networkservices

package
v7.20.0 Latest Latest
Warning

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

 Go to latest Published: Apr 24, 2024 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"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// Set of label tags associated with the EdgeCache resource.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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"`
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
	// 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

## Example Usage

### Network Services Edge Cache Keyset Basic

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/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{
			Name:        pulumi.String("my-keyset"),
			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/v7/go/gcp/networkservices"
"github.com/pulumi/pulumi-gcp/sdk/v7/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{
				Auto: nil,
			},
		})
		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{
			Name:        pulumi.String("my-keyset"),
			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:

* `projects/{{project}}/locations/global/edgeCacheKeysets/{{name}}`

* `{{project}}/{{name}}`

* `{{name}}`

When using the `pulumi import` command, EdgeCacheKeyset can be imported using one of the formats above. For example:

```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.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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 

func (o EdgeCacheKeysetOutput) Description() pulumi.StringPtrOutput

A human-readable description of the resource.

func (EdgeCacheKeysetOutput) EffectiveLabels 

func (o EdgeCacheKeysetOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (EdgeCacheKeysetOutput) ElementType 

func (EdgeCacheKeysetOutput) ElementType() reflect.Type

func (EdgeCacheKeysetOutput) Labels 

func (o EdgeCacheKeysetOutput) Labels() pulumi.StringMapOutput

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

func (EdgeCacheKeysetOutput) Name 

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 

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 

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) PulumiLabels 

func (o EdgeCacheKeysetOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider.

func (EdgeCacheKeysetOutput) ToEdgeCacheKeysetOutput 

func (o EdgeCacheKeysetOutput) ToEdgeCacheKeysetOutput() EdgeCacheKeysetOutput

func (EdgeCacheKeysetOutput) ToEdgeCacheKeysetOutputWithContext 

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

func (EdgeCacheKeysetOutput) ValidationSharedKeys 

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 

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
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// Set of label tags associated with the EdgeCache resource.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
	// 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 

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 

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 

func (EdgeCacheKeysetValidationSharedKeyArgs) ElementType() reflect.Type

func (EdgeCacheKeysetValidationSharedKeyArgs) ToEdgeCacheKeysetValidationSharedKeyOutput 

func (i EdgeCacheKeysetValidationSharedKeyArgs) ToEdgeCacheKeysetValidationSharedKeyOutput() EdgeCacheKeysetValidationSharedKeyOutput

func (EdgeCacheKeysetValidationSharedKeyArgs) ToEdgeCacheKeysetValidationSharedKeyOutputWithContext 

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

type EdgeCacheKeysetValidationSharedKeyArray 

type EdgeCacheKeysetValidationSharedKeyArray []EdgeCacheKeysetValidationSharedKeyInput

func (EdgeCacheKeysetValidationSharedKeyArray) ElementType 

func (EdgeCacheKeysetValidationSharedKeyArray) ElementType() reflect.Type

func (EdgeCacheKeysetValidationSharedKeyArray) ToEdgeCacheKeysetValidationSharedKeyArrayOutput 

func (i EdgeCacheKeysetValidationSharedKeyArray) ToEdgeCacheKeysetValidationSharedKeyArrayOutput() EdgeCacheKeysetValidationSharedKeyArrayOutput

func (EdgeCacheKeysetValidationSharedKeyArray) ToEdgeCacheKeysetValidationSharedKeyArrayOutputWithContext 

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

type EdgeCacheKeysetValidationSharedKeyArrayInput 

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 

type EdgeCacheKeysetValidationSharedKeyArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheKeysetValidationSharedKeyArrayOutput) ElementType 

func (EdgeCacheKeysetValidationSharedKeyArrayOutput) ElementType() reflect.Type

func (EdgeCacheKeysetValidationSharedKeyArrayOutput) Index 

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

func (EdgeCacheKeysetValidationSharedKeyArrayOutput) ToEdgeCacheKeysetValidationSharedKeyArrayOutput 

func (o EdgeCacheKeysetValidationSharedKeyArrayOutput) ToEdgeCacheKeysetValidationSharedKeyArrayOutput() EdgeCacheKeysetValidationSharedKeyArrayOutput

func (EdgeCacheKeysetValidationSharedKeyArrayOutput) ToEdgeCacheKeysetValidationSharedKeyArrayOutputWithContext 

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

type EdgeCacheKeysetValidationSharedKeyInput 

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 

type EdgeCacheKeysetValidationSharedKeyOutput struct{ *pulumi.OutputState }

func (EdgeCacheKeysetValidationSharedKeyOutput) ElementType 

func (EdgeCacheKeysetValidationSharedKeyOutput) ElementType() reflect.Type

func (EdgeCacheKeysetValidationSharedKeyOutput) SecretVersion 

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 

func (o EdgeCacheKeysetValidationSharedKeyOutput) ToEdgeCacheKeysetValidationSharedKeyOutput() EdgeCacheKeysetValidationSharedKeyOutput

func (EdgeCacheKeysetValidationSharedKeyOutput) ToEdgeCacheKeysetValidationSharedKeyOutputWithContext 

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"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// 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.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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"`
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
	// 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.

To get more information about EdgeCacheOrigin, see:

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

## Example Usage

### Network Services Edge Cache Origin Basic

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networkservices.NewEdgeCacheOrigin(ctx, "default", &networkservices.EdgeCacheOriginArgs{
			Name:          pulumi.String("my-origin"),
			OriginAddress: pulumi.String("gs://media-edge-default"),
			Description:   pulumi.String("The default bucket for media edge test"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fallback, err := networkservices.NewEdgeCacheOrigin(ctx, "fallback", &networkservices.EdgeCacheOriginArgs{
			Name:          pulumi.String("my-fallback"),
			OriginAddress: pulumi.String("fallback.example.com"),
			Description:   pulumi.String("The default bucket for media edge test"),
			MaxAttempts:   pulumi.Int(3),
			Protocol:      pulumi.String("HTTP"),
			Port:          pulumi.Int(80),
			RetryConditions: pulumi.StringArray{
				pulumi.String("CONNECT_FAILURE"),
				pulumi.String("NOT_FOUND"),
				pulumi.String("HTTP_5XX"),
				pulumi.String("FORBIDDEN"),
			},
			Timeout: &networkservices.EdgeCacheOriginTimeoutArgs{
				ConnectTimeout:     pulumi.String("10s"),
				MaxAttemptsTimeout: pulumi.String("20s"),
				ResponseTimeout:    pulumi.String("60s"),
				ReadTimeout:        pulumi.String("5s"),
			},
			OriginOverrideAction: &networkservices.EdgeCacheOriginOriginOverrideActionArgs{
				UrlRewrite: &networkservices.EdgeCacheOriginOriginOverrideActionUrlRewriteArgs{
					HostRewrite: pulumi.String("example.com"),
				},
				HeaderAction: &networkservices.EdgeCacheOriginOriginOverrideActionHeaderActionArgs{
					RequestHeadersToAdds: networkservices.EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray{
						&networkservices.EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs{
							HeaderName:  pulumi.String("x-header"),
							HeaderValue: pulumi.String("value"),
							Replace:     pulumi.Bool(true),
						},
					},
				},
			},
			OriginRedirect: &networkservices.EdgeCacheOriginOriginRedirectArgs{
				RedirectConditions: pulumi.StringArray{
					pulumi.String("MOVED_PERMANENTLY"),
					pulumi.String("FOUND"),
					pulumi.String("SEE_OTHER"),
					pulumi.String("TEMPORARY_REDIRECT"),
					pulumi.String("PERMANENT_REDIRECT"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheOrigin(ctx, "default", &networkservices.EdgeCacheOriginArgs{
			Name:           pulumi.String("my-origin"),
			OriginAddress:  pulumi.String("gs://media-edge-default"),
			FailoverOrigin: fallback.ID(),
			Description:    pulumi.String("The default bucket for media edge test"),
			MaxAttempts:    pulumi.Int(2),
			Labels: pulumi.StringMap{
				"a": pulumi.String("b"),
			},
			Timeout: &networkservices.EdgeCacheOriginTimeoutArgs{
				ConnectTimeout: pulumi.String("10s"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/networkservices"
"github.com/pulumi/pulumi-gcp/sdk/v7/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{
				Auto: nil,
			},
		})
		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{
			Name:          pulumi.String("my-origin"),
			OriginAddress: pulumi.String("gs://media-edge-default"),
			Description:   pulumi.String("The default bucket for V4 authentication"),
			AwsV4Authentication: &networkservices.EdgeCacheOriginAwsV4AuthenticationArgs{
				AccessKeyId:            pulumi.String("ACCESSKEYID"),
				SecretAccessKeyVersion: secret_version_basic.ID(),
				OriginRegion:           pulumi.String("auto"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

EdgeCacheOrigin can be imported using any of these accepted formats:

* `projects/{{project}}/locations/global/edgeCacheOrigins/{{name}}`

* `{{project}}/{{name}}`

* `{{name}}`

When using the `pulumi import` command, EdgeCacheOrigin can be imported using one of the formats above. For example:

```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.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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 

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 

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 

func (EdgeCacheOriginAwsV4AuthenticationArgs) ElementType() reflect.Type

func (EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationOutput 

func (i EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationOutput() EdgeCacheOriginAwsV4AuthenticationOutput

func (EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationOutputWithContext 

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

func (EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationPtrOutput 

func (i EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationPtrOutput() EdgeCacheOriginAwsV4AuthenticationPtrOutput

func (EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationPtrOutputWithContext 

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

type EdgeCacheOriginAwsV4AuthenticationInput 

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 

type EdgeCacheOriginAwsV4AuthenticationOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginAwsV4AuthenticationOutput) AccessKeyId 

func (o EdgeCacheOriginAwsV4AuthenticationOutput) AccessKeyId() pulumi.StringOutput

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

func (EdgeCacheOriginAwsV4AuthenticationOutput) ElementType 

func (EdgeCacheOriginAwsV4AuthenticationOutput) ElementType() reflect.Type

func (EdgeCacheOriginAwsV4AuthenticationOutput) OriginRegion 

func (o EdgeCacheOriginAwsV4AuthenticationOutput) OriginRegion() pulumi.StringOutput

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

func (EdgeCacheOriginAwsV4AuthenticationOutput) SecretAccessKeyVersion 

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 

func (o EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationOutput() EdgeCacheOriginAwsV4AuthenticationOutput

func (EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationOutputWithContext 

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

func (EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutput 

func (o EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutput() EdgeCacheOriginAwsV4AuthenticationPtrOutput

func (EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutputWithContext 

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

type EdgeCacheOriginAwsV4AuthenticationPtrInput 

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 

func EdgeCacheOriginAwsV4AuthenticationPtr(v *EdgeCacheOriginAwsV4AuthenticationArgs) EdgeCacheOriginAwsV4AuthenticationPtrInput

type EdgeCacheOriginAwsV4AuthenticationPtrOutput 

type EdgeCacheOriginAwsV4AuthenticationPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) AccessKeyId 

func (o EdgeCacheOriginAwsV4AuthenticationPtrOutput) AccessKeyId() pulumi.StringPtrOutput

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

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) Elem 

func (o EdgeCacheOriginAwsV4AuthenticationPtrOutput) Elem() EdgeCacheOriginAwsV4AuthenticationOutput

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) ElementType 

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) ElementType() reflect.Type

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) OriginRegion 

func (o EdgeCacheOriginAwsV4AuthenticationPtrOutput) OriginRegion() pulumi.StringPtrOutput

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

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) SecretAccessKeyVersion 

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 

func (o EdgeCacheOriginAwsV4AuthenticationPtrOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutput() EdgeCacheOriginAwsV4AuthenticationPtrOutput

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutputWithContext 

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 

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 

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 

func (EdgeCacheOriginOriginOverrideActionArgs) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionOutput 

func (i EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionOutput() EdgeCacheOriginOriginOverrideActionOutput

func (EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionOutputWithContext 

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

func (EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionPtrOutput 

func (i EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionPtrOutput() EdgeCacheOriginOriginOverrideActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionPtrOutputWithContext 

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

type EdgeCacheOriginOriginOverrideActionHeaderAction 

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 

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 

func (EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutput 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutput() EdgeCacheOriginOriginOverrideActionHeaderActionOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutputWithContext 

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

func (EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput() EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutputWithContext 

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

type EdgeCacheOriginOriginOverrideActionHeaderActionInput 

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 

type EdgeCacheOriginOriginOverrideActionHeaderActionOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ElementType 

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) RequestHeadersToAdds 

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 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutput() EdgeCacheOriginOriginOverrideActionHeaderActionOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutputWithContext 

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

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput() EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutputWithContext 

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

type EdgeCacheOriginOriginOverrideActionHeaderActionPtrInput 

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 

func EdgeCacheOriginOriginOverrideActionHeaderActionPtr(v *EdgeCacheOriginOriginOverrideActionHeaderActionArgs) EdgeCacheOriginOriginOverrideActionHeaderActionPtrInput

type EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput 

type EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) Elem 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) Elem() EdgeCacheOriginOriginOverrideActionHeaderActionOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) ElementType 

func (EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) RequestHeadersToAdds 

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 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput() EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutputWithContext 

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

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAdd 

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 

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 

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutputWithContext 

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

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray 

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray []EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddInput

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray) ElementType 

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutputWithContext 

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

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayInput 

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 

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) ElementType 

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) Index 

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

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutputWithContext 

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

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddInput 

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 

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) ElementType 

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) HeaderName 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) HeaderName() pulumi.StringOutput

The name of the header to add.

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) HeaderValue 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) HeaderValue() pulumi.StringOutput

The value of the header to add.

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) Replace 

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 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutputWithContext 

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

type EdgeCacheOriginOriginOverrideActionInput 

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 

type EdgeCacheOriginOriginOverrideActionOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionOutput) ElementType 

func (EdgeCacheOriginOriginOverrideActionOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionOutput) HeaderAction 

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 

func (o EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionOutput() EdgeCacheOriginOriginOverrideActionOutput

func (EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionOutputWithContext 

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

func (EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutput 

func (o EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutput() EdgeCacheOriginOriginOverrideActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutputWithContext 

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

func (EdgeCacheOriginOriginOverrideActionOutput) UrlRewrite 

func (o EdgeCacheOriginOriginOverrideActionOutput) UrlRewrite() EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

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

type EdgeCacheOriginOriginOverrideActionPtrInput 

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 

func EdgeCacheOriginOriginOverrideActionPtr(v *EdgeCacheOriginOriginOverrideActionArgs) EdgeCacheOriginOriginOverrideActionPtrInput

type EdgeCacheOriginOriginOverrideActionPtrOutput 

type EdgeCacheOriginOriginOverrideActionPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionPtrOutput) Elem 

func (o EdgeCacheOriginOriginOverrideActionPtrOutput) Elem() EdgeCacheOriginOriginOverrideActionOutput

func (EdgeCacheOriginOriginOverrideActionPtrOutput) ElementType 

func (EdgeCacheOriginOriginOverrideActionPtrOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionPtrOutput) HeaderAction 

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 

func (o EdgeCacheOriginOriginOverrideActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutput() EdgeCacheOriginOriginOverrideActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutputWithContext 

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

func (EdgeCacheOriginOriginOverrideActionPtrOutput) UrlRewrite 

func (o EdgeCacheOriginOriginOverrideActionPtrOutput) UrlRewrite() EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

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

type EdgeCacheOriginOriginOverrideActionUrlRewrite 

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 

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 

func (EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutput 

func (i EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutput() EdgeCacheOriginOriginOverrideActionUrlRewriteOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutputWithContext 

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

func (EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput 

func (i EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput() EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutputWithContext 

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

type EdgeCacheOriginOriginOverrideActionUrlRewriteInput 

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 

type EdgeCacheOriginOriginOverrideActionUrlRewriteOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ElementType 

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) HostRewrite 

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 

func (o EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutput() EdgeCacheOriginOriginOverrideActionUrlRewriteOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutputWithContext 

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

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput 

func (o EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput() EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutputWithContext 

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

type EdgeCacheOriginOriginOverrideActionUrlRewritePtrInput 

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 

func EdgeCacheOriginOriginOverrideActionUrlRewritePtr(v *EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) EdgeCacheOriginOriginOverrideActionUrlRewritePtrInput

type EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput 

type EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) Elem 

func (o EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) Elem() EdgeCacheOriginOriginOverrideActionUrlRewriteOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) ElementType 

func (EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) HostRewrite 

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 

func (o EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput() EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutputWithContext 

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

type EdgeCacheOriginOriginRedirect 

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 

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 

func (EdgeCacheOriginOriginRedirectArgs) ElementType() reflect.Type

func (EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectOutput 

func (i EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectOutput() EdgeCacheOriginOriginRedirectOutput

func (EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectOutputWithContext 

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

func (EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectPtrOutput 

func (i EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectPtrOutput() EdgeCacheOriginOriginRedirectPtrOutput

func (EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectPtrOutputWithContext 

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

type EdgeCacheOriginOriginRedirectInput 

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 

type EdgeCacheOriginOriginRedirectOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginRedirectOutput) ElementType 

func (EdgeCacheOriginOriginRedirectOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginRedirectOutput) RedirectConditions 

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 

func (o EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectOutput() EdgeCacheOriginOriginRedirectOutput

func (EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectOutputWithContext 

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

func (EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectPtrOutput 

func (o EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectPtrOutput() EdgeCacheOriginOriginRedirectPtrOutput

func (EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectPtrOutputWithContext 

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

type EdgeCacheOriginOriginRedirectPtrInput 

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 

func EdgeCacheOriginOriginRedirectPtr(v *EdgeCacheOriginOriginRedirectArgs) EdgeCacheOriginOriginRedirectPtrInput

type EdgeCacheOriginOriginRedirectPtrOutput 

type EdgeCacheOriginOriginRedirectPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginRedirectPtrOutput) Elem 

func (o EdgeCacheOriginOriginRedirectPtrOutput) Elem() EdgeCacheOriginOriginRedirectOutput

func (EdgeCacheOriginOriginRedirectPtrOutput) ElementType 

func (EdgeCacheOriginOriginRedirectPtrOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginRedirectPtrOutput) RedirectConditions 

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 

func (o EdgeCacheOriginOriginRedirectPtrOutput) ToEdgeCacheOriginOriginRedirectPtrOutput() EdgeCacheOriginOriginRedirectPtrOutput

func (EdgeCacheOriginOriginRedirectPtrOutput) ToEdgeCacheOriginOriginRedirectPtrOutputWithContext 

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

type EdgeCacheOriginOutput 

type EdgeCacheOriginOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOutput) AwsV4Authentication 

func (o EdgeCacheOriginOutput) AwsV4Authentication() EdgeCacheOriginAwsV4AuthenticationPtrOutput

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

func (EdgeCacheOriginOutput) Description 

func (o EdgeCacheOriginOutput) Description() pulumi.StringPtrOutput

A human-readable description of the resource.

func (EdgeCacheOriginOutput) EffectiveLabels 

func (o EdgeCacheOriginOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (EdgeCacheOriginOutput) ElementType 

func (EdgeCacheOriginOutput) ElementType() reflect.Type

func (EdgeCacheOriginOutput) FailoverOrigin 

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 

func (o EdgeCacheOriginOutput) Labels() pulumi.StringMapOutput

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

func (EdgeCacheOriginOutput) MaxAttempts 

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 

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 

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 

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 

func (o EdgeCacheOriginOutput) OriginRedirect() EdgeCacheOriginOriginRedirectPtrOutput

Follow redirects from this origin. Structure is documented below.

func (EdgeCacheOriginOutput) Port 

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 

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 

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) PulumiLabels 

func (o EdgeCacheOriginOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider.

func (EdgeCacheOriginOutput) RetryConditions 

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 

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
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// 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.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
	// 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 

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 

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 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"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// 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. **Note**: This field is non-authoritative, and will only
	// manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
	// present on the resource.
	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.
	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"`
	Project pulumi.StringOutput `pulumi:"project"`
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
	// 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/v7/go/gcp/networkservices"
"github.com/pulumi/pulumi-gcp/sdk/v7/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{
			Name:         pulumi.String("my-bucket"),
			Location:     pulumi.String("US"),
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		instance, err := networkservices.NewEdgeCacheOrigin(ctx, "instance", &networkservices.EdgeCacheOriginArgs{
			Name:          pulumi.String("my-origin"),
			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, "instance", &networkservices.EdgeCacheServiceArgs{
			Name:        pulumi.String("my-service"),
			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: instance.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/v7/go/gcp/networkservices"
"github.com/pulumi/pulumi-gcp/sdk/v7/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{
			Name:         pulumi.String("my-bucket"),
			Location:     pulumi.String("US"),
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheOrigin(ctx, "google", &networkservices.EdgeCacheOriginArgs{
			Name:          pulumi.String("origin-google"),
			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
		}
		instance, err := networkservices.NewEdgeCacheOrigin(ctx, "instance", &networkservices.EdgeCacheOriginArgs{
			Name:          pulumi.String("my-origin"),
			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, "instance", &networkservices.EdgeCacheServiceArgs{
			Name:         pulumi.String("my-service"),
			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: instance.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: instance.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: instance.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
	})
}

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

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/networkservices"
"github.com/pulumi/pulumi-gcp/sdk/v7/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{
				Auto: nil,
			},
		})
		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
		}
		keyset, err := networkservices.NewEdgeCacheKeyset(ctx, "keyset", &networkservices.EdgeCacheKeysetArgs{
			Name:        pulumi.String("keyset-name"),
			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
		}
		instance, err := networkservices.NewEdgeCacheOrigin(ctx, "instance", &networkservices.EdgeCacheOriginArgs{
			Name:          pulumi.String("my-origin"),
			OriginAddress: pulumi.String("gs://media-edge-default"),
			Description:   pulumi.String("The default bucket for media edge test"),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheService(ctx, "instance", &networkservices.EdgeCacheServiceArgs{
			Name:        pulumi.String("my-service"),
			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 master playlist"),
								Priority:    pulumi.String("1"),
								MatchRules: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray{
									&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs{
										PathTemplateMatch: pulumi.String("/master.m3u8"),
									},
								},
								Origin: instance.Name,
								RouteAction: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs{
									CdnPolicy: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs{
										SignedRequestMode:   pulumi.String("REQUIRE_TOKENS"),
										SignedRequestKeyset: keyset.ID(),
										SignedTokenOptions: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs{
											TokenQueryParameter: pulumi.String("edge-cache-token"),
										},
										SignedRequestMaximumExpirationTtl: pulumi.String("600s"),
										AddSignatures: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs{
											Actions: pulumi.String("GENERATE_COOKIE"),
											Keyset:  keyset.ID(),
											CopiedParameters: pulumi.StringArray{
												pulumi.String("PathGlobs"),
												pulumi.String("SessionID"),
											},
										},
									},
								},
							},
							&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleArgs{
								Description: pulumi.String("a route rule to match against all playlists"),
								Priority:    pulumi.String("2"),
								MatchRules: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray{
									&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs{
										PathTemplateMatch: pulumi.String("/*.m3u8"),
									},
								},
								Origin: instance.Name,
								RouteAction: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs{
									CdnPolicy: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs{
										SignedRequestMode:   pulumi.String("REQUIRE_TOKENS"),
										SignedRequestKeyset: keyset.ID(),
										SignedTokenOptions: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs{
											TokenQueryParameter: pulumi.String("hdnts"),
											AllowedSignatureAlgorithms: pulumi.StringArray{
												pulumi.String("ED25519"),
												pulumi.String("HMAC_SHA_256"),
												pulumi.String("HMAC_SHA1"),
											},
										},
										AddSignatures: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs{
											Actions:             pulumi.String("GENERATE_TOKEN_HLS_COOKIELESS"),
											Keyset:              keyset.ID(),
											TokenTtl:            pulumi.String("1200s"),
											TokenQueryParameter: pulumi.String("hdntl"),
											CopiedParameters: pulumi.StringArray{
												pulumi.String("URLPrefix"),
											},
										},
									},
								},
							},
							&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleArgs{
								Description: pulumi.String("a route rule to match against"),
								Priority:    pulumi.String("3"),
								MatchRules: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray{
									&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs{
										PathTemplateMatch: pulumi.String("/**.m3u8"),
									},
								},
								Origin: instance.Name,
								RouteAction: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs{
									CdnPolicy: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs{
										SignedRequestMode:   pulumi.String("REQUIRE_TOKENS"),
										SignedRequestKeyset: keyset.ID(),
										SignedTokenOptions: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs{
											TokenQueryParameter: pulumi.String("hdntl"),
										},
										AddSignatures: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs{
											Actions:             pulumi.String("PROPAGATE_TOKEN_HLS_COOKIELESS"),
											TokenQueryParameter: pulumi.String("hdntl"),
										},
									},
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

EdgeCacheService can be imported using any of these accepted formats:

* `projects/{{project}}/locations/global/edgeCacheServices/{{name}}`

* `{{project}}/{{name}}`

* `{{name}}`

When using the `pulumi import` command, EdgeCacheService can be imported using one of the formats above. For example:

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

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

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

func GetEdgeCacheService 

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

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

func NewEdgeCacheService 

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

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

func (*EdgeCacheService) ElementType 

func (*EdgeCacheService) ElementType() reflect.Type

func (*EdgeCacheService) ToEdgeCacheServiceOutput 

func (i *EdgeCacheService) ToEdgeCacheServiceOutput() EdgeCacheServiceOutput

func (*EdgeCacheService) ToEdgeCacheServiceOutputWithContext 

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

type EdgeCacheServiceArgs 

type EdgeCacheServiceArgs struct {
	// A human-readable description of the resource.
	Description pulumi.StringPtrInput
	// Disables HTTP/2. HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use
	// and reduces connection setup overhead by sending multiple streams over the same connection. Some legacy HTTP clients may
	// have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from
	// being advertised and negotiated.
	DisableHttp2 pulumi.BoolPtrInput
	// HTTP/3 (IETF QUIC) and Google QUIC are enabled by default.
	DisableQuic pulumi.BoolPtrInput
	// Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the
	// EdgeCacheService.
	EdgeSecurityPolicy pulumi.StringPtrInput
	// URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService. Note
	// that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
	EdgeSslCertificates pulumi.StringArrayInput
	// Set of label tags associated with the EdgeCache resource. **Note**: This field is non-authoritative, and will only
	// manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
	// present on the resource.
	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.
	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
	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 

func (o EdgeCacheServiceOutput) Description() pulumi.StringPtrOutput

A human-readable description of the resource.

func (EdgeCacheServiceOutput) DisableHttp2 

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 

func (o EdgeCacheServiceOutput) DisableQuic() pulumi.BoolOutput

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

func (EdgeCacheServiceOutput) EdgeSecurityPolicy 

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 

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) EffectiveLabels 

func (o EdgeCacheServiceOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (EdgeCacheServiceOutput) ElementType 

func (EdgeCacheServiceOutput) ElementType() reflect.Type

func (EdgeCacheServiceOutput) Ipv4Addresses 

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 

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 

func (o EdgeCacheServiceOutput) Labels() pulumi.StringMapOutput

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

func (EdgeCacheServiceOutput) LogConfig 

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.

func (EdgeCacheServiceOutput) Name 

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 

func (o EdgeCacheServiceOutput) Project() pulumi.StringOutput

func (EdgeCacheServiceOutput) PulumiLabels 

func (o EdgeCacheServiceOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider.

func (EdgeCacheServiceOutput) RequireTls 

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 

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 

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 

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 

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 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutputWithContext 

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

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutputWithContext 

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

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesInput 

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 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) Actions 

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 

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 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) Keyset 

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 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutputWithContext 

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

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutputWithContext 

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

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) TokenQueryParameter 

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 

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 

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 

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtr(v *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrInput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) Actions 

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 

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 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) Elem() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) Keyset 

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 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutputWithContext 

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

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) TokenQueryParameter 

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 

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 

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 

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 

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 

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 

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 

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 

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 

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 

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 

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 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutputWithContext 

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

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutputWithContext 

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

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsInput 

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 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) AllowedSignatureAlgorithms 

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 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutputWithContext 

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

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutputWithContext 

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

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) TokenQueryParameter 

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 

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 

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtr(v *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrInput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) AllowedSignatureAlgorithms 

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 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) Elem() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutputWithContext 

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

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) TokenQueryParameter 

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 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
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// 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. **Note**: This field is non-authoritative, and will only
	// manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
	// present on the resource.
	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.
	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
	Project pulumi.StringPtrInput
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
	// 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 

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"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// 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. **Note**: This field is non-authoritative, and will only manage
	// the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on
	// the resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Name of the EndpointPolicy resource.
	Name    pulumi.StringOutput `pulumi:"name"`
	Project pulumi.StringOutput `pulumi:"project"`
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
	// 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.
	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/v7/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{
			Name: pulumi.String("my-endpoint-policy"),
			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"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/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{
			Name: pulumi.String("my-endpoint-policy"),
			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"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

EndpointPolicy can be imported using any of these accepted formats:

* `projects/{{project}}/locations/global/endpointPolicies/{{name}}`

* `{{project}}/{{name}}`

* `{{name}}`

When using the `pulumi import` command, EndpointPolicy can be imported using one of the formats above. For example:

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

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 

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 

func (*EndpointPolicy) ElementType() reflect.Type

func (*EndpointPolicy) ToEndpointPolicyOutput 

func (i *EndpointPolicy) ToEndpointPolicyOutput() EndpointPolicyOutput

func (*EndpointPolicy) ToEndpointPolicyOutputWithContext 

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

type EndpointPolicyArgs 

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. **Note**: This field is non-authoritative, and will only manage
	// the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on
	// the resource.
	Labels pulumi.StringMapInput
	// Name of the EndpointPolicy resource.
	Name    pulumi.StringPtrInput
	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.
	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 

func (EndpointPolicyArgs) ElementType() reflect.Type

type EndpointPolicyArray 

type EndpointPolicyArray []EndpointPolicyInput

func (EndpointPolicyArray) ElementType 

func (EndpointPolicyArray) ElementType() reflect.Type

func (EndpointPolicyArray) ToEndpointPolicyArrayOutput 

func (i EndpointPolicyArray) ToEndpointPolicyArrayOutput() EndpointPolicyArrayOutput

func (EndpointPolicyArray) ToEndpointPolicyArrayOutputWithContext 

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

type EndpointPolicyArrayInput 

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 

type EndpointPolicyArrayOutput struct{ *pulumi.OutputState }

func (EndpointPolicyArrayOutput) ElementType 

func (EndpointPolicyArrayOutput) ElementType() reflect.Type

func (EndpointPolicyArrayOutput) Index 

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

func (EndpointPolicyArrayOutput) ToEndpointPolicyArrayOutput 

func (o EndpointPolicyArrayOutput) ToEndpointPolicyArrayOutput() EndpointPolicyArrayOutput

func (EndpointPolicyArrayOutput) ToEndpointPolicyArrayOutputWithContext 

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

type EndpointPolicyEndpointMatcher 

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

type EndpointPolicyEndpointMatcherArgs 

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 

func (EndpointPolicyEndpointMatcherArgs) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherOutput 

func (i EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherOutput() EndpointPolicyEndpointMatcherOutput

func (EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherOutputWithContext 

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

func (EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherPtrOutput 

func (i EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherPtrOutput() EndpointPolicyEndpointMatcherPtrOutput

func (EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherPtrOutputWithContext 

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

type EndpointPolicyEndpointMatcherInput 

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 

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 

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 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutput 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutputWithContext 

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

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutputWithContext 

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

type EndpointPolicyEndpointMatcherMetadataLabelMatcherInput 

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 

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 

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 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutputWithContext 

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

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray []EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelInput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray) ElementType 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutputWithContext 

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

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayInput 

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 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) ElementType 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) Index 

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

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutputWithContext 

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

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelInput 

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 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) ElementType 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) LabelName 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) LabelName() pulumi.StringOutput

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

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) LabelValue 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) LabelValue() pulumi.StringOutput

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

***

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutputWithContext 

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

type EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ElementType 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) MetadataLabelMatchCriteria 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) MetadataLabelMatchCriteria() pulumi.StringOutput

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

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) MetadataLabels 

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 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutputWithContext 

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

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutputWithContext 

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

type EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrInput 

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 

func EndpointPolicyEndpointMatcherMetadataLabelMatcherPtr(v *EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrInput

type EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) Elem 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) Elem() EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) ElementType 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) MetadataLabelMatchCriteria 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) MetadataLabelMatchCriteria() pulumi.StringPtrOutput

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

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) MetadataLabels 

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 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutputWithContext 

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

type EndpointPolicyEndpointMatcherOutput 

type EndpointPolicyEndpointMatcherOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherOutput) ElementType 

func (EndpointPolicyEndpointMatcherOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherOutput) MetadataLabelMatcher 

func (o EndpointPolicyEndpointMatcherOutput) MetadataLabelMatcher() EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput

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

func (EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherOutput 

func (o EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherOutput() EndpointPolicyEndpointMatcherOutput

func (EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherOutputWithContext 

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

func (EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherPtrOutput 

func (o EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherPtrOutput() EndpointPolicyEndpointMatcherPtrOutput

func (EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherPtrOutputWithContext 

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

type EndpointPolicyEndpointMatcherPtrInput 

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 

func EndpointPolicyEndpointMatcherPtr(v *EndpointPolicyEndpointMatcherArgs) EndpointPolicyEndpointMatcherPtrInput

type EndpointPolicyEndpointMatcherPtrOutput 

type EndpointPolicyEndpointMatcherPtrOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherPtrOutput) Elem 

func (o EndpointPolicyEndpointMatcherPtrOutput) Elem() EndpointPolicyEndpointMatcherOutput

func (EndpointPolicyEndpointMatcherPtrOutput) ElementType 

func (EndpointPolicyEndpointMatcherPtrOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherPtrOutput) MetadataLabelMatcher 

func (o EndpointPolicyEndpointMatcherPtrOutput) MetadataLabelMatcher() EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput

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

func (EndpointPolicyEndpointMatcherPtrOutput) ToEndpointPolicyEndpointMatcherPtrOutput 

func (o EndpointPolicyEndpointMatcherPtrOutput) ToEndpointPolicyEndpointMatcherPtrOutput() EndpointPolicyEndpointMatcherPtrOutput

func (EndpointPolicyEndpointMatcherPtrOutput) ToEndpointPolicyEndpointMatcherPtrOutputWithContext 

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

type EndpointPolicyInput 

type EndpointPolicyInput interface {
	pulumi.Input

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

type EndpointPolicyMap 

type EndpointPolicyMap map[string]EndpointPolicyInput

func (EndpointPolicyMap) ElementType 

func (EndpointPolicyMap) ElementType() reflect.Type

func (EndpointPolicyMap) ToEndpointPolicyMapOutput 

func (i EndpointPolicyMap) ToEndpointPolicyMapOutput() EndpointPolicyMapOutput

func (EndpointPolicyMap) ToEndpointPolicyMapOutputWithContext 

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

type EndpointPolicyMapInput 

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 

type EndpointPolicyMapOutput struct{ *pulumi.OutputState }

func (EndpointPolicyMapOutput) ElementType 

func (EndpointPolicyMapOutput) ElementType() reflect.Type

func (EndpointPolicyMapOutput) MapIndex 

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

func (EndpointPolicyMapOutput) ToEndpointPolicyMapOutput 

func (o EndpointPolicyMapOutput) ToEndpointPolicyMapOutput() EndpointPolicyMapOutput

func (EndpointPolicyMapOutput) ToEndpointPolicyMapOutputWithContext 

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

type EndpointPolicyOutput 

type EndpointPolicyOutput struct{ *pulumi.OutputState }

func (EndpointPolicyOutput) AuthorizationPolicy 

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 

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 

func (o EndpointPolicyOutput) CreateTime() pulumi.StringOutput

Time the TcpRoute was created in UTC.

func (EndpointPolicyOutput) Description 

func (o EndpointPolicyOutput) Description() pulumi.StringPtrOutput

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

func (EndpointPolicyOutput) EffectiveLabels 

func (o EndpointPolicyOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (EndpointPolicyOutput) ElementType 

func (EndpointPolicyOutput) ElementType() reflect.Type

func (EndpointPolicyOutput) EndpointMatcher 

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 

func (o EndpointPolicyOutput) Labels() pulumi.StringMapOutput

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

func (EndpointPolicyOutput) Name 

func (o EndpointPolicyOutput) Name() pulumi.StringOutput

Name of the EndpointPolicy resource.

func (EndpointPolicyOutput) Project 

func (o EndpointPolicyOutput) Project() pulumi.StringOutput

func (EndpointPolicyOutput) PulumiLabels 

func (o EndpointPolicyOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider.

func (EndpointPolicyOutput) ServerTlsPolicy 

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 

func (o EndpointPolicyOutput) ToEndpointPolicyOutput() EndpointPolicyOutput

func (EndpointPolicyOutput) ToEndpointPolicyOutputWithContext 

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

func (EndpointPolicyOutput) TrafficPortSelector 

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.

func (EndpointPolicyOutput) Type 

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 

func (o EndpointPolicyOutput) UpdateTime() pulumi.StringOutput

Time the TcpRoute was updated in UTC.

type EndpointPolicyState 

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
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// 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. **Note**: This field is non-authoritative, and will only manage
	// the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on
	// the resource.
	Labels pulumi.StringMapInput
	// Name of the EndpointPolicy resource.
	Name    pulumi.StringPtrInput
	Project pulumi.StringPtrInput
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
	// 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.
	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 

func (EndpointPolicyState) ElementType() reflect.Type

type EndpointPolicyTrafficPortSelector 

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 

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 

func (EndpointPolicyTrafficPortSelectorArgs) ElementType() reflect.Type

func (EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorOutput 

func (i EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorOutput() EndpointPolicyTrafficPortSelectorOutput

func (EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorOutputWithContext 

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

func (EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorPtrOutput 

func (i EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorPtrOutput() EndpointPolicyTrafficPortSelectorPtrOutput

func (EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorPtrOutputWithContext 

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

type EndpointPolicyTrafficPortSelectorInput 

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 

type EndpointPolicyTrafficPortSelectorOutput struct{ *pulumi.OutputState }

func (EndpointPolicyTrafficPortSelectorOutput) ElementType 

func (EndpointPolicyTrafficPortSelectorOutput) ElementType() reflect.Type

func (EndpointPolicyTrafficPortSelectorOutput) Ports 

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 

func (o EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorOutput() EndpointPolicyTrafficPortSelectorOutput

func (EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorOutputWithContext 

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

func (EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorPtrOutput 

func (o EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorPtrOutput() EndpointPolicyTrafficPortSelectorPtrOutput

func (EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorPtrOutputWithContext 

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

type EndpointPolicyTrafficPortSelectorPtrInput 

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 

func EndpointPolicyTrafficPortSelectorPtr(v *EndpointPolicyTrafficPortSelectorArgs) EndpointPolicyTrafficPortSelectorPtrInput

type EndpointPolicyTrafficPortSelectorPtrOutput 

type EndpointPolicyTrafficPortSelectorPtrOutput struct{ *pulumi.OutputState }

func (EndpointPolicyTrafficPortSelectorPtrOutput) Elem 

func (o EndpointPolicyTrafficPortSelectorPtrOutput) Elem() EndpointPolicyTrafficPortSelectorOutput

func (EndpointPolicyTrafficPortSelectorPtrOutput) ElementType 

func (EndpointPolicyTrafficPortSelectorPtrOutput) ElementType() reflect.Type

func (EndpointPolicyTrafficPortSelectorPtrOutput) Ports 

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 

func (o EndpointPolicyTrafficPortSelectorPtrOutput) ToEndpointPolicyTrafficPortSelectorPtrOutput() EndpointPolicyTrafficPortSelectorPtrOutput

func (EndpointPolicyTrafficPortSelectorPtrOutput) ToEndpointPolicyTrafficPortSelectorPtrOutputWithContext 

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

type Gateway 

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"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// 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.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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"`
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
	// 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/v7/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{
			Name:  pulumi.String("my-gateway"),
			Scope: pulumi.String("default-scope-basic"),
			Type:  pulumi.String("OPEN_MESH"),
			Ports: pulumi.IntArray{
				pulumi.Int(443),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Gateway Advanced

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/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{
			Name: pulumi.String("my-gateway"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Type:        pulumi.String("OPEN_MESH"),
			Ports: pulumi.IntArray{
				pulumi.Int(443),
			},
			Scope: pulumi.String("default-scope-advance"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "test-fixtures/cert.pem",
		}, nil)
		if err != nil {
			return err
		}
		invokeFile1, err := std.File(ctx, &std.FileArgs{
			Input: "test-fixtures/private-key.pem",
		}, nil)
		if err != nil {
			return err
		}
		_, err = certificatemanager.NewCertificate(ctx, "default", &certificatemanager.CertificateArgs{
			Name:     pulumi.String("my-certificate"),
			Location: pulumi.String("us-central1"),
			SelfManaged: &certificatemanager.CertificateSelfManagedArgs{
				PemCertificate: invokeFile.Result,
				PemPrivateKey:  invokeFile1.Result,
			},
		})
		if err != nil {
			return err
		}
		defaultNetwork, err := compute.NewNetwork(ctx, "default", &compute.NetworkArgs{
			Name:                  pulumi.String("my-network"),
			RoutingMode:           pulumi.String("REGIONAL"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		defaultSubnetwork, err := compute.NewSubnetwork(ctx, "default", &compute.SubnetworkArgs{
			Name:        pulumi.String("my-subnetwork-name"),
			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
		}
		_, err = compute.NewSubnetwork(ctx, "proxyonlysubnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("my-proxy-only-subnetwork"),
			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, "default", &networksecurity.GatewaySecurityPolicyArgs{
			Name:     pulumi.String("my-policy-name"),
			Location: pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		_, err = networksecurity.NewGatewaySecurityPolicyRule(ctx, "default", &networksecurity.GatewaySecurityPolicyRuleArgs{
			Name:                  pulumi.String("my-policyrule-name"),
			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, "default", &networkservices.GatewayArgs{
			Name:     pulumi.String("my-gateway1"),
			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{
				_default.ID(),
			},
			GatewaySecurityPolicy:           defaultGatewaySecurityPolicy.ID(),
			Network:                         defaultNetwork.ID(),
			Subnetwork:                      defaultSubnetwork.ID(),
			DeleteSwgAutogenRouterOnDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "test-fixtures/cert.pem",
		}, nil)
		if err != nil {
			return err
		}
		invokeFile1, err := std.File(ctx, &std.FileArgs{
			Input: "test-fixtures/private-key.pem",
		}, nil)
		if err != nil {
			return err
		}
		_, err = certificatemanager.NewCertificate(ctx, "default", &certificatemanager.CertificateArgs{
			Name:     pulumi.String("my-certificate"),
			Location: pulumi.String("us-south1"),
			SelfManaged: &certificatemanager.CertificateSelfManagedArgs{
				PemCertificate: invokeFile.Result,
				PemPrivateKey:  invokeFile1.Result,
			},
		})
		if err != nil {
			return err
		}
		defaultNetwork, err := compute.NewNetwork(ctx, "default", &compute.NetworkArgs{
			Name:                  pulumi.String("my-network"),
			RoutingMode:           pulumi.String("REGIONAL"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		defaultSubnetwork, err := compute.NewSubnetwork(ctx, "default", &compute.SubnetworkArgs{
			Name:        pulumi.String("my-subnetwork-name"),
			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
		}
		_, err = compute.NewSubnetwork(ctx, "proxyonlysubnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("my-proxy-only-subnetwork"),
			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, "default", &networksecurity.GatewaySecurityPolicyArgs{
			Name:     pulumi.String("my-policy-name"),
			Location: pulumi.String("us-south1"),
		})
		if err != nil {
			return err
		}
		_, err = networksecurity.NewGatewaySecurityPolicyRule(ctx, "default", &networksecurity.GatewaySecurityPolicyRuleArgs{
			Name:                  pulumi.String("my-policyrule-name"),
			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, "default", &networkservices.GatewayArgs{
			Name:     pulumi.String("my-gateway1"),
			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{
				_default.ID(),
			},
			GatewaySecurityPolicy:           defaultGatewaySecurityPolicy.ID(),
			Network:                         defaultNetwork.ID(),
			Subnetwork:                      defaultSubnetwork.ID(),
			DeleteSwgAutogenRouterOnDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewGateway(ctx, "gateway2", &networkservices.GatewayArgs{
			Name:     pulumi.String("my-gateway2"),
			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{
				_default.ID(),
			},
			GatewaySecurityPolicy:           defaultGatewaySecurityPolicy.ID(),
			Network:                         defaultNetwork.ID(),
			Subnetwork:                      defaultSubnetwork.ID(),
			DeleteSwgAutogenRouterOnDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Gateway can be imported using any of these accepted formats:

* `projects/{{project}}/locations/{{location}}/gateways/{{name}}`

* `{{project}}/{{location}}/{{name}}`

* `{{location}}/{{name}}`

When using the `pulumi import` command, Gateway can be imported using one of the formats above. For example:

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

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 

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 

func (*Gateway) ElementType() reflect.Type

func (*Gateway) ToGatewayOutput 

func (i *Gateway) ToGatewayOutput() GatewayOutput

func (*Gateway) ToGatewayOutputWithContext 

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

type GatewayArgs 

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.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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 

func (GatewayArgs) ElementType() reflect.Type

type GatewayArray 

type GatewayArray []GatewayInput

func (GatewayArray) ElementType 

func (GatewayArray) ElementType() reflect.Type

func (GatewayArray) ToGatewayArrayOutput 

func (i GatewayArray) ToGatewayArrayOutput() GatewayArrayOutput

func (GatewayArray) ToGatewayArrayOutputWithContext 

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

type GatewayArrayInput 

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 

type GatewayArrayOutput struct{ *pulumi.OutputState }

func (GatewayArrayOutput) ElementType 

func (GatewayArrayOutput) ElementType() reflect.Type

func (GatewayArrayOutput) Index 

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

func (GatewayArrayOutput) ToGatewayArrayOutput 

func (o GatewayArrayOutput) ToGatewayArrayOutput() GatewayArrayOutput

func (GatewayArrayOutput) ToGatewayArrayOutputWithContext 

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

type GatewayInput 

type GatewayInput interface {
	pulumi.Input

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

type GatewayMap 

type GatewayMap map[string]GatewayInput

func (GatewayMap) ElementType 

func (GatewayMap) ElementType() reflect.Type

func (GatewayMap) ToGatewayMapOutput 

func (i GatewayMap) ToGatewayMapOutput() GatewayMapOutput

func (GatewayMap) ToGatewayMapOutputWithContext 

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

type GatewayMapInput 

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 

type GatewayMapOutput struct{ *pulumi.OutputState }

func (GatewayMapOutput) ElementType 

func (GatewayMapOutput) ElementType() reflect.Type

func (GatewayMapOutput) MapIndex 

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

func (GatewayMapOutput) ToGatewayMapOutput 

func (o GatewayMapOutput) ToGatewayMapOutput() GatewayMapOutput

func (GatewayMapOutput) ToGatewayMapOutputWithContext 

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

type GatewayOutput 

type GatewayOutput struct{ *pulumi.OutputState }

func (GatewayOutput) Addresses 

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 

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 

func (o GatewayOutput) CreateTime() pulumi.StringOutput

Time the AccessPolicy was created in UTC.

func (GatewayOutput) DeleteSwgAutogenRouterOnDestroy 

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 

func (o GatewayOutput) Description() pulumi.StringPtrOutput

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

func (GatewayOutput) EffectiveLabels 

func (o GatewayOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (GatewayOutput) ElementType 

func (GatewayOutput) ElementType() reflect.Type

func (GatewayOutput) GatewaySecurityPolicy 

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 

func (o GatewayOutput) Labels() pulumi.StringMapOutput

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

func (GatewayOutput) Location 

func (o GatewayOutput) Location() pulumi.StringPtrOutput

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

func (GatewayOutput) Name 

func (o GatewayOutput) Name() pulumi.StringOutput

Short name of the Gateway resource to be created.

***

func (GatewayOutput) Network 

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 

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 

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) PulumiLabels 

func (o GatewayOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider.

func (GatewayOutput) Scope 

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 

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 

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 

func (o GatewayOutput) ToGatewayOutput() GatewayOutput

func (GatewayOutput) ToGatewayOutputWithContext 

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

func (GatewayOutput) Type 

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 

func (o GatewayOutput) UpdateTime() pulumi.StringOutput

Time the AccessPolicy was updated in UTC.

type GatewayState 

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
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// 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.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
	// 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 

func (GatewayState) ElementType() reflect.Type

type GrpcRoute 

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"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// 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. **Note**: This field is non-authoritative, and will only
	// manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
	// present on the resource.
	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"`
	Project pulumi.StringOutput `pulumi:"project"`
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
	// 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/v7/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{
			Name: pulumi.String("my-grpc-route"),
			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),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/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{
			Name: pulumi.String("my-grpc-route"),
			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),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Grpc Route Actions

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/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{
			Name: pulumi.String("my-grpc-route"),
			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),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

GrpcRoute can be imported using any of these accepted formats:

* `projects/{{project}}/locations/global/grpcRoutes/{{name}}`

* `{{project}}/{{name}}`

* `{{name}}`

When using the `pulumi import` command, GrpcRoute can be imported using one of the formats above. For example:

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

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 

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 

func (*GrpcRoute) ElementType() reflect.Type

func (*GrpcRoute) ToGrpcRouteOutput 

func (i *GrpcRoute) ToGrpcRouteOutput() GrpcRouteOutput

func (*GrpcRoute) ToGrpcRouteOutputWithContext 

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

type GrpcRouteArgs 

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. **Note**: This field is non-authoritative, and will only
	// manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
	// present on the resource.
	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
	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 

func (GrpcRouteArgs) ElementType() reflect.Type

type GrpcRouteArray 

type GrpcRouteArray []GrpcRouteInput

func (GrpcRouteArray) ElementType 

func (GrpcRouteArray) ElementType() reflect.Type

func (GrpcRouteArray) ToGrpcRouteArrayOutput 

func (i GrpcRouteArray) ToGrpcRouteArrayOutput() GrpcRouteArrayOutput

func (GrpcRouteArray) ToGrpcRouteArrayOutputWithContext 

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

type GrpcRouteArrayInput 

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 

type GrpcRouteArrayOutput struct{ *pulumi.OutputState }

func (GrpcRouteArrayOutput) ElementType 

func (GrpcRouteArrayOutput) ElementType() reflect.Type

func (GrpcRouteArrayOutput) Index 

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

func (GrpcRouteArrayOutput) ToGrpcRouteArrayOutput 

func (o GrpcRouteArrayOutput) ToGrpcRouteArrayOutput() GrpcRouteArrayOutput

func (GrpcRouteArrayOutput) ToGrpcRouteArrayOutputWithContext 

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

type GrpcRouteInput 

type GrpcRouteInput interface {
	pulumi.Input

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

type GrpcRouteMap 

type GrpcRouteMap map[string]GrpcRouteInput

func (GrpcRouteMap) ElementType 

func (GrpcRouteMap) ElementType() reflect.Type

func (GrpcRouteMap) ToGrpcRouteMapOutput 

func (i GrpcRouteMap) ToGrpcRouteMapOutput() GrpcRouteMapOutput

func (GrpcRouteMap) ToGrpcRouteMapOutputWithContext 

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

type GrpcRouteMapInput 

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 

type GrpcRouteMapOutput struct{ *pulumi.OutputState }

func (GrpcRouteMapOutput) ElementType 

func (GrpcRouteMapOutput) ElementType() reflect.Type

func (GrpcRouteMapOutput) MapIndex 

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

func (GrpcRouteMapOutput) ToGrpcRouteMapOutput 

func (o GrpcRouteMapOutput) ToGrpcRouteMapOutput() GrpcRouteMapOutput

func (GrpcRouteMapOutput) ToGrpcRouteMapOutputWithContext 

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

type GrpcRouteOutput 

type GrpcRouteOutput struct{ *pulumi.OutputState }

func (GrpcRouteOutput) CreateTime 

func (o GrpcRouteOutput) CreateTime() pulumi.StringOutput

Time the GrpcRoute was created in UTC.

func (GrpcRouteOutput) Description 

func (o GrpcRouteOutput) Description() pulumi.StringPtrOutput

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

func (GrpcRouteOutput) EffectiveLabels 

func (o GrpcRouteOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (GrpcRouteOutput) ElementType 

func (GrpcRouteOutput) ElementType() reflect.Type

func (GrpcRouteOutput) Gateways 

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 

func (o GrpcRouteOutput) Hostnames() pulumi.StringArrayOutput

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

func (GrpcRouteOutput) Labels 

func (o GrpcRouteOutput) Labels() pulumi.StringMapOutput

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

func (GrpcRouteOutput) Meshes 

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 

func (o GrpcRouteOutput) Name() pulumi.StringOutput

Name of the GrpcRoute resource.

func (GrpcRouteOutput) Project 

func (o GrpcRouteOutput) Project() pulumi.StringOutput

func (GrpcRouteOutput) PulumiLabels 

func (o GrpcRouteOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider.

func (GrpcRouteOutput) Rules 

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 

func (o GrpcRouteOutput) ToGrpcRouteOutput() GrpcRouteOutput

func (GrpcRouteOutput) ToGrpcRouteOutputWithContext 

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

func (GrpcRouteOutput) UpdateTime 

func (o GrpcRouteOutput) UpdateTime() pulumi.StringOutput

Time the GrpcRoute was updated in UTC.

type GrpcRouteRule 

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 

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 

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 

func (GrpcRouteRuleActionArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionOutput 

func (i GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionOutput() GrpcRouteRuleActionOutput

func (GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionOutputWithContext 

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

func (GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionPtrOutput 

func (i GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionPtrOutput() GrpcRouteRuleActionPtrOutput

func (GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionPtrOutputWithContext 

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

type GrpcRouteRuleActionDestination 

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 

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 

func (GrpcRouteRuleActionDestinationArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionDestinationArgs) ToGrpcRouteRuleActionDestinationOutput 

func (i GrpcRouteRuleActionDestinationArgs) ToGrpcRouteRuleActionDestinationOutput() GrpcRouteRuleActionDestinationOutput

func (GrpcRouteRuleActionDestinationArgs) ToGrpcRouteRuleActionDestinationOutputWithContext 

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

type GrpcRouteRuleActionDestinationArray 

type GrpcRouteRuleActionDestinationArray []GrpcRouteRuleActionDestinationInput

func (GrpcRouteRuleActionDestinationArray) ElementType 

func (GrpcRouteRuleActionDestinationArray) ElementType() reflect.Type

func (GrpcRouteRuleActionDestinationArray) ToGrpcRouteRuleActionDestinationArrayOutput 

func (i GrpcRouteRuleActionDestinationArray) ToGrpcRouteRuleActionDestinationArrayOutput() GrpcRouteRuleActionDestinationArrayOutput

func (GrpcRouteRuleActionDestinationArray) ToGrpcRouteRuleActionDestinationArrayOutputWithContext 

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

type GrpcRouteRuleActionDestinationArrayInput 

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 

type GrpcRouteRuleActionDestinationArrayOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionDestinationArrayOutput) ElementType 

func (GrpcRouteRuleActionDestinationArrayOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionDestinationArrayOutput) Index 

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

func (GrpcRouteRuleActionDestinationArrayOutput) ToGrpcRouteRuleActionDestinationArrayOutput 

func (o GrpcRouteRuleActionDestinationArrayOutput) ToGrpcRouteRuleActionDestinationArrayOutput() GrpcRouteRuleActionDestinationArrayOutput

func (GrpcRouteRuleActionDestinationArrayOutput) ToGrpcRouteRuleActionDestinationArrayOutputWithContext 

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

type GrpcRouteRuleActionDestinationInput 

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 

type GrpcRouteRuleActionDestinationOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionDestinationOutput) ElementType 

func (GrpcRouteRuleActionDestinationOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionDestinationOutput) ServiceName 

func (o GrpcRouteRuleActionDestinationOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (GrpcRouteRuleActionDestinationOutput) ToGrpcRouteRuleActionDestinationOutput 

func (o GrpcRouteRuleActionDestinationOutput) ToGrpcRouteRuleActionDestinationOutput() GrpcRouteRuleActionDestinationOutput

func (GrpcRouteRuleActionDestinationOutput) ToGrpcRouteRuleActionDestinationOutputWithContext 

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

func (GrpcRouteRuleActionDestinationOutput) Weight 

func (o GrpcRouteRuleActionDestinationOutput) Weight() pulumi.IntPtrOutput

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

type GrpcRouteRuleActionFaultInjectionPolicy 

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 

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 

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 

func (GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutput 

func (i GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutputWithContext 

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

func (GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput 

func (i GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext 

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

type GrpcRouteRuleActionFaultInjectionPolicyAbortInput 

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 

type GrpcRouteRuleActionFaultInjectionPolicyAbortOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ElementType 

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) HttpStatus 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) HttpStatus() pulumi.IntPtrOutput

The HTTP status code used to abort the request.

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) Percentage 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic which will be aborted.

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutput 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutputWithContext 

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

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext 

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

type GrpcRouteRuleActionFaultInjectionPolicyAbortPtrInput 

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 

func GrpcRouteRuleActionFaultInjectionPolicyAbortPtr(v *GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) GrpcRouteRuleActionFaultInjectionPolicyAbortPtrInput

type GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput 

type GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Elem 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Elem() GrpcRouteRuleActionFaultInjectionPolicyAbortOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ElementType 

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) HttpStatus 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) HttpStatus() pulumi.IntPtrOutput

The HTTP status code used to abort the request.

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Percentage 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic which will be aborted.

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext 

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

type GrpcRouteRuleActionFaultInjectionPolicyArgs 

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 

func (GrpcRouteRuleActionFaultInjectionPolicyArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyOutput 

func (i GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyOutput() GrpcRouteRuleActionFaultInjectionPolicyOutput

func (GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyOutputWithContext 

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

func (GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput 

func (i GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutputWithContext 

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

type GrpcRouteRuleActionFaultInjectionPolicyDelay 

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 

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 

func (GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutput 

func (i GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutputWithContext 

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

func (GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput 

func (i GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext 

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

type GrpcRouteRuleActionFaultInjectionPolicyDelayInput 

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 

type GrpcRouteRuleActionFaultInjectionPolicyDelayOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ElementType 

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) FixedDelay 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) FixedDelay() pulumi.StringPtrOutput

Specify a fixed delay before forwarding the request.

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) Percentage 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic on which delay will be injected.

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutput 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutputWithContext 

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

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext 

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

type GrpcRouteRuleActionFaultInjectionPolicyDelayPtrInput 

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 

func GrpcRouteRuleActionFaultInjectionPolicyDelayPtr(v *GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) GrpcRouteRuleActionFaultInjectionPolicyDelayPtrInput

type GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput 

type GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Elem 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Elem() GrpcRouteRuleActionFaultInjectionPolicyDelayOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ElementType 

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) FixedDelay 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) FixedDelay() pulumi.StringPtrOutput

Specify a fixed delay before forwarding the request.

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Percentage 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic on which delay will be injected.

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext 

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

type GrpcRouteRuleActionFaultInjectionPolicyInput 

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 

type GrpcRouteRuleActionFaultInjectionPolicyOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) Abort 

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 

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 

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyOutput 

func (o GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyOutput() GrpcRouteRuleActionFaultInjectionPolicyOutput

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyOutputWithContext 

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

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput 

func (o GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutputWithContext 

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

type GrpcRouteRuleActionFaultInjectionPolicyPtrInput 

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 

func GrpcRouteRuleActionFaultInjectionPolicyPtr(v *GrpcRouteRuleActionFaultInjectionPolicyArgs) GrpcRouteRuleActionFaultInjectionPolicyPtrInput

type GrpcRouteRuleActionFaultInjectionPolicyPtrOutput 

type GrpcRouteRuleActionFaultInjectionPolicyPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) Abort 

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 

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 

func (o GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) Elem() GrpcRouteRuleActionFaultInjectionPolicyOutput

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) ElementType 

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput 

func (o GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutputWithContext 

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

type GrpcRouteRuleActionInput 

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 

type GrpcRouteRuleActionOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionOutput) Destinations 

func (o GrpcRouteRuleActionOutput) Destinations() GrpcRouteRuleActionDestinationArrayOutput

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

func (GrpcRouteRuleActionOutput) ElementType 

func (GrpcRouteRuleActionOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionOutput) FaultInjectionPolicy 

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 

func (o GrpcRouteRuleActionOutput) RetryPolicy() GrpcRouteRuleActionRetryPolicyPtrOutput

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

func (GrpcRouteRuleActionOutput) Timeout 

func (o GrpcRouteRuleActionOutput) Timeout() pulumi.StringPtrOutput

Specifies the timeout for selected route.

func (GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionOutput 

func (o GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionOutput() GrpcRouteRuleActionOutput

func (GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionOutputWithContext 

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

func (GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionPtrOutput 

func (o GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionPtrOutput() GrpcRouteRuleActionPtrOutput

func (GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionPtrOutputWithContext 

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

type GrpcRouteRuleActionPtrInput 

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 

func GrpcRouteRuleActionPtr(v *GrpcRouteRuleActionArgs) GrpcRouteRuleActionPtrInput

type GrpcRouteRuleActionPtrOutput 

type GrpcRouteRuleActionPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionPtrOutput) Destinations 

func (o GrpcRouteRuleActionPtrOutput) Destinations() GrpcRouteRuleActionDestinationArrayOutput

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

func (GrpcRouteRuleActionPtrOutput) Elem 

func (o GrpcRouteRuleActionPtrOutput) Elem() GrpcRouteRuleActionOutput

func (GrpcRouteRuleActionPtrOutput) ElementType 

func (GrpcRouteRuleActionPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionPtrOutput) FaultInjectionPolicy 

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 

func (o GrpcRouteRuleActionPtrOutput) RetryPolicy() GrpcRouteRuleActionRetryPolicyPtrOutput

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

func (GrpcRouteRuleActionPtrOutput) Timeout 

func (o GrpcRouteRuleActionPtrOutput) Timeout() pulumi.StringPtrOutput

Specifies the timeout for selected route.

func (GrpcRouteRuleActionPtrOutput) ToGrpcRouteRuleActionPtrOutput 

func (o GrpcRouteRuleActionPtrOutput) ToGrpcRouteRuleActionPtrOutput() GrpcRouteRuleActionPtrOutput

func (GrpcRouteRuleActionPtrOutput) ToGrpcRouteRuleActionPtrOutputWithContext 

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

type GrpcRouteRuleActionRetryPolicy 

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 

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 

func (GrpcRouteRuleActionRetryPolicyArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyOutput 

func (i GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyOutput() GrpcRouteRuleActionRetryPolicyOutput

func (GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyOutputWithContext 

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

func (GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyPtrOutput 

func (i GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyPtrOutput() GrpcRouteRuleActionRetryPolicyPtrOutput

func (GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyPtrOutputWithContext 

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

type GrpcRouteRuleActionRetryPolicyInput 

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 

type GrpcRouteRuleActionRetryPolicyOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionRetryPolicyOutput) ElementType 

func (GrpcRouteRuleActionRetryPolicyOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionRetryPolicyOutput) NumRetries 

func (o GrpcRouteRuleActionRetryPolicyOutput) NumRetries() pulumi.IntPtrOutput

Specifies the allowed number of retries.

***

func (GrpcRouteRuleActionRetryPolicyOutput) RetryConditions 

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 

func (o GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyOutput() GrpcRouteRuleActionRetryPolicyOutput

func (GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyOutputWithContext 

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

func (GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutput 

func (o GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutput() GrpcRouteRuleActionRetryPolicyPtrOutput

func (GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutputWithContext 

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

type GrpcRouteRuleActionRetryPolicyPtrInput 

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 

func GrpcRouteRuleActionRetryPolicyPtr(v *GrpcRouteRuleActionRetryPolicyArgs) GrpcRouteRuleActionRetryPolicyPtrInput

type GrpcRouteRuleActionRetryPolicyPtrOutput 

type GrpcRouteRuleActionRetryPolicyPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionRetryPolicyPtrOutput) Elem 

func (o GrpcRouteRuleActionRetryPolicyPtrOutput) Elem() GrpcRouteRuleActionRetryPolicyOutput

func (GrpcRouteRuleActionRetryPolicyPtrOutput) ElementType 

func (GrpcRouteRuleActionRetryPolicyPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionRetryPolicyPtrOutput) NumRetries 

func (o GrpcRouteRuleActionRetryPolicyPtrOutput) NumRetries() pulumi.IntPtrOutput

Specifies the allowed number of retries.

***

func (GrpcRouteRuleActionRetryPolicyPtrOutput) RetryConditions 

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 

func (o GrpcRouteRuleActionRetryPolicyPtrOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutput() GrpcRouteRuleActionRetryPolicyPtrOutput

func (GrpcRouteRuleActionRetryPolicyPtrOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutputWithContext 

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

type GrpcRouteRuleArgs 

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 

func (GrpcRouteRuleArgs) ElementType() reflect.Type

func (GrpcRouteRuleArgs) ToGrpcRouteRuleOutput 

func (i GrpcRouteRuleArgs) ToGrpcRouteRuleOutput() GrpcRouteRuleOutput

func (GrpcRouteRuleArgs) ToGrpcRouteRuleOutputWithContext 

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

type GrpcRouteRuleArray 

type GrpcRouteRuleArray []GrpcRouteRuleInput

func (GrpcRouteRuleArray) ElementType 

func (GrpcRouteRuleArray) ElementType() reflect.Type

func (GrpcRouteRuleArray) ToGrpcRouteRuleArrayOutput 

func (i GrpcRouteRuleArray) ToGrpcRouteRuleArrayOutput() GrpcRouteRuleArrayOutput

func (GrpcRouteRuleArray) ToGrpcRouteRuleArrayOutputWithContext 

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

type GrpcRouteRuleArrayInput 

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 

type GrpcRouteRuleArrayOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleArrayOutput) ElementType 

func (GrpcRouteRuleArrayOutput) ElementType() reflect.Type

func (GrpcRouteRuleArrayOutput) Index 

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

func (GrpcRouteRuleArrayOutput) ToGrpcRouteRuleArrayOutput 

func (o GrpcRouteRuleArrayOutput) ToGrpcRouteRuleArrayOutput() GrpcRouteRuleArrayOutput

func (GrpcRouteRuleArrayOutput) ToGrpcRouteRuleArrayOutputWithContext 

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

type GrpcRouteRuleInput 

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 

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 

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 

func (GrpcRouteRuleMatchArgs) ElementType() reflect.Type

func (GrpcRouteRuleMatchArgs) ToGrpcRouteRuleMatchOutput 

func (i GrpcRouteRuleMatchArgs) ToGrpcRouteRuleMatchOutput() GrpcRouteRuleMatchOutput

func (GrpcRouteRuleMatchArgs) ToGrpcRouteRuleMatchOutputWithContext 

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

type GrpcRouteRuleMatchArray 

type GrpcRouteRuleMatchArray []GrpcRouteRuleMatchInput

func (GrpcRouteRuleMatchArray) ElementType 

func (GrpcRouteRuleMatchArray) ElementType() reflect.Type

func (GrpcRouteRuleMatchArray) ToGrpcRouteRuleMatchArrayOutput 

func (i GrpcRouteRuleMatchArray) ToGrpcRouteRuleMatchArrayOutput() GrpcRouteRuleMatchArrayOutput

func (GrpcRouteRuleMatchArray) ToGrpcRouteRuleMatchArrayOutputWithContext 

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

type GrpcRouteRuleMatchArrayInput 

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 

type GrpcRouteRuleMatchArrayOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchArrayOutput) ElementType 

func (GrpcRouteRuleMatchArrayOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchArrayOutput) Index 

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

func (GrpcRouteRuleMatchArrayOutput) ToGrpcRouteRuleMatchArrayOutput 

func (o GrpcRouteRuleMatchArrayOutput) ToGrpcRouteRuleMatchArrayOutput() GrpcRouteRuleMatchArrayOutput

func (GrpcRouteRuleMatchArrayOutput) ToGrpcRouteRuleMatchArrayOutputWithContext 

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

type GrpcRouteRuleMatchHeader 

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 

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 

func (GrpcRouteRuleMatchHeaderArgs) ElementType() reflect.Type

func (GrpcRouteRuleMatchHeaderArgs) ToGrpcRouteRuleMatchHeaderOutput 

func (i GrpcRouteRuleMatchHeaderArgs) ToGrpcRouteRuleMatchHeaderOutput() GrpcRouteRuleMatchHeaderOutput

func (GrpcRouteRuleMatchHeaderArgs) ToGrpcRouteRuleMatchHeaderOutputWithContext 

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

type GrpcRouteRuleMatchHeaderArray 

type GrpcRouteRuleMatchHeaderArray []GrpcRouteRuleMatchHeaderInput

func (GrpcRouteRuleMatchHeaderArray) ElementType 

func (GrpcRouteRuleMatchHeaderArray) ElementType() reflect.Type

func (GrpcRouteRuleMatchHeaderArray) ToGrpcRouteRuleMatchHeaderArrayOutput 

func (i GrpcRouteRuleMatchHeaderArray) ToGrpcRouteRuleMatchHeaderArrayOutput() GrpcRouteRuleMatchHeaderArrayOutput

func (GrpcRouteRuleMatchHeaderArray) ToGrpcRouteRuleMatchHeaderArrayOutputWithContext 

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

type GrpcRouteRuleMatchHeaderArrayInput 

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 

type GrpcRouteRuleMatchHeaderArrayOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchHeaderArrayOutput) ElementType 

func (GrpcRouteRuleMatchHeaderArrayOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchHeaderArrayOutput) Index 

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

func (GrpcRouteRuleMatchHeaderArrayOutput) ToGrpcRouteRuleMatchHeaderArrayOutput 

func (o GrpcRouteRuleMatchHeaderArrayOutput) ToGrpcRouteRuleMatchHeaderArrayOutput() GrpcRouteRuleMatchHeaderArrayOutput

func (GrpcRouteRuleMatchHeaderArrayOutput) ToGrpcRouteRuleMatchHeaderArrayOutputWithContext 

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

type GrpcRouteRuleMatchHeaderInput 

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 

type GrpcRouteRuleMatchHeaderOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchHeaderOutput) ElementType 

func (GrpcRouteRuleMatchHeaderOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchHeaderOutput) Key 

func (o GrpcRouteRuleMatchHeaderOutput) Key() pulumi.StringOutput

Required. The key of the header.

func (GrpcRouteRuleMatchHeaderOutput) ToGrpcRouteRuleMatchHeaderOutput 

func (o GrpcRouteRuleMatchHeaderOutput) ToGrpcRouteRuleMatchHeaderOutput() GrpcRouteRuleMatchHeaderOutput

func (GrpcRouteRuleMatchHeaderOutput) ToGrpcRouteRuleMatchHeaderOutputWithContext 

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

func (GrpcRouteRuleMatchHeaderOutput) Type 

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 

func (o GrpcRouteRuleMatchHeaderOutput) Value() pulumi.StringOutput

Required. The value of the header.

type GrpcRouteRuleMatchInput 

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 

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 

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 

func (GrpcRouteRuleMatchMethodArgs) ElementType() reflect.Type

func (GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodOutput 

func (i GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodOutput() GrpcRouteRuleMatchMethodOutput

func (GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodOutputWithContext 

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

func (GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodPtrOutput 

func (i GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodPtrOutput() GrpcRouteRuleMatchMethodPtrOutput

func (GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodPtrOutputWithContext 

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

type GrpcRouteRuleMatchMethodInput 

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 

type GrpcRouteRuleMatchMethodOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchMethodOutput) CaseSensitive 

func (o GrpcRouteRuleMatchMethodOutput) CaseSensitive() pulumi.BoolPtrOutput

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

func (GrpcRouteRuleMatchMethodOutput) ElementType 

func (GrpcRouteRuleMatchMethodOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchMethodOutput) GrpcMethod 

func (o GrpcRouteRuleMatchMethodOutput) GrpcMethod() pulumi.StringOutput

Required. Name of the method to match against.

func (GrpcRouteRuleMatchMethodOutput) GrpcService 

func (o GrpcRouteRuleMatchMethodOutput) GrpcService() pulumi.StringOutput

Required. Name of the service to match against.

func (GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodOutput 

func (o GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodOutput() GrpcRouteRuleMatchMethodOutput

func (GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodOutputWithContext 

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

func (GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodPtrOutput 

func (o GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodPtrOutput() GrpcRouteRuleMatchMethodPtrOutput

func (GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodPtrOutputWithContext 

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

type GrpcRouteRuleMatchMethodPtrInput 

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 

func GrpcRouteRuleMatchMethodPtr(v *GrpcRouteRuleMatchMethodArgs) GrpcRouteRuleMatchMethodPtrInput

type GrpcRouteRuleMatchMethodPtrOutput 

type GrpcRouteRuleMatchMethodPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchMethodPtrOutput) CaseSensitive 

func (o GrpcRouteRuleMatchMethodPtrOutput) CaseSensitive() pulumi.BoolPtrOutput

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

func (GrpcRouteRuleMatchMethodPtrOutput) Elem 

func (o GrpcRouteRuleMatchMethodPtrOutput) Elem() GrpcRouteRuleMatchMethodOutput

func (GrpcRouteRuleMatchMethodPtrOutput) ElementType 

func (GrpcRouteRuleMatchMethodPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchMethodPtrOutput) GrpcMethod 

func (o GrpcRouteRuleMatchMethodPtrOutput) GrpcMethod() pulumi.StringPtrOutput

Required. Name of the method to match against.

func (GrpcRouteRuleMatchMethodPtrOutput) GrpcService 

func (o GrpcRouteRuleMatchMethodPtrOutput) GrpcService() pulumi.StringPtrOutput

Required. Name of the service to match against.

func (GrpcRouteRuleMatchMethodPtrOutput) ToGrpcRouteRuleMatchMethodPtrOutput 

func (o GrpcRouteRuleMatchMethodPtrOutput) ToGrpcRouteRuleMatchMethodPtrOutput() GrpcRouteRuleMatchMethodPtrOutput

func (GrpcRouteRuleMatchMethodPtrOutput) ToGrpcRouteRuleMatchMethodPtrOutputWithContext 

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

type GrpcRouteRuleMatchOutput 

type GrpcRouteRuleMatchOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchOutput) ElementType 

func (GrpcRouteRuleMatchOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchOutput) Headers 

func (o GrpcRouteRuleMatchOutput) Headers() GrpcRouteRuleMatchHeaderArrayOutput

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

func (GrpcRouteRuleMatchOutput) Method 

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 

func (o GrpcRouteRuleMatchOutput) ToGrpcRouteRuleMatchOutput() GrpcRouteRuleMatchOutput

func (GrpcRouteRuleMatchOutput) ToGrpcRouteRuleMatchOutputWithContext 

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

type GrpcRouteRuleOutput 

type GrpcRouteRuleOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleOutput) Action 

func (o GrpcRouteRuleOutput) Action() GrpcRouteRuleActionPtrOutput

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

func (GrpcRouteRuleOutput) ElementType 

func (GrpcRouteRuleOutput) ElementType() reflect.Type

func (GrpcRouteRuleOutput) Matches 

func (o GrpcRouteRuleOutput) Matches() GrpcRouteRuleMatchArrayOutput

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

func (GrpcRouteRuleOutput) ToGrpcRouteRuleOutput 

func (o GrpcRouteRuleOutput) ToGrpcRouteRuleOutput() GrpcRouteRuleOutput

func (GrpcRouteRuleOutput) ToGrpcRouteRuleOutputWithContext 

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

type GrpcRouteState 

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
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// 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. **Note**: This field is non-authoritative, and will only
	// manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
	// present on the resource.
	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
	Project pulumi.StringPtrInput
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
	// 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 

func (GrpcRouteState) ElementType() reflect.Type

type HttpRoute 

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"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// 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. **Note**: This field is non-authoritative, and will only
	// manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
	// present on the resource.
	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"`
	Project pulumi.StringOutput `pulumi:"project"`
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
	// 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/v7/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{
			Name: pulumi.String("my-http-route"),
			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"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/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{
			Name: pulumi.String("my-http-route"),
			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),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Http Route Actions

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/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{
			Name: pulumi.String("my-http-route"),
			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"),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Http Route Mesh Basic

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/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{
			Name: pulumi.String("my-http-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewHttpRoute(ctx, "default", &networkservices.HttpRouteArgs{
			Name: pulumi.String("my-http-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Meshes: pulumi.StringArray{
				_default.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"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

HttpRoute can be imported using any of these accepted formats:

* `projects/{{project}}/locations/global/httpRoutes/{{name}}`

* `{{project}}/{{name}}`

* `{{name}}`

When using the `pulumi import` command, HttpRoute can be imported using one of the formats above. For example:

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

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 

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 

func (*HttpRoute) ElementType() reflect.Type

func (*HttpRoute) ToHttpRouteOutput 

func (i *HttpRoute) ToHttpRouteOutput() HttpRouteOutput

func (*HttpRoute) ToHttpRouteOutputWithContext 

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

type HttpRouteArgs 

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. **Note**: This field is non-authoritative, and will only
	// manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
	// present on the resource.
	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
	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 

func (HttpRouteArgs) ElementType() reflect.Type

type HttpRouteArray 

type HttpRouteArray []HttpRouteInput

func (HttpRouteArray) ElementType 

func (HttpRouteArray) ElementType() reflect.Type

func (HttpRouteArray) ToHttpRouteArrayOutput 

func (i HttpRouteArray) ToHttpRouteArrayOutput() HttpRouteArrayOutput

func (HttpRouteArray) ToHttpRouteArrayOutputWithContext 

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

type HttpRouteArrayInput 

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 

type HttpRouteArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteArrayOutput) ElementType 

func (HttpRouteArrayOutput) ElementType() reflect.Type

func (HttpRouteArrayOutput) Index 

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

func (HttpRouteArrayOutput) ToHttpRouteArrayOutput 

func (o HttpRouteArrayOutput) ToHttpRouteArrayOutput() HttpRouteArrayOutput

func (HttpRouteArrayOutput) ToHttpRouteArrayOutputWithContext 

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

type HttpRouteInput 

type HttpRouteInput interface {
	pulumi.Input

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

type HttpRouteMap 

type HttpRouteMap map[string]HttpRouteInput

func (HttpRouteMap) ElementType 

func (HttpRouteMap) ElementType() reflect.Type

func (HttpRouteMap) ToHttpRouteMapOutput 

func (i HttpRouteMap) ToHttpRouteMapOutput() HttpRouteMapOutput

func (HttpRouteMap) ToHttpRouteMapOutputWithContext 

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

type HttpRouteMapInput 

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 

type HttpRouteMapOutput struct{ *pulumi.OutputState }

func (HttpRouteMapOutput) ElementType 

func (HttpRouteMapOutput) ElementType() reflect.Type

func (HttpRouteMapOutput) MapIndex 

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

func (HttpRouteMapOutput) ToHttpRouteMapOutput 

func (o HttpRouteMapOutput) ToHttpRouteMapOutput() HttpRouteMapOutput

func (HttpRouteMapOutput) ToHttpRouteMapOutputWithContext 

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

type HttpRouteOutput 

type HttpRouteOutput struct{ *pulumi.OutputState }

func (HttpRouteOutput) CreateTime 

func (o HttpRouteOutput) CreateTime() pulumi.StringOutput

Time the HttpRoute was created in UTC.

func (HttpRouteOutput) Description 

func (o HttpRouteOutput) Description() pulumi.StringPtrOutput

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

func (HttpRouteOutput) EffectiveLabels 

func (o HttpRouteOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (HttpRouteOutput) ElementType 

func (HttpRouteOutput) ElementType() reflect.Type

func (HttpRouteOutput) Gateways 

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 

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 

func (o HttpRouteOutput) Labels() pulumi.StringMapOutput

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

func (HttpRouteOutput) Meshes 

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 

func (o HttpRouteOutput) Name() pulumi.StringOutput

Name of the HttpRoute resource.

func (HttpRouteOutput) Project 

func (o HttpRouteOutput) Project() pulumi.StringOutput

func (HttpRouteOutput) PulumiLabels 

func (o HttpRouteOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider.

func (HttpRouteOutput) Rules 

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 

func (o HttpRouteOutput) ToHttpRouteOutput() HttpRouteOutput

func (HttpRouteOutput) ToHttpRouteOutputWithContext 

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

func (HttpRouteOutput) UpdateTime 

func (o HttpRouteOutput) UpdateTime() pulumi.StringOutput

Time the HttpRoute was updated in UTC.

type HttpRouteRule 

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 

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 

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 

func (HttpRouteRuleActionArgs) ElementType() reflect.Type

func (HttpRouteRuleActionArgs) ToHttpRouteRuleActionOutput 

func (i HttpRouteRuleActionArgs) ToHttpRouteRuleActionOutput() HttpRouteRuleActionOutput

func (HttpRouteRuleActionArgs) ToHttpRouteRuleActionOutputWithContext 

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

func (HttpRouteRuleActionArgs) ToHttpRouteRuleActionPtrOutput 

func (i HttpRouteRuleActionArgs) ToHttpRouteRuleActionPtrOutput() HttpRouteRuleActionPtrOutput

func (HttpRouteRuleActionArgs) ToHttpRouteRuleActionPtrOutputWithContext 

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

type HttpRouteRuleActionCorsPolicy 

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 

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 

func (HttpRouteRuleActionCorsPolicyArgs) ElementType() reflect.Type

func (HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyOutput 

func (i HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyOutput() HttpRouteRuleActionCorsPolicyOutput

func (HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyOutputWithContext 

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

func (HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyPtrOutput 

func (i HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyPtrOutput() HttpRouteRuleActionCorsPolicyPtrOutput

func (HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionCorsPolicyInput 

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 

type HttpRouteRuleActionCorsPolicyOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionCorsPolicyOutput) AllowCredentials 

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 

func (o HttpRouteRuleActionCorsPolicyOutput) AllowHeaders() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyOutput) AllowMethods 

func (o HttpRouteRuleActionCorsPolicyOutput) AllowMethods() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyOutput) AllowOriginRegexes 

func (o HttpRouteRuleActionCorsPolicyOutput) AllowOriginRegexes() pulumi.StringArrayOutput

Specifies the regular expression patterns that match allowed origins.

func (HttpRouteRuleActionCorsPolicyOutput) AllowOrigins 

func (o HttpRouteRuleActionCorsPolicyOutput) AllowOrigins() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyOutput) Disabled 

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 

func (HttpRouteRuleActionCorsPolicyOutput) ElementType() reflect.Type

func (HttpRouteRuleActionCorsPolicyOutput) ExposeHeaders 

func (o HttpRouteRuleActionCorsPolicyOutput) ExposeHeaders() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyOutput) MaxAge 

func (o HttpRouteRuleActionCorsPolicyOutput) MaxAge() pulumi.StringPtrOutput

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

func (HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyOutput 

func (o HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyOutput() HttpRouteRuleActionCorsPolicyOutput

func (HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyOutputWithContext 

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

func (HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyPtrOutput 

func (o HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyPtrOutput() HttpRouteRuleActionCorsPolicyPtrOutput

func (HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionCorsPolicyPtrInput 

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 

func HttpRouteRuleActionCorsPolicyPtr(v *HttpRouteRuleActionCorsPolicyArgs) HttpRouteRuleActionCorsPolicyPtrInput

type HttpRouteRuleActionCorsPolicyPtrOutput 

type HttpRouteRuleActionCorsPolicyPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionCorsPolicyPtrOutput) AllowCredentials 

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 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) AllowHeaders() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyPtrOutput) AllowMethods 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) AllowMethods() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyPtrOutput) AllowOriginRegexes 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) AllowOriginRegexes() pulumi.StringArrayOutput

Specifies the regular expression patterns that match allowed origins.

func (HttpRouteRuleActionCorsPolicyPtrOutput) AllowOrigins 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) AllowOrigins() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyPtrOutput) Disabled 

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 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) Elem() HttpRouteRuleActionCorsPolicyOutput

func (HttpRouteRuleActionCorsPolicyPtrOutput) ElementType 

func (HttpRouteRuleActionCorsPolicyPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionCorsPolicyPtrOutput) ExposeHeaders 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) ExposeHeaders() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyPtrOutput) MaxAge 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) MaxAge() pulumi.StringPtrOutput

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

func (HttpRouteRuleActionCorsPolicyPtrOutput) ToHttpRouteRuleActionCorsPolicyPtrOutput 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) ToHttpRouteRuleActionCorsPolicyPtrOutput() HttpRouteRuleActionCorsPolicyPtrOutput

func (HttpRouteRuleActionCorsPolicyPtrOutput) ToHttpRouteRuleActionCorsPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionDestination 

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 

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 

func (HttpRouteRuleActionDestinationArgs) ElementType() reflect.Type

func (HttpRouteRuleActionDestinationArgs) ToHttpRouteRuleActionDestinationOutput 

func (i HttpRouteRuleActionDestinationArgs) ToHttpRouteRuleActionDestinationOutput() HttpRouteRuleActionDestinationOutput

func (HttpRouteRuleActionDestinationArgs) ToHttpRouteRuleActionDestinationOutputWithContext 

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

type HttpRouteRuleActionDestinationArray 

type HttpRouteRuleActionDestinationArray []HttpRouteRuleActionDestinationInput

func (HttpRouteRuleActionDestinationArray) ElementType 

func (HttpRouteRuleActionDestinationArray) ElementType() reflect.Type

func (HttpRouteRuleActionDestinationArray) ToHttpRouteRuleActionDestinationArrayOutput 

func (i HttpRouteRuleActionDestinationArray) ToHttpRouteRuleActionDestinationArrayOutput() HttpRouteRuleActionDestinationArrayOutput

func (HttpRouteRuleActionDestinationArray) ToHttpRouteRuleActionDestinationArrayOutputWithContext 

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

type HttpRouteRuleActionDestinationArrayInput 

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 

type HttpRouteRuleActionDestinationArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionDestinationArrayOutput) ElementType 

func (HttpRouteRuleActionDestinationArrayOutput) ElementType() reflect.Type

func (HttpRouteRuleActionDestinationArrayOutput) Index 

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

func (HttpRouteRuleActionDestinationArrayOutput) ToHttpRouteRuleActionDestinationArrayOutput 

func (o HttpRouteRuleActionDestinationArrayOutput) ToHttpRouteRuleActionDestinationArrayOutput() HttpRouteRuleActionDestinationArrayOutput

func (HttpRouteRuleActionDestinationArrayOutput) ToHttpRouteRuleActionDestinationArrayOutputWithContext 

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

type HttpRouteRuleActionDestinationInput 

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 

type HttpRouteRuleActionDestinationOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionDestinationOutput) ElementType 

func (HttpRouteRuleActionDestinationOutput) ElementType() reflect.Type

func (HttpRouteRuleActionDestinationOutput) ServiceName 

func (o HttpRouteRuleActionDestinationOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (HttpRouteRuleActionDestinationOutput) ToHttpRouteRuleActionDestinationOutput 

func (o HttpRouteRuleActionDestinationOutput) ToHttpRouteRuleActionDestinationOutput() HttpRouteRuleActionDestinationOutput

func (HttpRouteRuleActionDestinationOutput) ToHttpRouteRuleActionDestinationOutputWithContext 

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

func (HttpRouteRuleActionDestinationOutput) Weight 

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 

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 

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 

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 

func (HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutput 

func (i HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutput() HttpRouteRuleActionFaultInjectionPolicyAbortOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutputWithContext 

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

func (HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput 

func (i HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput() HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext 

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

type HttpRouteRuleActionFaultInjectionPolicyAbortInput 

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 

type HttpRouteRuleActionFaultInjectionPolicyAbortOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ElementType 

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) HttpStatus 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortOutput) HttpStatus() pulumi.IntPtrOutput

The HTTP status code used to abort the request.

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) Percentage 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic which will be aborted.

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutput 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutput() HttpRouteRuleActionFaultInjectionPolicyAbortOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutputWithContext 

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

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput() HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext 

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

type HttpRouteRuleActionFaultInjectionPolicyAbortPtrInput 

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 

func HttpRouteRuleActionFaultInjectionPolicyAbortPtr(v *HttpRouteRuleActionFaultInjectionPolicyAbortArgs) HttpRouteRuleActionFaultInjectionPolicyAbortPtrInput

type HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput 

type HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Elem 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Elem() HttpRouteRuleActionFaultInjectionPolicyAbortOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ElementType 

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) HttpStatus 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) HttpStatus() pulumi.IntPtrOutput

The HTTP status code used to abort the request.

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Percentage 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic which will be aborted.

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput() HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext 

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

type HttpRouteRuleActionFaultInjectionPolicyArgs 

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 

func (HttpRouteRuleActionFaultInjectionPolicyArgs) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyOutput 

func (i HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyOutput() HttpRouteRuleActionFaultInjectionPolicyOutput

func (HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyOutputWithContext 

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

func (HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput 

func (i HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput() HttpRouteRuleActionFaultInjectionPolicyPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionFaultInjectionPolicyDelay 

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 

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 

func (HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutput 

func (i HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutput() HttpRouteRuleActionFaultInjectionPolicyDelayOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutputWithContext 

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

func (HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput 

func (i HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput() HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext 

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

type HttpRouteRuleActionFaultInjectionPolicyDelayInput 

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 

type HttpRouteRuleActionFaultInjectionPolicyDelayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ElementType 

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) FixedDelay 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayOutput) FixedDelay() pulumi.StringPtrOutput

Specify a fixed delay before forwarding the request.

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) Percentage 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic on which delay will be injected.

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutput 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutput() HttpRouteRuleActionFaultInjectionPolicyDelayOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutputWithContext 

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

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput() HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext 

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

type HttpRouteRuleActionFaultInjectionPolicyDelayPtrInput 

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 

func HttpRouteRuleActionFaultInjectionPolicyDelayPtr(v *HttpRouteRuleActionFaultInjectionPolicyDelayArgs) HttpRouteRuleActionFaultInjectionPolicyDelayPtrInput

type HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput 

type HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Elem 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Elem() HttpRouteRuleActionFaultInjectionPolicyDelayOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ElementType 

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) FixedDelay 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) FixedDelay() pulumi.StringPtrOutput

Specify a fixed delay before forwarding the request.

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Percentage 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic on which delay will be injected.

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput() HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext 

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

type HttpRouteRuleActionFaultInjectionPolicyInput 

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 

type HttpRouteRuleActionFaultInjectionPolicyOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyOutput) Abort 

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 

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 

func (HttpRouteRuleActionFaultInjectionPolicyOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyOutput 

func (o HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyOutput() HttpRouteRuleActionFaultInjectionPolicyOutput

func (HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyOutputWithContext 

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

func (HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput 

func (o HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput() HttpRouteRuleActionFaultInjectionPolicyPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionFaultInjectionPolicyPtrInput 

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 

func HttpRouteRuleActionFaultInjectionPolicyPtr(v *HttpRouteRuleActionFaultInjectionPolicyArgs) HttpRouteRuleActionFaultInjectionPolicyPtrInput

type HttpRouteRuleActionFaultInjectionPolicyPtrOutput 

type HttpRouteRuleActionFaultInjectionPolicyPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) Abort 

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 

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 

func (o HttpRouteRuleActionFaultInjectionPolicyPtrOutput) Elem() HttpRouteRuleActionFaultInjectionPolicyOutput

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) ElementType 

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput 

func (o HttpRouteRuleActionFaultInjectionPolicyPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput() HttpRouteRuleActionFaultInjectionPolicyPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionInput 

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 

type HttpRouteRuleActionOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionOutput) CorsPolicy 

func (o HttpRouteRuleActionOutput) CorsPolicy() HttpRouteRuleActionCorsPolicyPtrOutput

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

func (HttpRouteRuleActionOutput) Destinations 

func (o HttpRouteRuleActionOutput) Destinations() HttpRouteRuleActionDestinationArrayOutput

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

func (HttpRouteRuleActionOutput) ElementType 

func (HttpRouteRuleActionOutput) ElementType() reflect.Type

func (HttpRouteRuleActionOutput) FaultInjectionPolicy 

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 

func (o HttpRouteRuleActionOutput) Redirect() HttpRouteRuleActionRedirectPtrOutput

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

func (HttpRouteRuleActionOutput) RequestHeaderModifier 

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 

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 

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 

func (o HttpRouteRuleActionOutput) RetryPolicy() HttpRouteRuleActionRetryPolicyPtrOutput

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

func (HttpRouteRuleActionOutput) Timeout 

func (o HttpRouteRuleActionOutput) Timeout() pulumi.StringPtrOutput

Specifies the timeout for selected route.

func (HttpRouteRuleActionOutput) ToHttpRouteRuleActionOutput 

func (o HttpRouteRuleActionOutput) ToHttpRouteRuleActionOutput() HttpRouteRuleActionOutput

func (HttpRouteRuleActionOutput) ToHttpRouteRuleActionOutputWithContext 

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

func (HttpRouteRuleActionOutput) ToHttpRouteRuleActionPtrOutput 

func (o HttpRouteRuleActionOutput) ToHttpRouteRuleActionPtrOutput() HttpRouteRuleActionPtrOutput

func (HttpRouteRuleActionOutput) ToHttpRouteRuleActionPtrOutputWithContext 

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

func (HttpRouteRuleActionOutput) UrlRewrite 

func (o HttpRouteRuleActionOutput) UrlRewrite() HttpRouteRuleActionUrlRewritePtrOutput

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

type HttpRouteRuleActionPtrInput 

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 

func HttpRouteRuleActionPtr(v *HttpRouteRuleActionArgs) HttpRouteRuleActionPtrInput

type HttpRouteRuleActionPtrOutput 

type HttpRouteRuleActionPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionPtrOutput) CorsPolicy 

func (o HttpRouteRuleActionPtrOutput) CorsPolicy() HttpRouteRuleActionCorsPolicyPtrOutput

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

func (HttpRouteRuleActionPtrOutput) Destinations 

func (o HttpRouteRuleActionPtrOutput) Destinations() HttpRouteRuleActionDestinationArrayOutput

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

func (HttpRouteRuleActionPtrOutput) Elem 

func (o HttpRouteRuleActionPtrOutput) Elem() HttpRouteRuleActionOutput

func (HttpRouteRuleActionPtrOutput) ElementType 

func (HttpRouteRuleActionPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionPtrOutput) FaultInjectionPolicy 

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 

func (o HttpRouteRuleActionPtrOutput) Redirect() HttpRouteRuleActionRedirectPtrOutput

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

func (HttpRouteRuleActionPtrOutput) RequestHeaderModifier 

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 

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 

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 

func (o HttpRouteRuleActionPtrOutput) RetryPolicy() HttpRouteRuleActionRetryPolicyPtrOutput

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

func (HttpRouteRuleActionPtrOutput) Timeout 

func (o HttpRouteRuleActionPtrOutput) Timeout() pulumi.StringPtrOutput

Specifies the timeout for selected route.

func (HttpRouteRuleActionPtrOutput) ToHttpRouteRuleActionPtrOutput 

func (o HttpRouteRuleActionPtrOutput) ToHttpRouteRuleActionPtrOutput() HttpRouteRuleActionPtrOutput

func (HttpRouteRuleActionPtrOutput) ToHttpRouteRuleActionPtrOutputWithContext 

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

func (HttpRouteRuleActionPtrOutput) UrlRewrite 

func (o HttpRouteRuleActionPtrOutput) UrlRewrite() HttpRouteRuleActionUrlRewritePtrOutput

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

type HttpRouteRuleActionRedirect 

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 

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 

func (HttpRouteRuleActionRedirectArgs) ElementType() reflect.Type

func (HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectOutput 

func (i HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectOutput() HttpRouteRuleActionRedirectOutput

func (HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectOutputWithContext 

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

func (HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectPtrOutput 

func (i HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectPtrOutput() HttpRouteRuleActionRedirectPtrOutput

func (HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectPtrOutputWithContext 

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

type HttpRouteRuleActionRedirectInput 

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 

type HttpRouteRuleActionRedirectOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRedirectOutput) ElementType 

func (HttpRouteRuleActionRedirectOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRedirectOutput) HostRedirect 

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 

func (o HttpRouteRuleActionRedirectOutput) HttpsRedirect() pulumi.BoolPtrOutput

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

func (HttpRouteRuleActionRedirectOutput) PathRedirect 

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 

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 

func (o HttpRouteRuleActionRedirectOutput) PrefixRewrite() pulumi.StringPtrOutput

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

func (HttpRouteRuleActionRedirectOutput) ResponseCode 

func (o HttpRouteRuleActionRedirectOutput) ResponseCode() pulumi.StringPtrOutput

The HTTP Status code to use for the redirect.

func (HttpRouteRuleActionRedirectOutput) StripQuery 

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 

func (o HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectOutput() HttpRouteRuleActionRedirectOutput

func (HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectOutputWithContext 

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

func (HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectPtrOutput 

func (o HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectPtrOutput() HttpRouteRuleActionRedirectPtrOutput

func (HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectPtrOutputWithContext 

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

type HttpRouteRuleActionRedirectPtrInput 

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 

func HttpRouteRuleActionRedirectPtr(v *HttpRouteRuleActionRedirectArgs) HttpRouteRuleActionRedirectPtrInput

type HttpRouteRuleActionRedirectPtrOutput 

type HttpRouteRuleActionRedirectPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRedirectPtrOutput) Elem 

func (o HttpRouteRuleActionRedirectPtrOutput) Elem() HttpRouteRuleActionRedirectOutput

func (HttpRouteRuleActionRedirectPtrOutput) ElementType 

func (HttpRouteRuleActionRedirectPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRedirectPtrOutput) HostRedirect 

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 

func (o HttpRouteRuleActionRedirectPtrOutput) HttpsRedirect() pulumi.BoolPtrOutput

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

func (HttpRouteRuleActionRedirectPtrOutput) PathRedirect 

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 

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 

func (o HttpRouteRuleActionRedirectPtrOutput) PrefixRewrite() pulumi.StringPtrOutput

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

func (HttpRouteRuleActionRedirectPtrOutput) ResponseCode 

func (o HttpRouteRuleActionRedirectPtrOutput) ResponseCode() pulumi.StringPtrOutput

The HTTP Status code to use for the redirect.

func (HttpRouteRuleActionRedirectPtrOutput) StripQuery 

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 

func (o HttpRouteRuleActionRedirectPtrOutput) ToHttpRouteRuleActionRedirectPtrOutput() HttpRouteRuleActionRedirectPtrOutput

func (HttpRouteRuleActionRedirectPtrOutput) ToHttpRouteRuleActionRedirectPtrOutputWithContext 

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

type HttpRouteRuleActionRequestHeaderModifier 

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 

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 

func (HttpRouteRuleActionRequestHeaderModifierArgs) ElementType() reflect.Type

func (HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierOutput 

func (i HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierOutput() HttpRouteRuleActionRequestHeaderModifierOutput

func (HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierOutputWithContext 

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

func (HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierPtrOutput 

func (i HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierPtrOutput() HttpRouteRuleActionRequestHeaderModifierPtrOutput

func (HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierPtrOutputWithContext 

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

type HttpRouteRuleActionRequestHeaderModifierInput 

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 

type HttpRouteRuleActionRequestHeaderModifierOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestHeaderModifierOutput) Add 

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 

func (HttpRouteRuleActionRequestHeaderModifierOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestHeaderModifierOutput) Removes 

func (o HttpRouteRuleActionRequestHeaderModifierOutput) Removes() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionRequestHeaderModifierOutput) Set 

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 

func (o HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierOutput() HttpRouteRuleActionRequestHeaderModifierOutput

func (HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierOutputWithContext 

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

func (HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutput 

func (o HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutput() HttpRouteRuleActionRequestHeaderModifierPtrOutput

func (HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutputWithContext 

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

type HttpRouteRuleActionRequestHeaderModifierPtrInput 

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 

func HttpRouteRuleActionRequestHeaderModifierPtr(v *HttpRouteRuleActionRequestHeaderModifierArgs) HttpRouteRuleActionRequestHeaderModifierPtrInput

type HttpRouteRuleActionRequestHeaderModifierPtrOutput 

type HttpRouteRuleActionRequestHeaderModifierPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) Add 

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 

func (o HttpRouteRuleActionRequestHeaderModifierPtrOutput) Elem() HttpRouteRuleActionRequestHeaderModifierOutput

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) ElementType 

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) Removes 

func (o HttpRouteRuleActionRequestHeaderModifierPtrOutput) Removes() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) Set 

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 

func (o HttpRouteRuleActionRequestHeaderModifierPtrOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutput() HttpRouteRuleActionRequestHeaderModifierPtrOutput

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutputWithContext 

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

type HttpRouteRuleActionRequestMirrorPolicy 

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

type HttpRouteRuleActionRequestMirrorPolicyArgs 

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

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ElementType 

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyOutput 

func (i HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyOutput() HttpRouteRuleActionRequestMirrorPolicyOutput

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyOutputWithContext 

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

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput 

func (i HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput() HttpRouteRuleActionRequestMirrorPolicyPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionRequestMirrorPolicyDestination 

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 

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 

func (HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutput 

func (i HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutputWithContext 

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

func (HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput 

func (i HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutputWithContext 

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

type HttpRouteRuleActionRequestMirrorPolicyDestinationInput 

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 

type HttpRouteRuleActionRequestMirrorPolicyDestinationOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ElementType 

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ServiceName 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutput 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutputWithContext 

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

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutputWithContext 

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

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) Weight 

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 

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 

func HttpRouteRuleActionRequestMirrorPolicyDestinationPtr(v *HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) HttpRouteRuleActionRequestMirrorPolicyDestinationPtrInput

type HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput 

type HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) Elem 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) Elem() HttpRouteRuleActionRequestMirrorPolicyDestinationOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ElementType 

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ServiceName 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutputWithContext 

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

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) Weight 

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 

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 

type HttpRouteRuleActionRequestMirrorPolicyOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestMirrorPolicyOutput) Destination 

func (o HttpRouteRuleActionRequestMirrorPolicyOutput) Destination() HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

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

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ElementType 

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyOutput 

func (o HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyOutput() HttpRouteRuleActionRequestMirrorPolicyOutput

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyOutputWithContext 

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

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput 

func (o HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput() HttpRouteRuleActionRequestMirrorPolicyPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionRequestMirrorPolicyPtrInput 

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 

func HttpRouteRuleActionRequestMirrorPolicyPtr(v *HttpRouteRuleActionRequestMirrorPolicyArgs) HttpRouteRuleActionRequestMirrorPolicyPtrInput

type HttpRouteRuleActionRequestMirrorPolicyPtrOutput 

type HttpRouteRuleActionRequestMirrorPolicyPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) Destination 

func (o HttpRouteRuleActionRequestMirrorPolicyPtrOutput) Destination() HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

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

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) Elem 

func (o HttpRouteRuleActionRequestMirrorPolicyPtrOutput) Elem() HttpRouteRuleActionRequestMirrorPolicyOutput

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) ElementType 

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput 

func (o HttpRouteRuleActionRequestMirrorPolicyPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput() HttpRouteRuleActionRequestMirrorPolicyPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionResponseHeaderModifier 

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 

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 

func (HttpRouteRuleActionResponseHeaderModifierArgs) ElementType() reflect.Type

func (HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierOutput 

func (i HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierOutput() HttpRouteRuleActionResponseHeaderModifierOutput

func (HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierOutputWithContext 

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

func (HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierPtrOutput 

func (i HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierPtrOutput() HttpRouteRuleActionResponseHeaderModifierPtrOutput

func (HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierPtrOutputWithContext 

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

type HttpRouteRuleActionResponseHeaderModifierInput 

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 

type HttpRouteRuleActionResponseHeaderModifierOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionResponseHeaderModifierOutput) Add 

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 

func (HttpRouteRuleActionResponseHeaderModifierOutput) ElementType() reflect.Type

func (HttpRouteRuleActionResponseHeaderModifierOutput) Removes 

func (o HttpRouteRuleActionResponseHeaderModifierOutput) Removes() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionResponseHeaderModifierOutput) Set 

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 

func (o HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierOutput() HttpRouteRuleActionResponseHeaderModifierOutput

func (HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierOutputWithContext 

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

func (HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutput 

func (o HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutput() HttpRouteRuleActionResponseHeaderModifierPtrOutput

func (HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutputWithContext 

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

type HttpRouteRuleActionResponseHeaderModifierPtrInput 

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 

func HttpRouteRuleActionResponseHeaderModifierPtr(v *HttpRouteRuleActionResponseHeaderModifierArgs) HttpRouteRuleActionResponseHeaderModifierPtrInput

type HttpRouteRuleActionResponseHeaderModifierPtrOutput 

type HttpRouteRuleActionResponseHeaderModifierPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) Add 

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 

func (o HttpRouteRuleActionResponseHeaderModifierPtrOutput) Elem() HttpRouteRuleActionResponseHeaderModifierOutput

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) ElementType 

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) Removes 

func (o HttpRouteRuleActionResponseHeaderModifierPtrOutput) Removes() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) Set 

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 

func (o HttpRouteRuleActionResponseHeaderModifierPtrOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutput() HttpRouteRuleActionResponseHeaderModifierPtrOutput

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutputWithContext 

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

type HttpRouteRuleActionRetryPolicy 

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 

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 

func (HttpRouteRuleActionRetryPolicyArgs) ElementType() reflect.Type

func (HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyOutput 

func (i HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyOutput() HttpRouteRuleActionRetryPolicyOutput

func (HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyOutputWithContext 

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

func (HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyPtrOutput 

func (i HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyPtrOutput() HttpRouteRuleActionRetryPolicyPtrOutput

func (HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionRetryPolicyInput 

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 

type HttpRouteRuleActionRetryPolicyOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRetryPolicyOutput) ElementType 

func (HttpRouteRuleActionRetryPolicyOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRetryPolicyOutput) NumRetries 

func (o HttpRouteRuleActionRetryPolicyOutput) NumRetries() pulumi.IntPtrOutput

Specifies the allowed number of retries.

func (HttpRouteRuleActionRetryPolicyOutput) PerTryTimeout 

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 

func (o HttpRouteRuleActionRetryPolicyOutput) RetryConditions() pulumi.StringArrayOutput

Specifies one or more conditions when this retry policy applies.

func (HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyOutput 

func (o HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyOutput() HttpRouteRuleActionRetryPolicyOutput

func (HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyOutputWithContext 

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

func (HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyPtrOutput 

func (o HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyPtrOutput() HttpRouteRuleActionRetryPolicyPtrOutput

func (HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionRetryPolicyPtrInput 

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 

func HttpRouteRuleActionRetryPolicyPtr(v *HttpRouteRuleActionRetryPolicyArgs) HttpRouteRuleActionRetryPolicyPtrInput

type HttpRouteRuleActionRetryPolicyPtrOutput 

type HttpRouteRuleActionRetryPolicyPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRetryPolicyPtrOutput) Elem 

func (o HttpRouteRuleActionRetryPolicyPtrOutput) Elem() HttpRouteRuleActionRetryPolicyOutput

func (HttpRouteRuleActionRetryPolicyPtrOutput) ElementType 

func (HttpRouteRuleActionRetryPolicyPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRetryPolicyPtrOutput) NumRetries 

func (o HttpRouteRuleActionRetryPolicyPtrOutput) NumRetries() pulumi.IntPtrOutput

Specifies the allowed number of retries.

func (HttpRouteRuleActionRetryPolicyPtrOutput) PerTryTimeout 

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 

func (o HttpRouteRuleActionRetryPolicyPtrOutput) RetryConditions() pulumi.StringArrayOutput

Specifies one or more conditions when this retry policy applies.

func (HttpRouteRuleActionRetryPolicyPtrOutput) ToHttpRouteRuleActionRetryPolicyPtrOutput 

func (o HttpRouteRuleActionRetryPolicyPtrOutput) ToHttpRouteRuleActionRetryPolicyPtrOutput() HttpRouteRuleActionRetryPolicyPtrOutput

func (HttpRouteRuleActionRetryPolicyPtrOutput) ToHttpRouteRuleActionRetryPolicyPtrOutputWithContext 

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

type HttpRouteRuleActionUrlRewrite 

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 

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 

func (HttpRouteRuleActionUrlRewriteArgs) ElementType() reflect.Type

func (HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewriteOutput 

func (i HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewriteOutput() HttpRouteRuleActionUrlRewriteOutput

func (HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewriteOutputWithContext 

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

func (HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewritePtrOutput 

func (i HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewritePtrOutput() HttpRouteRuleActionUrlRewritePtrOutput

func (HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewritePtrOutputWithContext 

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

type HttpRouteRuleActionUrlRewriteInput 

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 

type HttpRouteRuleActionUrlRewriteOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionUrlRewriteOutput) ElementType 

func (HttpRouteRuleActionUrlRewriteOutput) ElementType() reflect.Type

func (HttpRouteRuleActionUrlRewriteOutput) HostRewrite 

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 

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 

func (o HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewriteOutput() HttpRouteRuleActionUrlRewriteOutput

func (HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewriteOutputWithContext 

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

func (HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewritePtrOutput 

func (o HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewritePtrOutput() HttpRouteRuleActionUrlRewritePtrOutput

func (HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewritePtrOutputWithContext 

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

type HttpRouteRuleActionUrlRewritePtrInput 

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 

func HttpRouteRuleActionUrlRewritePtr(v *HttpRouteRuleActionUrlRewriteArgs) HttpRouteRuleActionUrlRewritePtrInput

type HttpRouteRuleActionUrlRewritePtrOutput 

type HttpRouteRuleActionUrlRewritePtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionUrlRewritePtrOutput) Elem 

func (o HttpRouteRuleActionUrlRewritePtrOutput) Elem() HttpRouteRuleActionUrlRewriteOutput

func (HttpRouteRuleActionUrlRewritePtrOutput) ElementType 

func (HttpRouteRuleActionUrlRewritePtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionUrlRewritePtrOutput) HostRewrite 

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 

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 

func (o HttpRouteRuleActionUrlRewritePtrOutput) ToHttpRouteRuleActionUrlRewritePtrOutput() HttpRouteRuleActionUrlRewritePtrOutput

func (HttpRouteRuleActionUrlRewritePtrOutput) ToHttpRouteRuleActionUrlRewritePtrOutputWithContext 

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

type HttpRouteRuleArgs 

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 

func (HttpRouteRuleArgs) ElementType() reflect.Type

func (HttpRouteRuleArgs) ToHttpRouteRuleOutput 

func (i HttpRouteRuleArgs) ToHttpRouteRuleOutput() HttpRouteRuleOutput

func (HttpRouteRuleArgs) ToHttpRouteRuleOutputWithContext 

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

type HttpRouteRuleArray 

type HttpRouteRuleArray []HttpRouteRuleInput

func (HttpRouteRuleArray) ElementType 

func (HttpRouteRuleArray) ElementType() reflect.Type

func (HttpRouteRuleArray) ToHttpRouteRuleArrayOutput 

func (i HttpRouteRuleArray) ToHttpRouteRuleArrayOutput() HttpRouteRuleArrayOutput

func (HttpRouteRuleArray) ToHttpRouteRuleArrayOutputWithContext 

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

type HttpRouteRuleArrayInput 

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 

type HttpRouteRuleArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleArrayOutput) ElementType 

func (HttpRouteRuleArrayOutput) ElementType() reflect.Type

func (HttpRouteRuleArrayOutput) Index 

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

func (HttpRouteRuleArrayOutput) ToHttpRouteRuleArrayOutput 

func (o HttpRouteRuleArrayOutput) ToHttpRouteRuleArrayOutput() HttpRouteRuleArrayOutput

func (HttpRouteRuleArrayOutput) ToHttpRouteRuleArrayOutputWithContext 

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

type HttpRouteRuleInput 

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 

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 

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 

func (HttpRouteRuleMatchArgs) ElementType() reflect.Type

func (HttpRouteRuleMatchArgs) ToHttpRouteRuleMatchOutput 

func (i HttpRouteRuleMatchArgs) ToHttpRouteRuleMatchOutput() HttpRouteRuleMatchOutput

func (HttpRouteRuleMatchArgs) ToHttpRouteRuleMatchOutputWithContext 

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

type HttpRouteRuleMatchArray 

type HttpRouteRuleMatchArray []HttpRouteRuleMatchInput

func (HttpRouteRuleMatchArray) ElementType 

func (HttpRouteRuleMatchArray) ElementType() reflect.Type

func (HttpRouteRuleMatchArray) ToHttpRouteRuleMatchArrayOutput 

func (i HttpRouteRuleMatchArray) ToHttpRouteRuleMatchArrayOutput() HttpRouteRuleMatchArrayOutput

func (HttpRouteRuleMatchArray) ToHttpRouteRuleMatchArrayOutputWithContext 

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

type HttpRouteRuleMatchArrayInput 

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 

type HttpRouteRuleMatchArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchArrayOutput) ElementType 

func (HttpRouteRuleMatchArrayOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchArrayOutput) Index 

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

func (HttpRouteRuleMatchArrayOutput) ToHttpRouteRuleMatchArrayOutput 

func (o HttpRouteRuleMatchArrayOutput) ToHttpRouteRuleMatchArrayOutput() HttpRouteRuleMatchArrayOutput

func (HttpRouteRuleMatchArrayOutput) ToHttpRouteRuleMatchArrayOutputWithContext 

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

type HttpRouteRuleMatchHeader 

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 

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 

func (HttpRouteRuleMatchHeaderArgs) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderArgs) ToHttpRouteRuleMatchHeaderOutput 

func (i HttpRouteRuleMatchHeaderArgs) ToHttpRouteRuleMatchHeaderOutput() HttpRouteRuleMatchHeaderOutput

func (HttpRouteRuleMatchHeaderArgs) ToHttpRouteRuleMatchHeaderOutputWithContext 

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

type HttpRouteRuleMatchHeaderArray 

type HttpRouteRuleMatchHeaderArray []HttpRouteRuleMatchHeaderInput

func (HttpRouteRuleMatchHeaderArray) ElementType 

func (HttpRouteRuleMatchHeaderArray) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderArray) ToHttpRouteRuleMatchHeaderArrayOutput 

func (i HttpRouteRuleMatchHeaderArray) ToHttpRouteRuleMatchHeaderArrayOutput() HttpRouteRuleMatchHeaderArrayOutput

func (HttpRouteRuleMatchHeaderArray) ToHttpRouteRuleMatchHeaderArrayOutputWithContext 

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

type HttpRouteRuleMatchHeaderArrayInput 

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 

type HttpRouteRuleMatchHeaderArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchHeaderArrayOutput) ElementType 

func (HttpRouteRuleMatchHeaderArrayOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderArrayOutput) Index 

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

func (HttpRouteRuleMatchHeaderArrayOutput) ToHttpRouteRuleMatchHeaderArrayOutput 

func (o HttpRouteRuleMatchHeaderArrayOutput) ToHttpRouteRuleMatchHeaderArrayOutput() HttpRouteRuleMatchHeaderArrayOutput

func (HttpRouteRuleMatchHeaderArrayOutput) ToHttpRouteRuleMatchHeaderArrayOutputWithContext 

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

type HttpRouteRuleMatchHeaderInput 

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 

type HttpRouteRuleMatchHeaderOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchHeaderOutput) ElementType 

func (HttpRouteRuleMatchHeaderOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderOutput) ExactMatch 

func (o HttpRouteRuleMatchHeaderOutput) ExactMatch() pulumi.StringPtrOutput

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

func (HttpRouteRuleMatchHeaderOutput) Header 

func (o HttpRouteRuleMatchHeaderOutput) Header() pulumi.StringPtrOutput

The name of the HTTP header to match against.

func (HttpRouteRuleMatchHeaderOutput) InvertMatch 

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 

func (o HttpRouteRuleMatchHeaderOutput) PrefixMatch() pulumi.StringPtrOutput

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

func (HttpRouteRuleMatchHeaderOutput) PresentMatch 

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 

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 

func (o HttpRouteRuleMatchHeaderOutput) RegexMatch() pulumi.StringPtrOutput

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

func (HttpRouteRuleMatchHeaderOutput) SuffixMatch 

func (o HttpRouteRuleMatchHeaderOutput) SuffixMatch() pulumi.StringPtrOutput

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

func (HttpRouteRuleMatchHeaderOutput) ToHttpRouteRuleMatchHeaderOutput 

func (o HttpRouteRuleMatchHeaderOutput) ToHttpRouteRuleMatchHeaderOutput() HttpRouteRuleMatchHeaderOutput

func (HttpRouteRuleMatchHeaderOutput) ToHttpRouteRuleMatchHeaderOutputWithContext 

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

type HttpRouteRuleMatchHeaderRangeMatch 

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

type HttpRouteRuleMatchHeaderRangeMatchArgs 

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 

func (HttpRouteRuleMatchHeaderRangeMatchArgs) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchOutput 

func (i HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchOutput() HttpRouteRuleMatchHeaderRangeMatchOutput

func (HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchOutputWithContext 

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

func (HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput 

func (i HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput() HttpRouteRuleMatchHeaderRangeMatchPtrOutput

func (HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutputWithContext 

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

type HttpRouteRuleMatchHeaderRangeMatchInput 

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 

type HttpRouteRuleMatchHeaderRangeMatchOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ElementType 

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderRangeMatchOutput) End 

func (o HttpRouteRuleMatchHeaderRangeMatchOutput) End() pulumi.IntOutput

End of the range (exclusive).

func (HttpRouteRuleMatchHeaderRangeMatchOutput) Start 

func (o HttpRouteRuleMatchHeaderRangeMatchOutput) Start() pulumi.IntOutput

Start of the range (inclusive).

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchOutput 

func (o HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchOutput() HttpRouteRuleMatchHeaderRangeMatchOutput

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchOutputWithContext 

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

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput 

func (o HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput() HttpRouteRuleMatchHeaderRangeMatchPtrOutput

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutputWithContext 

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

type HttpRouteRuleMatchHeaderRangeMatchPtrInput 

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 

func HttpRouteRuleMatchHeaderRangeMatchPtr(v *HttpRouteRuleMatchHeaderRangeMatchArgs) HttpRouteRuleMatchHeaderRangeMatchPtrInput

type HttpRouteRuleMatchHeaderRangeMatchPtrOutput 

type HttpRouteRuleMatchHeaderRangeMatchPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) Elem 

func (o HttpRouteRuleMatchHeaderRangeMatchPtrOutput) Elem() HttpRouteRuleMatchHeaderRangeMatchOutput

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) ElementType 

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) End 

func (o HttpRouteRuleMatchHeaderRangeMatchPtrOutput) End() pulumi.IntPtrOutput

End of the range (exclusive).

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) Start 

func (o HttpRouteRuleMatchHeaderRangeMatchPtrOutput) Start() pulumi.IntPtrOutput

Start of the range (inclusive).

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput 

func (o HttpRouteRuleMatchHeaderRangeMatchPtrOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput() HttpRouteRuleMatchHeaderRangeMatchPtrOutput

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutputWithContext 

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

type HttpRouteRuleMatchInput 

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 

type HttpRouteRuleMatchOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchOutput) ElementType 

func (HttpRouteRuleMatchOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchOutput) FullPathMatch 

func (o HttpRouteRuleMatchOutput) FullPathMatch() pulumi.StringPtrOutput

The HTTP request path value should exactly match this value.

func (HttpRouteRuleMatchOutput) Headers 

func (o HttpRouteRuleMatchOutput) Headers() HttpRouteRuleMatchHeaderArrayOutput

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

func (HttpRouteRuleMatchOutput) IgnoreCase 

func (o HttpRouteRuleMatchOutput) IgnoreCase() pulumi.BoolPtrOutput

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

func (HttpRouteRuleMatchOutput) PrefixMatch 

func (o HttpRouteRuleMatchOutput) PrefixMatch() pulumi.StringPtrOutput

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

func (HttpRouteRuleMatchOutput) QueryParameters 

func (o HttpRouteRuleMatchOutput) QueryParameters() HttpRouteRuleMatchQueryParameterArrayOutput

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

func (HttpRouteRuleMatchOutput) RegexMatch 

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 

func (o HttpRouteRuleMatchOutput) ToHttpRouteRuleMatchOutput() HttpRouteRuleMatchOutput

func (HttpRouteRuleMatchOutput) ToHttpRouteRuleMatchOutputWithContext 

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

type HttpRouteRuleMatchQueryParameter 

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 

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 

func (HttpRouteRuleMatchQueryParameterArgs) ElementType() reflect.Type

func (HttpRouteRuleMatchQueryParameterArgs) ToHttpRouteRuleMatchQueryParameterOutput 

func (i HttpRouteRuleMatchQueryParameterArgs) ToHttpRouteRuleMatchQueryParameterOutput() HttpRouteRuleMatchQueryParameterOutput

func (HttpRouteRuleMatchQueryParameterArgs) ToHttpRouteRuleMatchQueryParameterOutputWithContext 

func (i HttpRouteRuleMatchQueryParameterArgs) ToHttpRouteRuleMatchQueryParameterOutputWithContext(ctx context.Context) HttpRouteRuleMatchQueryParameterOutput

type HttpRouteRuleMatchQueryParameterArray 

type HttpRouteRuleMatchQueryParameterArray []HttpRouteRuleMatchQueryParameterInput

func (HttpRouteRuleMatchQueryParameterArray) ElementType 

func (HttpRouteRuleMatchQueryParameterArray) ElementType() reflect.Type

func (HttpRouteRuleMatchQueryParameterArray) ToHttpRouteRuleMatchQueryParameterArrayOutput 

func (i HttpRouteRuleMatchQueryParameterArray) ToHttpRouteRuleMatchQueryParameterArrayOutput() HttpRouteRuleMatchQueryParameterArrayOutput

func (HttpRouteRuleMatchQueryParameterArray) ToHttpRouteRuleMatchQueryParameterArrayOutputWithContext 

func (i HttpRouteRuleMatchQueryParameterArray) ToHttpRouteRuleMatchQueryParameterArrayOutputWithContext(ctx context.Context) HttpRouteRuleMatchQueryParameterArrayOutput

type HttpRouteRuleMatchQueryParameterArrayInput 

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 

type HttpRouteRuleMatchQueryParameterArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchQueryParameterArrayOutput) ElementType 

func (HttpRouteRuleMatchQueryParameterArrayOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchQueryParameterArrayOutput) Index 

func (o HttpRouteRuleMatchQueryParameterArrayOutput) Index(i pulumi.IntInput) HttpRouteRuleMatchQueryParameterOutput

func (HttpRouteRuleMatchQueryParameterArrayOutput) ToHttpRouteRuleMatchQueryParameterArrayOutput 

func (o HttpRouteRuleMatchQueryParameterArrayOutput) ToHttpRouteRuleMatchQueryParameterArrayOutput() HttpRouteRuleMatchQueryParameterArrayOutput

func (HttpRouteRuleMatchQueryParameterArrayOutput) ToHttpRouteRuleMatchQueryParameterArrayOutputWithContext 

func (o HttpRouteRuleMatchQueryParameterArrayOutput) ToHttpRouteRuleMatchQueryParameterArrayOutputWithContext(ctx context.Context) HttpRouteRuleMatchQueryParameterArrayOutput

type HttpRouteRuleMatchQueryParameterInput 

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 

type HttpRouteRuleMatchQueryParameterOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchQueryParameterOutput) ElementType 

func (HttpRouteRuleMatchQueryParameterOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchQueryParameterOutput) ExactMatch 

func (o HttpRouteRuleMatchQueryParameterOutput) ExactMatch() pulumi.StringPtrOutput

The value of the query parameter must exactly match the contents of exactMatch.

func (HttpRouteRuleMatchQueryParameterOutput) PresentMatch 

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 

func (o HttpRouteRuleMatchQueryParameterOutput) QueryParameter() pulumi.StringPtrOutput

The name of the query parameter to match.

func (HttpRouteRuleMatchQueryParameterOutput) RegexMatch 

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 

func (o HttpRouteRuleMatchQueryParameterOutput) ToHttpRouteRuleMatchQueryParameterOutput() HttpRouteRuleMatchQueryParameterOutput

func (HttpRouteRuleMatchQueryParameterOutput) ToHttpRouteRuleMatchQueryParameterOutputWithContext 

func (o HttpRouteRuleMatchQueryParameterOutput) ToHttpRouteRuleMatchQueryParameterOutputWithContext(ctx context.Context) HttpRouteRuleMatchQueryParameterOutput

type HttpRouteRuleOutput 

type HttpRouteRuleOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleOutput) Action 

func (o HttpRouteRuleOutput) Action() HttpRouteRuleActionPtrOutput

The detailed rule defining how to route matched traffic. Structure is documented below.

func (HttpRouteRuleOutput) ElementType 

func (HttpRouteRuleOutput) ElementType() reflect.Type

func (HttpRouteRuleOutput) Matches 

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 

func (o HttpRouteRuleOutput) ToHttpRouteRuleOutput() HttpRouteRuleOutput

func (HttpRouteRuleOutput) ToHttpRouteRuleOutputWithContext 

func (o HttpRouteRuleOutput) ToHttpRouteRuleOutputWithContext(ctx context.Context) HttpRouteRuleOutput

type HttpRouteState 

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
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// 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. **Note**: This field is non-authoritative, and will only
	// manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
	// present on the resource.
	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
	Project pulumi.StringPtrInput
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
	// 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 

func (HttpRouteState) ElementType() reflect.Type

type Mesh 

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"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// 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.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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"`
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
	// 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/v7/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{
			Name: pulumi.String("my-mesh"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description:      pulumi.String("my description"),
			InterceptionPort: pulumi.Int(443),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Mesh No Port

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/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{
			Name: pulumi.String("my-mesh-noport"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Mesh can be imported using any of these accepted formats:

* `projects/{{project}}/locations/global/meshes/{{name}}`

* `{{project}}/{{name}}`

* `{{name}}`

When using the `pulumi import` command, Mesh can be imported using one of the formats above. For example:

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

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 

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 

func (*Mesh) ElementType() reflect.Type

func (*Mesh) ToMeshOutput 

func (i *Mesh) ToMeshOutput() MeshOutput

func (*Mesh) ToMeshOutputWithContext 

func (i *Mesh) ToMeshOutputWithContext(ctx context.Context) MeshOutput

type MeshArgs 

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.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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 

func (MeshArgs) ElementType() reflect.Type

type MeshArray 

type MeshArray []MeshInput

func (MeshArray) ElementType 

func (MeshArray) ElementType() reflect.Type

func (MeshArray) ToMeshArrayOutput 

func (i MeshArray) ToMeshArrayOutput() MeshArrayOutput

func (MeshArray) ToMeshArrayOutputWithContext 

func (i MeshArray) ToMeshArrayOutputWithContext(ctx context.Context) MeshArrayOutput

type MeshArrayInput 

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 

type MeshArrayOutput struct{ *pulumi.OutputState }

func (MeshArrayOutput) ElementType 

func (MeshArrayOutput) ElementType() reflect.Type

func (MeshArrayOutput) Index 

func (o MeshArrayOutput) Index(i pulumi.IntInput) MeshOutput

func (MeshArrayOutput) ToMeshArrayOutput 

func (o MeshArrayOutput) ToMeshArrayOutput() MeshArrayOutput

func (MeshArrayOutput) ToMeshArrayOutputWithContext 

func (o MeshArrayOutput) ToMeshArrayOutputWithContext(ctx context.Context) MeshArrayOutput

type MeshInput 

type MeshInput interface {
	pulumi.Input

	ToMeshOutput() MeshOutput
	ToMeshOutputWithContext(ctx context.Context) MeshOutput
}

type MeshMap 

type MeshMap map[string]MeshInput

func (MeshMap) ElementType 

func (MeshMap) ElementType() reflect.Type

func (MeshMap) ToMeshMapOutput 

func (i MeshMap) ToMeshMapOutput() MeshMapOutput

func (MeshMap) ToMeshMapOutputWithContext 

func (i MeshMap) ToMeshMapOutputWithContext(ctx context.Context) MeshMapOutput

type MeshMapInput 

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 

type MeshMapOutput struct{ *pulumi.OutputState }

func (MeshMapOutput) ElementType 

func (MeshMapOutput) ElementType() reflect.Type

func (MeshMapOutput) MapIndex 

func (o MeshMapOutput) MapIndex(k pulumi.StringInput) MeshOutput

func (MeshMapOutput) ToMeshMapOutput 

func (o MeshMapOutput) ToMeshMapOutput() MeshMapOutput

func (MeshMapOutput) ToMeshMapOutputWithContext 

func (o MeshMapOutput) ToMeshMapOutputWithContext(ctx context.Context) MeshMapOutput

type MeshOutput 

type MeshOutput struct{ *pulumi.OutputState }

func (MeshOutput) CreateTime 

func (o MeshOutput) CreateTime() pulumi.StringOutput

Time the Mesh was created in UTC.

func (MeshOutput) Description 

func (o MeshOutput) Description() pulumi.StringPtrOutput

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

func (MeshOutput) EffectiveLabels 

func (o MeshOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (MeshOutput) ElementType 

func (MeshOutput) ElementType() reflect.Type

func (MeshOutput) InterceptionPort 

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 

func (o MeshOutput) Labels() pulumi.StringMapOutput

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

func (MeshOutput) Name 

func (o MeshOutput) Name() pulumi.StringOutput

Short name of the Mesh resource to be created.

***

func (MeshOutput) Project 

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 (MeshOutput) PulumiLabels 

func (o MeshOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider. 

func (o MeshOutput) SelfLink() pulumi.StringOutput

Server-defined URL of this resource.

func (MeshOutput) ToMeshOutput 

func (o MeshOutput) ToMeshOutput() MeshOutput

func (MeshOutput) ToMeshOutputWithContext 

func (o MeshOutput) ToMeshOutputWithContext(ctx context.Context) MeshOutput

func (MeshOutput) UpdateTime 

func (o MeshOutput) UpdateTime() pulumi.StringOutput

Time the Mesh was updated in UTC.

type MeshState 

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
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// 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.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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 combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
	// Server-defined URL of this resource.
	SelfLink pulumi.StringPtrInput
	// Time the Mesh was updated in UTC.
	UpdateTime pulumi.StringPtrInput
}

func (MeshState) ElementType 

func (MeshState) ElementType() reflect.Type

type ServiceBinding 

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"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// Set of label tags associated with the ServiceBinding resource.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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 combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
	// 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/v7/go/gcp/networkservices"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/servicedirectory"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := servicedirectory.NewNamespace(ctx, "default", &servicedirectory.NamespaceArgs{
			NamespaceId: pulumi.String("my-namespace"),
			Location:    pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		defaultService, err := servicedirectory.NewService(ctx, "default", &servicedirectory.ServiceArgs{
			ServiceId: pulumi.String("my-service"),
			Namespace: _default.ID(),
			Metadata: pulumi.StringMap{
				"stage":  pulumi.String("prod"),
				"region": pulumi.String("us-central1"),
			},
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewServiceBinding(ctx, "default", &networkservices.ServiceBindingArgs{
			Name: pulumi.String("my-service-binding"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Service:     defaultService.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

ServiceBinding can be imported using any of these accepted formats:

* `projects/{{project}}/locations/global/serviceBindings/{{name}}`

* `{{project}}/{{name}}`

* `{{name}}`

When using the `pulumi import` command, ServiceBinding can be imported using one of the formats above. For example:

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

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 

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 

func (*ServiceBinding) ElementType() reflect.Type

func (*ServiceBinding) ToServiceBindingOutput 

func (i *ServiceBinding) ToServiceBindingOutput() ServiceBindingOutput

func (*ServiceBinding) ToServiceBindingOutputWithContext 

func (i *ServiceBinding) ToServiceBindingOutputWithContext(ctx context.Context) ServiceBindingOutput

type ServiceBindingArgs 

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.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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 

func (ServiceBindingArgs) ElementType() reflect.Type

type ServiceBindingArray 

type ServiceBindingArray []ServiceBindingInput

func (ServiceBindingArray) ElementType 

func (ServiceBindingArray) ElementType() reflect.Type

func (ServiceBindingArray) ToServiceBindingArrayOutput 

func (i ServiceBindingArray) ToServiceBindingArrayOutput() ServiceBindingArrayOutput

func (ServiceBindingArray) ToServiceBindingArrayOutputWithContext 

func (i ServiceBindingArray) ToServiceBindingArrayOutputWithContext(ctx context.Context) ServiceBindingArrayOutput

type ServiceBindingArrayInput 

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 

type ServiceBindingArrayOutput struct{ *pulumi.OutputState }

func (ServiceBindingArrayOutput) ElementType 

func (ServiceBindingArrayOutput) ElementType() reflect.Type

func (ServiceBindingArrayOutput) Index 

func (o ServiceBindingArrayOutput) Index(i pulumi.IntInput) ServiceBindingOutput

func (ServiceBindingArrayOutput) ToServiceBindingArrayOutput 

func (o ServiceBindingArrayOutput) ToServiceBindingArrayOutput() ServiceBindingArrayOutput

func (ServiceBindingArrayOutput) ToServiceBindingArrayOutputWithContext 

func (o ServiceBindingArrayOutput) ToServiceBindingArrayOutputWithContext(ctx context.Context) ServiceBindingArrayOutput

type ServiceBindingInput 

type ServiceBindingInput interface {
	pulumi.Input

	ToServiceBindingOutput() ServiceBindingOutput
	ToServiceBindingOutputWithContext(ctx context.Context) ServiceBindingOutput
}

type ServiceBindingMap 

type ServiceBindingMap map[string]ServiceBindingInput

func (ServiceBindingMap) ElementType 

func (ServiceBindingMap) ElementType() reflect.Type

func (ServiceBindingMap) ToServiceBindingMapOutput 

func (i ServiceBindingMap) ToServiceBindingMapOutput() ServiceBindingMapOutput

func (ServiceBindingMap) ToServiceBindingMapOutputWithContext 

func (i ServiceBindingMap) ToServiceBindingMapOutputWithContext(ctx context.Context) ServiceBindingMapOutput

type ServiceBindingMapInput 

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 

type ServiceBindingMapOutput struct{ *pulumi.OutputState }

func (ServiceBindingMapOutput) ElementType 

func (ServiceBindingMapOutput) ElementType() reflect.Type

func (ServiceBindingMapOutput) MapIndex 

func (o ServiceBindingMapOutput) MapIndex(k pulumi.StringInput) ServiceBindingOutput

func (ServiceBindingMapOutput) ToServiceBindingMapOutput 

func (o ServiceBindingMapOutput) ToServiceBindingMapOutput() ServiceBindingMapOutput

func (ServiceBindingMapOutput) ToServiceBindingMapOutputWithContext 

func (o ServiceBindingMapOutput) ToServiceBindingMapOutputWithContext(ctx context.Context) ServiceBindingMapOutput

type ServiceBindingOutput 

type ServiceBindingOutput struct{ *pulumi.OutputState }

func (ServiceBindingOutput) CreateTime 

func (o ServiceBindingOutput) CreateTime() pulumi.StringOutput

Time the ServiceBinding was created in UTC.

func (ServiceBindingOutput) Description 

func (o ServiceBindingOutput) Description() pulumi.StringPtrOutput

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

func (ServiceBindingOutput) EffectiveLabels 

func (o ServiceBindingOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (ServiceBindingOutput) ElementType 

func (ServiceBindingOutput) ElementType() reflect.Type

func (ServiceBindingOutput) Labels 

func (o ServiceBindingOutput) Labels() pulumi.StringMapOutput

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

func (ServiceBindingOutput) Name 

func (o ServiceBindingOutput) Name() pulumi.StringOutput

Name of the ServiceBinding resource.

***

func (ServiceBindingOutput) Project 

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) PulumiLabels 

func (o ServiceBindingOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider.

func (ServiceBindingOutput) Service 

func (o ServiceBindingOutput) Service() pulumi.StringOutput

The full Service Directory Service name of the format projects/*/locations/*/namespaces/*/services/*

func (ServiceBindingOutput) ToServiceBindingOutput 

func (o ServiceBindingOutput) ToServiceBindingOutput() ServiceBindingOutput

func (ServiceBindingOutput) ToServiceBindingOutputWithContext 

func (o ServiceBindingOutput) ToServiceBindingOutputWithContext(ctx context.Context) ServiceBindingOutput

func (ServiceBindingOutput) UpdateTime 

func (o ServiceBindingOutput) UpdateTime() pulumi.StringOutput

Time the ServiceBinding was updated in UTC.

type ServiceBindingState 

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
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// Set of label tags associated with the ServiceBinding resource.
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the 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 combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
	// 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 

func (ServiceBindingState) ElementType() reflect.Type

type TcpRoute 

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"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// 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. **Note**: This field is non-authoritative, and will only manage
	// the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on
	// the resource.
	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"`
	Project pulumi.StringOutput `pulumi:"project"`
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
	// 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

### Network Services Tcp Route Basic

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultHttpHealthCheck, err := compute.NewHttpHealthCheck(ctx, "default", &compute.HttpHealthCheckArgs{
			Name:             pulumi.String("backend-service-health-check"),
			RequestPath:      pulumi.String("/"),
			CheckIntervalSec: pulumi.Int(1),
			TimeoutSec:       pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendService(ctx, "default", &compute.BackendServiceArgs{
			Name:         pulumi.String("my-backend-service"),
			HealthChecks: defaultHttpHealthCheck.ID(),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewTcpRoute(ctx, "default", &networkservices.TcpRouteArgs{
			Name: pulumi.String("my-tcp-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Rules: networkservices.TcpRouteRuleArray{
				&networkservices.TcpRouteRuleArgs{
					Matches: networkservices.TcpRouteRuleMatchArray{
						&networkservices.TcpRouteRuleMatchArgs{
							Address: pulumi.String("10.0.0.1/32"),
							Port:    pulumi.String("8081"),
						},
					},
					Action: &networkservices.TcpRouteRuleActionArgs{
						Destinations: networkservices.TcpRouteRuleActionDestinationArray{
							&networkservices.TcpRouteRuleActionDestinationArgs{
								ServiceName: _default.ID(),
								Weight:      pulumi.Int(1),
							},
						},
						OriginalDestination: pulumi.Bool(false),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Tcp Route Actions

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultHttpHealthCheck, err := compute.NewHttpHealthCheck(ctx, "default", &compute.HttpHealthCheckArgs{
			Name:             pulumi.String("backend-service-health-check"),
			RequestPath:      pulumi.String("/"),
			CheckIntervalSec: pulumi.Int(1),
			TimeoutSec:       pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendService(ctx, "default", &compute.BackendServiceArgs{
			Name:         pulumi.String("my-backend-service"),
			HealthChecks: defaultHttpHealthCheck.ID(),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewTcpRoute(ctx, "default", &networkservices.TcpRouteArgs{
			Name: pulumi.String("my-tcp-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Rules: networkservices.TcpRouteRuleArray{
				&networkservices.TcpRouteRuleArgs{
					Action: &networkservices.TcpRouteRuleActionArgs{
						Destinations: networkservices.TcpRouteRuleActionDestinationArray{
							&networkservices.TcpRouteRuleActionDestinationArgs{
								ServiceName: _default.ID(),
								Weight:      pulumi.Int(1),
							},
						},
						OriginalDestination: pulumi.Bool(false),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Tcp Route Mesh Basic

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultHttpHealthCheck, err := compute.NewHttpHealthCheck(ctx, "default", &compute.HttpHealthCheckArgs{
			Name:             pulumi.String("backend-service-health-check"),
			RequestPath:      pulumi.String("/"),
			CheckIntervalSec: pulumi.Int(1),
			TimeoutSec:       pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendService(ctx, "default", &compute.BackendServiceArgs{
			Name:         pulumi.String("my-backend-service"),
			HealthChecks: defaultHttpHealthCheck.ID(),
		})
		if err != nil {
			return err
		}
		defaultMesh, err := networkservices.NewMesh(ctx, "default", &networkservices.MeshArgs{
			Name: pulumi.String("my-tcp-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewTcpRoute(ctx, "default", &networkservices.TcpRouteArgs{
			Name: pulumi.String("my-tcp-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Meshes: pulumi.StringArray{
				defaultMesh.ID(),
			},
			Rules: networkservices.TcpRouteRuleArray{
				&networkservices.TcpRouteRuleArgs{
					Matches: networkservices.TcpRouteRuleMatchArray{
						&networkservices.TcpRouteRuleMatchArgs{
							Address: pulumi.String("10.0.0.1/32"),
							Port:    pulumi.String("8081"),
						},
					},
					Action: &networkservices.TcpRouteRuleActionArgs{
						Destinations: networkservices.TcpRouteRuleActionDestinationArray{
							&networkservices.TcpRouteRuleActionDestinationArgs{
								ServiceName: _default.ID(),
								Weight:      pulumi.Int(1),
							},
						},
						OriginalDestination: pulumi.Bool(false),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Tcp Route Gateway Basic

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultHttpHealthCheck, err := compute.NewHttpHealthCheck(ctx, "default", &compute.HttpHealthCheckArgs{
			Name:             pulumi.String("backend-service-health-check"),
			RequestPath:      pulumi.String("/"),
			CheckIntervalSec: pulumi.Int(1),
			TimeoutSec:       pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendService(ctx, "default", &compute.BackendServiceArgs{
			Name:         pulumi.String("my-backend-service"),
			HealthChecks: defaultHttpHealthCheck.ID(),
		})
		if err != nil {
			return err
		}
		defaultGateway, err := networkservices.NewGateway(ctx, "default", &networkservices.GatewayArgs{
			Name: pulumi.String("my-tcp-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Scope:       pulumi.String("my-scope"),
			Type:        pulumi.String("OPEN_MESH"),
			Ports: pulumi.IntArray{
				pulumi.Int(443),
			},
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewTcpRoute(ctx, "default", &networkservices.TcpRouteArgs{
			Name: pulumi.String("my-tcp-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Gateways: pulumi.StringArray{
				defaultGateway.ID(),
			},
			Rules: networkservices.TcpRouteRuleArray{
				&networkservices.TcpRouteRuleArgs{
					Matches: networkservices.TcpRouteRuleMatchArray{
						&networkservices.TcpRouteRuleMatchArgs{
							Address: pulumi.String("10.0.0.1/32"),
							Port:    pulumi.String("8081"),
						},
					},
					Action: &networkservices.TcpRouteRuleActionArgs{
						Destinations: networkservices.TcpRouteRuleActionDestinationArray{
							&networkservices.TcpRouteRuleActionDestinationArgs{
								ServiceName: _default.ID(),
								Weight:      pulumi.Int(1),
							},
						},
						OriginalDestination: pulumi.Bool(false),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

TcpRoute can be imported using any of these accepted formats:

* `projects/{{project}}/locations/global/tcpRoutes/{{name}}`

* `{{project}}/{{name}}`

* `{{name}}`

When using the `pulumi import` command, TcpRoute can be imported using one of the formats above. For example:

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

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 

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 

func (*TcpRoute) ElementType() reflect.Type

func (*TcpRoute) ToTcpRouteOutput 

func (i *TcpRoute) ToTcpRouteOutput() TcpRouteOutput

func (*TcpRoute) ToTcpRouteOutputWithContext 

func (i *TcpRoute) ToTcpRouteOutputWithContext(ctx context.Context) TcpRouteOutput

type TcpRouteArgs 

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. **Note**: This field is non-authoritative, and will only manage
	// the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on
	// the resource.
	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
	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 

func (TcpRouteArgs) ElementType() reflect.Type

type TcpRouteArray 

type TcpRouteArray []TcpRouteInput

func (TcpRouteArray) ElementType 

func (TcpRouteArray) ElementType() reflect.Type

func (TcpRouteArray) ToTcpRouteArrayOutput 

func (i TcpRouteArray) ToTcpRouteArrayOutput() TcpRouteArrayOutput

func (TcpRouteArray) ToTcpRouteArrayOutputWithContext 

func (i TcpRouteArray) ToTcpRouteArrayOutputWithContext(ctx context.Context) TcpRouteArrayOutput

type TcpRouteArrayInput 

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 

type TcpRouteArrayOutput struct{ *pulumi.OutputState }

func (TcpRouteArrayOutput) ElementType 

func (TcpRouteArrayOutput) ElementType() reflect.Type

func (TcpRouteArrayOutput) Index 

func (o TcpRouteArrayOutput) Index(i pulumi.IntInput) TcpRouteOutput

func (TcpRouteArrayOutput) ToTcpRouteArrayOutput 

func (o TcpRouteArrayOutput) ToTcpRouteArrayOutput() TcpRouteArrayOutput

func (TcpRouteArrayOutput) ToTcpRouteArrayOutputWithContext 

func (o TcpRouteArrayOutput) ToTcpRouteArrayOutputWithContext(ctx context.Context) TcpRouteArrayOutput

type TcpRouteInput 

type TcpRouteInput interface {
	pulumi.Input

	ToTcpRouteOutput() TcpRouteOutput
	ToTcpRouteOutputWithContext(ctx context.Context) TcpRouteOutput
}

type TcpRouteMap 

type TcpRouteMap map[string]TcpRouteInput

func (TcpRouteMap) ElementType 

func (TcpRouteMap) ElementType() reflect.Type

func (TcpRouteMap) ToTcpRouteMapOutput 

func (i TcpRouteMap) ToTcpRouteMapOutput() TcpRouteMapOutput

func (TcpRouteMap) ToTcpRouteMapOutputWithContext 

func (i TcpRouteMap) ToTcpRouteMapOutputWithContext(ctx context.Context) TcpRouteMapOutput

type TcpRouteMapInput 

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 

type TcpRouteMapOutput struct{ *pulumi.OutputState }

func (TcpRouteMapOutput) ElementType 

func (TcpRouteMapOutput) ElementType() reflect.Type

func (TcpRouteMapOutput) MapIndex 

func (o TcpRouteMapOutput) MapIndex(k pulumi.StringInput) TcpRouteOutput

func (TcpRouteMapOutput) ToTcpRouteMapOutput 

func (o TcpRouteMapOutput) ToTcpRouteMapOutput() TcpRouteMapOutput

func (TcpRouteMapOutput) ToTcpRouteMapOutputWithContext 

func (o TcpRouteMapOutput) ToTcpRouteMapOutputWithContext(ctx context.Context) TcpRouteMapOutput

type TcpRouteOutput 

type TcpRouteOutput struct{ *pulumi.OutputState }

func (TcpRouteOutput) CreateTime 

func (o TcpRouteOutput) CreateTime() pulumi.StringOutput

Time the TcpRoute was created in UTC.

func (TcpRouteOutput) Description 

func (o TcpRouteOutput) Description() pulumi.StringPtrOutput

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

func (TcpRouteOutput) EffectiveLabels 

func (o TcpRouteOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (TcpRouteOutput) ElementType 

func (TcpRouteOutput) ElementType() reflect.Type

func (TcpRouteOutput) Gateways 

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 

func (o TcpRouteOutput) Labels() pulumi.StringMapOutput

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

func (TcpRouteOutput) Meshes 

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 

func (o TcpRouteOutput) Name() pulumi.StringOutput

Name of the TcpRoute resource.

func (TcpRouteOutput) Project 

func (o TcpRouteOutput) Project() pulumi.StringOutput

func (TcpRouteOutput) PulumiLabels 

func (o TcpRouteOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider.

func (TcpRouteOutput) Rules 

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 

func (o TcpRouteOutput) ToTcpRouteOutput() TcpRouteOutput

func (TcpRouteOutput) ToTcpRouteOutputWithContext 

func (o TcpRouteOutput) ToTcpRouteOutputWithContext(ctx context.Context) TcpRouteOutput

func (TcpRouteOutput) UpdateTime 

func (o TcpRouteOutput) UpdateTime() pulumi.StringOutput

Time the TcpRoute was updated in UTC.

type TcpRouteRule 

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 

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 

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 

func (TcpRouteRuleActionArgs) ElementType() reflect.Type

func (TcpRouteRuleActionArgs) ToTcpRouteRuleActionOutput 

func (i TcpRouteRuleActionArgs) ToTcpRouteRuleActionOutput() TcpRouteRuleActionOutput

func (TcpRouteRuleActionArgs) ToTcpRouteRuleActionOutputWithContext 

func (i TcpRouteRuleActionArgs) ToTcpRouteRuleActionOutputWithContext(ctx context.Context) TcpRouteRuleActionOutput

type TcpRouteRuleActionDestination 

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 

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 

func (TcpRouteRuleActionDestinationArgs) ElementType() reflect.Type

func (TcpRouteRuleActionDestinationArgs) ToTcpRouteRuleActionDestinationOutput 

func (i TcpRouteRuleActionDestinationArgs) ToTcpRouteRuleActionDestinationOutput() TcpRouteRuleActionDestinationOutput

func (TcpRouteRuleActionDestinationArgs) ToTcpRouteRuleActionDestinationOutputWithContext 

func (i TcpRouteRuleActionDestinationArgs) ToTcpRouteRuleActionDestinationOutputWithContext(ctx context.Context) TcpRouteRuleActionDestinationOutput

type TcpRouteRuleActionDestinationArray 

type TcpRouteRuleActionDestinationArray []TcpRouteRuleActionDestinationInput

func (TcpRouteRuleActionDestinationArray) ElementType 

func (TcpRouteRuleActionDestinationArray) ElementType() reflect.Type

func (TcpRouteRuleActionDestinationArray) ToTcpRouteRuleActionDestinationArrayOutput 

func (i TcpRouteRuleActionDestinationArray) ToTcpRouteRuleActionDestinationArrayOutput() TcpRouteRuleActionDestinationArrayOutput

func (TcpRouteRuleActionDestinationArray) ToTcpRouteRuleActionDestinationArrayOutputWithContext 

func (i TcpRouteRuleActionDestinationArray) ToTcpRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) TcpRouteRuleActionDestinationArrayOutput

type TcpRouteRuleActionDestinationArrayInput 

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 

type TcpRouteRuleActionDestinationArrayOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleActionDestinationArrayOutput) ElementType 

func (TcpRouteRuleActionDestinationArrayOutput) ElementType() reflect.Type

func (TcpRouteRuleActionDestinationArrayOutput) Index 

func (o TcpRouteRuleActionDestinationArrayOutput) Index(i pulumi.IntInput) TcpRouteRuleActionDestinationOutput

func (TcpRouteRuleActionDestinationArrayOutput) ToTcpRouteRuleActionDestinationArrayOutput 

func (o TcpRouteRuleActionDestinationArrayOutput) ToTcpRouteRuleActionDestinationArrayOutput() TcpRouteRuleActionDestinationArrayOutput

func (TcpRouteRuleActionDestinationArrayOutput) ToTcpRouteRuleActionDestinationArrayOutputWithContext 

func (o TcpRouteRuleActionDestinationArrayOutput) ToTcpRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) TcpRouteRuleActionDestinationArrayOutput

type TcpRouteRuleActionDestinationInput 

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 

type TcpRouteRuleActionDestinationOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleActionDestinationOutput) ElementType 

func (TcpRouteRuleActionDestinationOutput) ElementType() reflect.Type

func (TcpRouteRuleActionDestinationOutput) ServiceName 

func (o TcpRouteRuleActionDestinationOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (TcpRouteRuleActionDestinationOutput) ToTcpRouteRuleActionDestinationOutput 

func (o TcpRouteRuleActionDestinationOutput) ToTcpRouteRuleActionDestinationOutput() TcpRouteRuleActionDestinationOutput

func (TcpRouteRuleActionDestinationOutput) ToTcpRouteRuleActionDestinationOutputWithContext 

func (o TcpRouteRuleActionDestinationOutput) ToTcpRouteRuleActionDestinationOutputWithContext(ctx context.Context) TcpRouteRuleActionDestinationOutput

func (TcpRouteRuleActionDestinationOutput) Weight 

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 

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 

type TcpRouteRuleActionOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleActionOutput) Destinations 

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 

func (TcpRouteRuleActionOutput) ElementType() reflect.Type

func (TcpRouteRuleActionOutput) OriginalDestination 

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 

func (o TcpRouteRuleActionOutput) ToTcpRouteRuleActionOutput() TcpRouteRuleActionOutput

func (TcpRouteRuleActionOutput) ToTcpRouteRuleActionOutputWithContext 

func (o TcpRouteRuleActionOutput) ToTcpRouteRuleActionOutputWithContext(ctx context.Context) TcpRouteRuleActionOutput

type TcpRouteRuleArgs 

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 

func (TcpRouteRuleArgs) ElementType() reflect.Type

func (TcpRouteRuleArgs) ToTcpRouteRuleOutput 

func (i TcpRouteRuleArgs) ToTcpRouteRuleOutput() TcpRouteRuleOutput

func (TcpRouteRuleArgs) ToTcpRouteRuleOutputWithContext 

func (i TcpRouteRuleArgs) ToTcpRouteRuleOutputWithContext(ctx context.Context) TcpRouteRuleOutput

type TcpRouteRuleArray 

type TcpRouteRuleArray []TcpRouteRuleInput

func (TcpRouteRuleArray) ElementType 

func (TcpRouteRuleArray) ElementType() reflect.Type

func (TcpRouteRuleArray) ToTcpRouteRuleArrayOutput 

func (i TcpRouteRuleArray) ToTcpRouteRuleArrayOutput() TcpRouteRuleArrayOutput

func (TcpRouteRuleArray) ToTcpRouteRuleArrayOutputWithContext 

func (i TcpRouteRuleArray) ToTcpRouteRuleArrayOutputWithContext(ctx context.Context) TcpRouteRuleArrayOutput

type TcpRouteRuleArrayInput 

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 

type TcpRouteRuleArrayOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleArrayOutput) ElementType 

func (TcpRouteRuleArrayOutput) ElementType() reflect.Type

func (TcpRouteRuleArrayOutput) Index 

func (o TcpRouteRuleArrayOutput) Index(i pulumi.IntInput) TcpRouteRuleOutput

func (TcpRouteRuleArrayOutput) ToTcpRouteRuleArrayOutput 

func (o TcpRouteRuleArrayOutput) ToTcpRouteRuleArrayOutput() TcpRouteRuleArrayOutput

func (TcpRouteRuleArrayOutput) ToTcpRouteRuleArrayOutputWithContext 

func (o TcpRouteRuleArrayOutput) ToTcpRouteRuleArrayOutputWithContext(ctx context.Context) TcpRouteRuleArrayOutput

type TcpRouteRuleInput 

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 

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 

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 

func (TcpRouteRuleMatchArgs) ElementType() reflect.Type

func (TcpRouteRuleMatchArgs) ToTcpRouteRuleMatchOutput 

func (i TcpRouteRuleMatchArgs) ToTcpRouteRuleMatchOutput() TcpRouteRuleMatchOutput

func (TcpRouteRuleMatchArgs) ToTcpRouteRuleMatchOutputWithContext 

func (i TcpRouteRuleMatchArgs) ToTcpRouteRuleMatchOutputWithContext(ctx context.Context) TcpRouteRuleMatchOutput

type TcpRouteRuleMatchArray 

type TcpRouteRuleMatchArray []TcpRouteRuleMatchInput

func (TcpRouteRuleMatchArray) ElementType 

func (TcpRouteRuleMatchArray) ElementType() reflect.Type

func (TcpRouteRuleMatchArray) ToTcpRouteRuleMatchArrayOutput 

func (i TcpRouteRuleMatchArray) ToTcpRouteRuleMatchArrayOutput() TcpRouteRuleMatchArrayOutput

func (TcpRouteRuleMatchArray) ToTcpRouteRuleMatchArrayOutputWithContext 

func (i TcpRouteRuleMatchArray) ToTcpRouteRuleMatchArrayOutputWithContext(ctx context.Context) TcpRouteRuleMatchArrayOutput

type TcpRouteRuleMatchArrayInput 

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 

type TcpRouteRuleMatchArrayOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleMatchArrayOutput) ElementType 

func (TcpRouteRuleMatchArrayOutput) ElementType() reflect.Type

func (TcpRouteRuleMatchArrayOutput) Index 

func (o TcpRouteRuleMatchArrayOutput) Index(i pulumi.IntInput) TcpRouteRuleMatchOutput

func (TcpRouteRuleMatchArrayOutput) ToTcpRouteRuleMatchArrayOutput 

func (o TcpRouteRuleMatchArrayOutput) ToTcpRouteRuleMatchArrayOutput() TcpRouteRuleMatchArrayOutput

func (TcpRouteRuleMatchArrayOutput) ToTcpRouteRuleMatchArrayOutputWithContext 

func (o TcpRouteRuleMatchArrayOutput) ToTcpRouteRuleMatchArrayOutputWithContext(ctx context.Context) TcpRouteRuleMatchArrayOutput

type TcpRouteRuleMatchInput 

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 

type TcpRouteRuleMatchOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleMatchOutput) Address 

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 

func (TcpRouteRuleMatchOutput) ElementType() reflect.Type

func (TcpRouteRuleMatchOutput) Port 

func (o TcpRouteRuleMatchOutput) Port() pulumi.StringOutput

Specifies the destination port to match against.

func (TcpRouteRuleMatchOutput) ToTcpRouteRuleMatchOutput 

func (o TcpRouteRuleMatchOutput) ToTcpRouteRuleMatchOutput() TcpRouteRuleMatchOutput

func (TcpRouteRuleMatchOutput) ToTcpRouteRuleMatchOutputWithContext 

func (o TcpRouteRuleMatchOutput) ToTcpRouteRuleMatchOutputWithContext(ctx context.Context) TcpRouteRuleMatchOutput

type TcpRouteRuleOutput 

type TcpRouteRuleOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleOutput) Action 

func (o TcpRouteRuleOutput) Action() TcpRouteRuleActionOutput

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

func (TcpRouteRuleOutput) ElementType 

func (TcpRouteRuleOutput) ElementType() reflect.Type

func (TcpRouteRuleOutput) Matches 

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 

func (o TcpRouteRuleOutput) ToTcpRouteRuleOutput() TcpRouteRuleOutput

func (TcpRouteRuleOutput) ToTcpRouteRuleOutputWithContext 

func (o TcpRouteRuleOutput) ToTcpRouteRuleOutputWithContext(ctx context.Context) TcpRouteRuleOutput

type TcpRouteState 

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
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// 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. **Note**: This field is non-authoritative, and will only manage
	// the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on
	// the resource.
	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
	Project pulumi.StringPtrInput
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
	// 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 

func (TcpRouteState) ElementType() reflect.Type

type TlsRoute 

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"`
	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

### Network Services Tls Route Basic

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultHttpHealthCheck, err := compute.NewHttpHealthCheck(ctx, "default", &compute.HttpHealthCheckArgs{
			Name:             pulumi.String("backend-service-health-check"),
			RequestPath:      pulumi.String("/"),
			CheckIntervalSec: pulumi.Int(1),
			TimeoutSec:       pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendService(ctx, "default", &compute.BackendServiceArgs{
			Name:         pulumi.String("my-backend-service"),
			HealthChecks: defaultHttpHealthCheck.ID(),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewTlsRoute(ctx, "default", &networkservices.TlsRouteArgs{
			Name:        pulumi.String("my-tls-route"),
			Description: pulumi.String("my description"),
			Rules: networkservices.TlsRouteRuleArray{
				&networkservices.TlsRouteRuleArgs{
					Matches: networkservices.TlsRouteRuleMatchArray{
						&networkservices.TlsRouteRuleMatchArgs{
							SniHosts: pulumi.StringArray{
								pulumi.String("example.com"),
							},
							Alpns: pulumi.StringArray{
								pulumi.String("http/1.1"),
							},
						},
					},
					Action: &networkservices.TlsRouteRuleActionArgs{
						Destinations: networkservices.TlsRouteRuleActionDestinationArray{
							&networkservices.TlsRouteRuleActionDestinationArgs{
								ServiceName: _default.ID(),
								Weight:      pulumi.Int(1),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Tls Route Mesh Basic

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultHttpHealthCheck, err := compute.NewHttpHealthCheck(ctx, "default", &compute.HttpHealthCheckArgs{
			Name:             pulumi.String("backend-service-health-check"),
			RequestPath:      pulumi.String("/"),
			CheckIntervalSec: pulumi.Int(1),
			TimeoutSec:       pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendService(ctx, "default", &compute.BackendServiceArgs{
			Name:         pulumi.String("my-backend-service"),
			HealthChecks: defaultHttpHealthCheck.ID(),
		})
		if err != nil {
			return err
		}
		defaultMesh, err := networkservices.NewMesh(ctx, "default", &networkservices.MeshArgs{
			Name: pulumi.String("my-tls-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewTlsRoute(ctx, "default", &networkservices.TlsRouteArgs{
			Name:        pulumi.String("my-tls-route"),
			Description: pulumi.String("my description"),
			Meshes: pulumi.StringArray{
				defaultMesh.ID(),
			},
			Rules: networkservices.TlsRouteRuleArray{
				&networkservices.TlsRouteRuleArgs{
					Matches: networkservices.TlsRouteRuleMatchArray{
						&networkservices.TlsRouteRuleMatchArgs{
							SniHosts: pulumi.StringArray{
								pulumi.String("example.com"),
							},
							Alpns: pulumi.StringArray{
								pulumi.String("http/1.1"),
							},
						},
					},
					Action: &networkservices.TlsRouteRuleActionArgs{
						Destinations: networkservices.TlsRouteRuleActionDestinationArray{
							&networkservices.TlsRouteRuleActionDestinationArgs{
								ServiceName: _default.ID(),
								Weight:      pulumi.Int(1),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Tls Route Gateway Basic

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultHttpHealthCheck, err := compute.NewHttpHealthCheck(ctx, "default", &compute.HttpHealthCheckArgs{
			Name:             pulumi.String("backend-service-health-check"),
			RequestPath:      pulumi.String("/"),
			CheckIntervalSec: pulumi.Int(1),
			TimeoutSec:       pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendService(ctx, "default", &compute.BackendServiceArgs{
			Name:         pulumi.String("my-backend-service"),
			HealthChecks: defaultHttpHealthCheck.ID(),
		})
		if err != nil {
			return err
		}
		defaultGateway, err := networkservices.NewGateway(ctx, "default", &networkservices.GatewayArgs{
			Name: pulumi.String("my-tls-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Scope:       pulumi.String("my-scope"),
			Type:        pulumi.String("OPEN_MESH"),
			Ports: pulumi.IntArray{
				pulumi.Int(443),
			},
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewTlsRoute(ctx, "default", &networkservices.TlsRouteArgs{
			Name:        pulumi.String("my-tls-route"),
			Description: pulumi.String("my description"),
			Gateways: pulumi.StringArray{
				defaultGateway.ID(),
			},
			Rules: networkservices.TlsRouteRuleArray{
				&networkservices.TlsRouteRuleArgs{
					Matches: networkservices.TlsRouteRuleMatchArray{
						&networkservices.TlsRouteRuleMatchArgs{
							SniHosts: pulumi.StringArray{
								pulumi.String("example.com"),
							},
							Alpns: pulumi.StringArray{
								pulumi.String("http/1.1"),
							},
						},
					},
					Action: &networkservices.TlsRouteRuleActionArgs{
						Destinations: networkservices.TlsRouteRuleActionDestinationArray{
							&networkservices.TlsRouteRuleActionDestinationArgs{
								ServiceName: _default.ID(),
								Weight:      pulumi.Int(1),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

TlsRoute can be imported using any of these accepted formats:

* `projects/{{project}}/locations/global/tlsRoutes/{{name}}`

* `{{project}}/{{name}}`

* `{{name}}`

When using the `pulumi import` command, TlsRoute can be imported using one of the formats above. For example:

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

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 

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 

func (*TlsRoute) ElementType() reflect.Type

func (*TlsRoute) ToTlsRouteOutput 

func (i *TlsRoute) ToTlsRouteOutput() TlsRouteOutput

func (*TlsRoute) ToTlsRouteOutputWithContext 

func (i *TlsRoute) ToTlsRouteOutputWithContext(ctx context.Context) TlsRouteOutput

type TlsRouteArgs 

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

func (TlsRouteArgs) ElementType() reflect.Type

type TlsRouteArray 

type TlsRouteArray []TlsRouteInput

func (TlsRouteArray) ElementType 

func (TlsRouteArray) ElementType() reflect.Type

func (TlsRouteArray) ToTlsRouteArrayOutput 

func (i TlsRouteArray) ToTlsRouteArrayOutput() TlsRouteArrayOutput

func (TlsRouteArray) ToTlsRouteArrayOutputWithContext 

func (i TlsRouteArray) ToTlsRouteArrayOutputWithContext(ctx context.Context) TlsRouteArrayOutput

type TlsRouteArrayInput 

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 

type TlsRouteArrayOutput struct{ *pulumi.OutputState }

func (TlsRouteArrayOutput) ElementType 

func (TlsRouteArrayOutput) ElementType() reflect.Type

func (TlsRouteArrayOutput) Index 

func (o TlsRouteArrayOutput) Index(i pulumi.IntInput) TlsRouteOutput

func (TlsRouteArrayOutput) ToTlsRouteArrayOutput 

func (o TlsRouteArrayOutput) ToTlsRouteArrayOutput() TlsRouteArrayOutput

func (TlsRouteArrayOutput) ToTlsRouteArrayOutputWithContext 

func (o TlsRouteArrayOutput) ToTlsRouteArrayOutputWithContext(ctx context.Context) TlsRouteArrayOutput

type TlsRouteInput 

type TlsRouteInput interface {
	pulumi.Input

	ToTlsRouteOutput() TlsRouteOutput
	ToTlsRouteOutputWithContext(ctx context.Context) TlsRouteOutput
}

type TlsRouteMap 

type TlsRouteMap map[string]TlsRouteInput

func (TlsRouteMap) ElementType 

func (TlsRouteMap) ElementType() reflect.Type

func (TlsRouteMap) ToTlsRouteMapOutput 

func (i TlsRouteMap) ToTlsRouteMapOutput() TlsRouteMapOutput

func (TlsRouteMap) ToTlsRouteMapOutputWithContext 

func (i TlsRouteMap) ToTlsRouteMapOutputWithContext(ctx context.Context) TlsRouteMapOutput

type TlsRouteMapInput 

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 

type TlsRouteMapOutput struct{ *pulumi.OutputState }

func (TlsRouteMapOutput) ElementType 

func (TlsRouteMapOutput) ElementType() reflect.Type

func (TlsRouteMapOutput) MapIndex 

func (o TlsRouteMapOutput) MapIndex(k pulumi.StringInput) TlsRouteOutput

func (TlsRouteMapOutput) ToTlsRouteMapOutput 

func (o TlsRouteMapOutput) ToTlsRouteMapOutput() TlsRouteMapOutput

func (TlsRouteMapOutput) ToTlsRouteMapOutputWithContext 

func (o TlsRouteMapOutput) ToTlsRouteMapOutputWithContext(ctx context.Context) TlsRouteMapOutput

type TlsRouteOutput 

type TlsRouteOutput struct{ *pulumi.OutputState }

func (TlsRouteOutput) CreateTime 

func (o TlsRouteOutput) CreateTime() pulumi.StringOutput

Time the TlsRoute was created in UTC.

func (TlsRouteOutput) Description 

func (o TlsRouteOutput) Description() pulumi.StringPtrOutput

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

func (TlsRouteOutput) ElementType 

func (TlsRouteOutput) ElementType() reflect.Type

func (TlsRouteOutput) Gateways 

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 

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 

func (o TlsRouteOutput) Name() pulumi.StringOutput

Name of the TlsRoute resource.

func (TlsRouteOutput) Project 

func (o TlsRouteOutput) Project() pulumi.StringOutput

func (TlsRouteOutput) Rules 

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 

func (o TlsRouteOutput) ToTlsRouteOutput() TlsRouteOutput

func (TlsRouteOutput) ToTlsRouteOutputWithContext 

func (o TlsRouteOutput) ToTlsRouteOutputWithContext(ctx context.Context) TlsRouteOutput

func (TlsRouteOutput) UpdateTime 

func (o TlsRouteOutput) UpdateTime() pulumi.StringOutput

Time the TlsRoute was updated in UTC.

type TlsRouteRule 

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 

type TlsRouteRuleAction struct {
	// The destination to which traffic should be forwarded.
	// Structure is documented below.
	Destinations []TlsRouteRuleActionDestination `pulumi:"destinations"`
}

type TlsRouteRuleActionArgs 

type TlsRouteRuleActionArgs struct {
	// The destination to which traffic should be forwarded.
	// Structure is documented below.
	Destinations TlsRouteRuleActionDestinationArrayInput `pulumi:"destinations"`
}

func (TlsRouteRuleActionArgs) ElementType 

func (TlsRouteRuleActionArgs) ElementType() reflect.Type

func (TlsRouteRuleActionArgs) ToTlsRouteRuleActionOutput 

func (i TlsRouteRuleActionArgs) ToTlsRouteRuleActionOutput() TlsRouteRuleActionOutput

func (TlsRouteRuleActionArgs) ToTlsRouteRuleActionOutputWithContext 

func (i TlsRouteRuleActionArgs) ToTlsRouteRuleActionOutputWithContext(ctx context.Context) TlsRouteRuleActionOutput

type TlsRouteRuleActionDestination 

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 

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 

func (TlsRouteRuleActionDestinationArgs) ElementType() reflect.Type

func (TlsRouteRuleActionDestinationArgs) ToTlsRouteRuleActionDestinationOutput 

func (i TlsRouteRuleActionDestinationArgs) ToTlsRouteRuleActionDestinationOutput() TlsRouteRuleActionDestinationOutput

func (TlsRouteRuleActionDestinationArgs) ToTlsRouteRuleActionDestinationOutputWithContext 

func (i TlsRouteRuleActionDestinationArgs) ToTlsRouteRuleActionDestinationOutputWithContext(ctx context.Context) TlsRouteRuleActionDestinationOutput

type TlsRouteRuleActionDestinationArray 

type TlsRouteRuleActionDestinationArray []TlsRouteRuleActionDestinationInput

func (TlsRouteRuleActionDestinationArray) ElementType 

func (TlsRouteRuleActionDestinationArray) ElementType() reflect.Type

func (TlsRouteRuleActionDestinationArray) ToTlsRouteRuleActionDestinationArrayOutput 

func (i TlsRouteRuleActionDestinationArray) ToTlsRouteRuleActionDestinationArrayOutput() TlsRouteRuleActionDestinationArrayOutput

func (TlsRouteRuleActionDestinationArray) ToTlsRouteRuleActionDestinationArrayOutputWithContext 

func (i TlsRouteRuleActionDestinationArray) ToTlsRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) TlsRouteRuleActionDestinationArrayOutput

type TlsRouteRuleActionDestinationArrayInput 

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 

type TlsRouteRuleActionDestinationArrayOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleActionDestinationArrayOutput) ElementType 

func (TlsRouteRuleActionDestinationArrayOutput) ElementType() reflect.Type

func (TlsRouteRuleActionDestinationArrayOutput) Index 

func (o TlsRouteRuleActionDestinationArrayOutput) Index(i pulumi.IntInput) TlsRouteRuleActionDestinationOutput

func (TlsRouteRuleActionDestinationArrayOutput) ToTlsRouteRuleActionDestinationArrayOutput 

func (o TlsRouteRuleActionDestinationArrayOutput) ToTlsRouteRuleActionDestinationArrayOutput() TlsRouteRuleActionDestinationArrayOutput

func (TlsRouteRuleActionDestinationArrayOutput) ToTlsRouteRuleActionDestinationArrayOutputWithContext 

func (o TlsRouteRuleActionDestinationArrayOutput) ToTlsRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) TlsRouteRuleActionDestinationArrayOutput

type TlsRouteRuleActionDestinationInput 

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 

type TlsRouteRuleActionDestinationOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleActionDestinationOutput) ElementType 

func (TlsRouteRuleActionDestinationOutput) ElementType() reflect.Type

func (TlsRouteRuleActionDestinationOutput) ServiceName 

func (o TlsRouteRuleActionDestinationOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (TlsRouteRuleActionDestinationOutput) ToTlsRouteRuleActionDestinationOutput 

func (o TlsRouteRuleActionDestinationOutput) ToTlsRouteRuleActionDestinationOutput() TlsRouteRuleActionDestinationOutput

func (TlsRouteRuleActionDestinationOutput) ToTlsRouteRuleActionDestinationOutputWithContext 

func (o TlsRouteRuleActionDestinationOutput) ToTlsRouteRuleActionDestinationOutputWithContext(ctx context.Context) TlsRouteRuleActionDestinationOutput

func (TlsRouteRuleActionDestinationOutput) Weight 

func (o TlsRouteRuleActionDestinationOutput) Weight() pulumi.IntPtrOutput

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

***

type TlsRouteRuleActionInput 

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 

type TlsRouteRuleActionOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleActionOutput) Destinations 

func (o TlsRouteRuleActionOutput) Destinations() TlsRouteRuleActionDestinationArrayOutput

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

func (TlsRouteRuleActionOutput) ElementType 

func (TlsRouteRuleActionOutput) ElementType() reflect.Type

func (TlsRouteRuleActionOutput) ToTlsRouteRuleActionOutput 

func (o TlsRouteRuleActionOutput) ToTlsRouteRuleActionOutput() TlsRouteRuleActionOutput

func (TlsRouteRuleActionOutput) ToTlsRouteRuleActionOutputWithContext 

func (o TlsRouteRuleActionOutput) ToTlsRouteRuleActionOutputWithContext(ctx context.Context) TlsRouteRuleActionOutput

type TlsRouteRuleArgs 

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 

func (TlsRouteRuleArgs) ElementType() reflect.Type

func (TlsRouteRuleArgs) ToTlsRouteRuleOutput 

func (i TlsRouteRuleArgs) ToTlsRouteRuleOutput() TlsRouteRuleOutput

func (TlsRouteRuleArgs) ToTlsRouteRuleOutputWithContext 

func (i TlsRouteRuleArgs) ToTlsRouteRuleOutputWithContext(ctx context.Context) TlsRouteRuleOutput

type TlsRouteRuleArray 

type TlsRouteRuleArray []TlsRouteRuleInput

func (TlsRouteRuleArray) ElementType 

func (TlsRouteRuleArray) ElementType() reflect.Type

func (TlsRouteRuleArray) ToTlsRouteRuleArrayOutput 

func (i TlsRouteRuleArray) ToTlsRouteRuleArrayOutput() TlsRouteRuleArrayOutput

func (TlsRouteRuleArray) ToTlsRouteRuleArrayOutputWithContext 

func (i TlsRouteRuleArray) ToTlsRouteRuleArrayOutputWithContext(ctx context.Context) TlsRouteRuleArrayOutput

type TlsRouteRuleArrayInput 

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 

type TlsRouteRuleArrayOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleArrayOutput) ElementType 

func (TlsRouteRuleArrayOutput) ElementType() reflect.Type

func (TlsRouteRuleArrayOutput) Index 

func (o TlsRouteRuleArrayOutput) Index(i pulumi.IntInput) TlsRouteRuleOutput

func (TlsRouteRuleArrayOutput) ToTlsRouteRuleArrayOutput 

func (o TlsRouteRuleArrayOutput) ToTlsRouteRuleArrayOutput() TlsRouteRuleArrayOutput

func (TlsRouteRuleArrayOutput) ToTlsRouteRuleArrayOutputWithContext 

func (o TlsRouteRuleArrayOutput) ToTlsRouteRuleArrayOutputWithContext(ctx context.Context) TlsRouteRuleArrayOutput

type TlsRouteRuleInput 

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 

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 

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 

func (TlsRouteRuleMatchArgs) ElementType() reflect.Type

func (TlsRouteRuleMatchArgs) ToTlsRouteRuleMatchOutput 

func (i TlsRouteRuleMatchArgs) ToTlsRouteRuleMatchOutput() TlsRouteRuleMatchOutput

func (TlsRouteRuleMatchArgs) ToTlsRouteRuleMatchOutputWithContext 

func (i TlsRouteRuleMatchArgs) ToTlsRouteRuleMatchOutputWithContext(ctx context.Context) TlsRouteRuleMatchOutput

type TlsRouteRuleMatchArray 

type TlsRouteRuleMatchArray []TlsRouteRuleMatchInput

func (TlsRouteRuleMatchArray) ElementType 

func (TlsRouteRuleMatchArray) ElementType() reflect.Type

func (TlsRouteRuleMatchArray) ToTlsRouteRuleMatchArrayOutput 

func (i TlsRouteRuleMatchArray) ToTlsRouteRuleMatchArrayOutput() TlsRouteRuleMatchArrayOutput

func (TlsRouteRuleMatchArray) ToTlsRouteRuleMatchArrayOutputWithContext 

func (i TlsRouteRuleMatchArray) ToTlsRouteRuleMatchArrayOutputWithContext(ctx context.Context) TlsRouteRuleMatchArrayOutput

type TlsRouteRuleMatchArrayInput 

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 

type TlsRouteRuleMatchArrayOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleMatchArrayOutput) ElementType 

func (TlsRouteRuleMatchArrayOutput) ElementType() reflect.Type

func (TlsRouteRuleMatchArrayOutput) Index 

func (o TlsRouteRuleMatchArrayOutput) Index(i pulumi.IntInput) TlsRouteRuleMatchOutput

func (TlsRouteRuleMatchArrayOutput) ToTlsRouteRuleMatchArrayOutput 

func (o TlsRouteRuleMatchArrayOutput) ToTlsRouteRuleMatchArrayOutput() TlsRouteRuleMatchArrayOutput

func (TlsRouteRuleMatchArrayOutput) ToTlsRouteRuleMatchArrayOutputWithContext 

func (o TlsRouteRuleMatchArrayOutput) ToTlsRouteRuleMatchArrayOutputWithContext(ctx context.Context) TlsRouteRuleMatchArrayOutput

type TlsRouteRuleMatchInput 

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 

type TlsRouteRuleMatchOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleMatchOutput) Alpns 

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 

func (TlsRouteRuleMatchOutput) ElementType() reflect.Type

func (TlsRouteRuleMatchOutput) SniHosts 

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 

func (o TlsRouteRuleMatchOutput) ToTlsRouteRuleMatchOutput() TlsRouteRuleMatchOutput

func (TlsRouteRuleMatchOutput) ToTlsRouteRuleMatchOutputWithContext 

func (o TlsRouteRuleMatchOutput) ToTlsRouteRuleMatchOutputWithContext(ctx context.Context) TlsRouteRuleMatchOutput

type TlsRouteRuleOutput 

type TlsRouteRuleOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleOutput) Action 

func (o TlsRouteRuleOutput) Action() TlsRouteRuleActionOutput

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

func (TlsRouteRuleOutput) ElementType 

func (TlsRouteRuleOutput) ElementType() reflect.Type

func (TlsRouteRuleOutput) Matches 

func (o TlsRouteRuleOutput) Matches() TlsRouteRuleMatchArrayOutput

Matches define the predicate used to match requests to a given action. Structure is documented below.

func (TlsRouteRuleOutput) ToTlsRouteRuleOutput 

func (o TlsRouteRuleOutput) ToTlsRouteRuleOutput() TlsRouteRuleOutput

func (TlsRouteRuleOutput) ToTlsRouteRuleOutputWithContext 

func (o TlsRouteRuleOutput) ToTlsRouteRuleOutputWithContext(ctx context.Context) TlsRouteRuleOutput

type TlsRouteState 

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

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.