dns

package
v4.21.0 Latest Latest
Warning

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

 Go to latest Published: Apr 13, 2021 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 GetKeysArgs 

type GetKeysArgs struct {
	// The name or id of the Cloud DNS managed zone.
	ManagedZone string `pulumi:"managedZone"`
	// The ID of the project in which the resource belongs. If `project` is not provided, the provider project is used.
	Project *string `pulumi:"project"`
}

A collection of arguments for invoking getKeys.

type GetKeysKeySigningKey 

type GetKeysKeySigningKey struct {
	// String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
	Algorithm string `pulumi:"algorithm"`
	// The time that this resource was created in the control plane. This is in RFC3339 text format.
	CreationTime string `pulumi:"creationTime"`
	// A mutable string of at most 1024 characters associated with this resource for the user's convenience.
	Description string `pulumi:"description"`
	// A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:
	Digests []GetKeysKeySigningKeyDigest `pulumi:"digests"`
	// The DS record based on the KSK record. This is used when [delegating](https://cloud.google.com/dns/docs/dnssec-advanced#subdelegation) DNSSEC-signed subdomains.
	DsRecord string `pulumi:"dsRecord"`
	// Unique identifier for the resource; defined by the server.
	Id string `pulumi:"id"`
	// Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
	IsActive bool `pulumi:"isActive"`
	// Length of the key in bits. Specified at creation time then immutable.
	KeyLength int `pulumi:"keyLength"`
	// The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.
	KeyTag int `pulumi:"keyTag"`
	// Base64 encoded public half of this key.
	PublicKey string `pulumi:"publicKey"`
}

type GetKeysKeySigningKeyArgs 

type GetKeysKeySigningKeyArgs struct {
	// String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
	Algorithm pulumi.StringInput `pulumi:"algorithm"`
	// The time that this resource was created in the control plane. This is in RFC3339 text format.
	CreationTime pulumi.StringInput `pulumi:"creationTime"`
	// A mutable string of at most 1024 characters associated with this resource for the user's convenience.
	Description pulumi.StringInput `pulumi:"description"`
	// A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:
	Digests GetKeysKeySigningKeyDigestArrayInput `pulumi:"digests"`
	// The DS record based on the KSK record. This is used when [delegating](https://cloud.google.com/dns/docs/dnssec-advanced#subdelegation) DNSSEC-signed subdomains.
	DsRecord pulumi.StringInput `pulumi:"dsRecord"`
	// Unique identifier for the resource; defined by the server.
	Id pulumi.StringInput `pulumi:"id"`
	// Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
	IsActive pulumi.BoolInput `pulumi:"isActive"`
	// Length of the key in bits. Specified at creation time then immutable.
	KeyLength pulumi.IntInput `pulumi:"keyLength"`
	// The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.
	KeyTag pulumi.IntInput `pulumi:"keyTag"`
	// Base64 encoded public half of this key.
	PublicKey pulumi.StringInput `pulumi:"publicKey"`
}

func (GetKeysKeySigningKeyArgs) ElementType 

func (GetKeysKeySigningKeyArgs) ElementType() reflect.Type

func (GetKeysKeySigningKeyArgs) ToGetKeysKeySigningKeyOutput 

func (i GetKeysKeySigningKeyArgs) ToGetKeysKeySigningKeyOutput() GetKeysKeySigningKeyOutput

func (GetKeysKeySigningKeyArgs) ToGetKeysKeySigningKeyOutputWithContext 

func (i GetKeysKeySigningKeyArgs) ToGetKeysKeySigningKeyOutputWithContext(ctx context.Context) GetKeysKeySigningKeyOutput

type GetKeysKeySigningKeyArray 

type GetKeysKeySigningKeyArray []GetKeysKeySigningKeyInput

func (GetKeysKeySigningKeyArray) ElementType 

func (GetKeysKeySigningKeyArray) ElementType() reflect.Type

func (GetKeysKeySigningKeyArray) ToGetKeysKeySigningKeyArrayOutput 

func (i GetKeysKeySigningKeyArray) ToGetKeysKeySigningKeyArrayOutput() GetKeysKeySigningKeyArrayOutput

func (GetKeysKeySigningKeyArray) ToGetKeysKeySigningKeyArrayOutputWithContext 

func (i GetKeysKeySigningKeyArray) ToGetKeysKeySigningKeyArrayOutputWithContext(ctx context.Context) GetKeysKeySigningKeyArrayOutput

type GetKeysKeySigningKeyArrayInput 

type GetKeysKeySigningKeyArrayInput interface {
	pulumi.Input

	ToGetKeysKeySigningKeyArrayOutput() GetKeysKeySigningKeyArrayOutput
	ToGetKeysKeySigningKeyArrayOutputWithContext(context.Context) GetKeysKeySigningKeyArrayOutput
}

GetKeysKeySigningKeyArrayInput is an input type that accepts GetKeysKeySigningKeyArray and GetKeysKeySigningKeyArrayOutput values. You can construct a concrete instance of `GetKeysKeySigningKeyArrayInput` via: 

GetKeysKeySigningKeyArray{ GetKeysKeySigningKeyArgs{...} }

type GetKeysKeySigningKeyArrayOutput 

type GetKeysKeySigningKeyArrayOutput struct{ *pulumi.OutputState }

func (GetKeysKeySigningKeyArrayOutput) ElementType 

func (GetKeysKeySigningKeyArrayOutput) ElementType() reflect.Type

func (GetKeysKeySigningKeyArrayOutput) Index 

func (o GetKeysKeySigningKeyArrayOutput) Index(i pulumi.IntInput) GetKeysKeySigningKeyOutput

func (GetKeysKeySigningKeyArrayOutput) ToGetKeysKeySigningKeyArrayOutput 

func (o GetKeysKeySigningKeyArrayOutput) ToGetKeysKeySigningKeyArrayOutput() GetKeysKeySigningKeyArrayOutput

func (GetKeysKeySigningKeyArrayOutput) ToGetKeysKeySigningKeyArrayOutputWithContext 

func (o GetKeysKeySigningKeyArrayOutput) ToGetKeysKeySigningKeyArrayOutputWithContext(ctx context.Context) GetKeysKeySigningKeyArrayOutput

type GetKeysKeySigningKeyDigest 

type GetKeysKeySigningKeyDigest struct {
	// The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
	Digest *string `pulumi:"digest"`
	// Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`
	Type *string `pulumi:"type"`
}

type GetKeysKeySigningKeyDigestArgs 

type GetKeysKeySigningKeyDigestArgs struct {
	// The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
	Digest pulumi.StringPtrInput `pulumi:"digest"`
	// Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (GetKeysKeySigningKeyDigestArgs) ElementType 

func (GetKeysKeySigningKeyDigestArgs) ElementType() reflect.Type

func (GetKeysKeySigningKeyDigestArgs) ToGetKeysKeySigningKeyDigestOutput 

func (i GetKeysKeySigningKeyDigestArgs) ToGetKeysKeySigningKeyDigestOutput() GetKeysKeySigningKeyDigestOutput

func (GetKeysKeySigningKeyDigestArgs) ToGetKeysKeySigningKeyDigestOutputWithContext 

func (i GetKeysKeySigningKeyDigestArgs) ToGetKeysKeySigningKeyDigestOutputWithContext(ctx context.Context) GetKeysKeySigningKeyDigestOutput

type GetKeysKeySigningKeyDigestArray 

type GetKeysKeySigningKeyDigestArray []GetKeysKeySigningKeyDigestInput

func (GetKeysKeySigningKeyDigestArray) ElementType 

func (GetKeysKeySigningKeyDigestArray) ElementType() reflect.Type

func (GetKeysKeySigningKeyDigestArray) ToGetKeysKeySigningKeyDigestArrayOutput 

func (i GetKeysKeySigningKeyDigestArray) ToGetKeysKeySigningKeyDigestArrayOutput() GetKeysKeySigningKeyDigestArrayOutput

func (GetKeysKeySigningKeyDigestArray) ToGetKeysKeySigningKeyDigestArrayOutputWithContext 

func (i GetKeysKeySigningKeyDigestArray) ToGetKeysKeySigningKeyDigestArrayOutputWithContext(ctx context.Context) GetKeysKeySigningKeyDigestArrayOutput

type GetKeysKeySigningKeyDigestArrayInput 

type GetKeysKeySigningKeyDigestArrayInput interface {
	pulumi.Input

	ToGetKeysKeySigningKeyDigestArrayOutput() GetKeysKeySigningKeyDigestArrayOutput
	ToGetKeysKeySigningKeyDigestArrayOutputWithContext(context.Context) GetKeysKeySigningKeyDigestArrayOutput
}

GetKeysKeySigningKeyDigestArrayInput is an input type that accepts GetKeysKeySigningKeyDigestArray and GetKeysKeySigningKeyDigestArrayOutput values. You can construct a concrete instance of `GetKeysKeySigningKeyDigestArrayInput` via: 

GetKeysKeySigningKeyDigestArray{ GetKeysKeySigningKeyDigestArgs{...} }

type GetKeysKeySigningKeyDigestArrayOutput 

type GetKeysKeySigningKeyDigestArrayOutput struct{ *pulumi.OutputState }

func (GetKeysKeySigningKeyDigestArrayOutput) ElementType 

func (GetKeysKeySigningKeyDigestArrayOutput) ElementType() reflect.Type

func (GetKeysKeySigningKeyDigestArrayOutput) Index 

func (o GetKeysKeySigningKeyDigestArrayOutput) Index(i pulumi.IntInput) GetKeysKeySigningKeyDigestOutput

func (GetKeysKeySigningKeyDigestArrayOutput) ToGetKeysKeySigningKeyDigestArrayOutput 

func (o GetKeysKeySigningKeyDigestArrayOutput) ToGetKeysKeySigningKeyDigestArrayOutput() GetKeysKeySigningKeyDigestArrayOutput

func (GetKeysKeySigningKeyDigestArrayOutput) ToGetKeysKeySigningKeyDigestArrayOutputWithContext 

func (o GetKeysKeySigningKeyDigestArrayOutput) ToGetKeysKeySigningKeyDigestArrayOutputWithContext(ctx context.Context) GetKeysKeySigningKeyDigestArrayOutput

type GetKeysKeySigningKeyDigestInput 

type GetKeysKeySigningKeyDigestInput interface {
	pulumi.Input

	ToGetKeysKeySigningKeyDigestOutput() GetKeysKeySigningKeyDigestOutput
	ToGetKeysKeySigningKeyDigestOutputWithContext(context.Context) GetKeysKeySigningKeyDigestOutput
}

GetKeysKeySigningKeyDigestInput is an input type that accepts GetKeysKeySigningKeyDigestArgs and GetKeysKeySigningKeyDigestOutput values. You can construct a concrete instance of `GetKeysKeySigningKeyDigestInput` via: 

GetKeysKeySigningKeyDigestArgs{...}

type GetKeysKeySigningKeyDigestOutput 

type GetKeysKeySigningKeyDigestOutput struct{ *pulumi.OutputState }

func (GetKeysKeySigningKeyDigestOutput) Digest 

func (o GetKeysKeySigningKeyDigestOutput) Digest() pulumi.StringPtrOutput

The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.

func (GetKeysKeySigningKeyDigestOutput) ElementType 

func (GetKeysKeySigningKeyDigestOutput) ElementType() reflect.Type

func (GetKeysKeySigningKeyDigestOutput) ToGetKeysKeySigningKeyDigestOutput 

func (o GetKeysKeySigningKeyDigestOutput) ToGetKeysKeySigningKeyDigestOutput() GetKeysKeySigningKeyDigestOutput

func (GetKeysKeySigningKeyDigestOutput) ToGetKeysKeySigningKeyDigestOutputWithContext 

func (o GetKeysKeySigningKeyDigestOutput) ToGetKeysKeySigningKeyDigestOutputWithContext(ctx context.Context) GetKeysKeySigningKeyDigestOutput

func (GetKeysKeySigningKeyDigestOutput) Type 

func (o GetKeysKeySigningKeyDigestOutput) Type() pulumi.StringPtrOutput

Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`

type GetKeysKeySigningKeyInput 

type GetKeysKeySigningKeyInput interface {
	pulumi.Input

	ToGetKeysKeySigningKeyOutput() GetKeysKeySigningKeyOutput
	ToGetKeysKeySigningKeyOutputWithContext(context.Context) GetKeysKeySigningKeyOutput
}

GetKeysKeySigningKeyInput is an input type that accepts GetKeysKeySigningKeyArgs and GetKeysKeySigningKeyOutput values. You can construct a concrete instance of `GetKeysKeySigningKeyInput` via: 

GetKeysKeySigningKeyArgs{...}

type GetKeysKeySigningKeyOutput 

type GetKeysKeySigningKeyOutput struct{ *pulumi.OutputState }

func (GetKeysKeySigningKeyOutput) Algorithm 

func (o GetKeysKeySigningKeyOutput) Algorithm() pulumi.StringOutput

String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.

func (GetKeysKeySigningKeyOutput) CreationTime 

func (o GetKeysKeySigningKeyOutput) CreationTime() pulumi.StringOutput

The time that this resource was created in the control plane. This is in RFC3339 text format.

func (GetKeysKeySigningKeyOutput) Description 

func (o GetKeysKeySigningKeyOutput) Description() pulumi.StringOutput

A mutable string of at most 1024 characters associated with this resource for the user's convenience.

func (GetKeysKeySigningKeyOutput) Digests 

func (o GetKeysKeySigningKeyOutput) Digests() GetKeysKeySigningKeyDigestArrayOutput

A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:

func (GetKeysKeySigningKeyOutput) DsRecord 

func (o GetKeysKeySigningKeyOutput) DsRecord() pulumi.StringOutput

The DS record based on the KSK record. This is used when [delegating](https://cloud.google.com/dns/docs/dnssec-advanced#subdelegation) DNSSEC-signed subdomains.

func (GetKeysKeySigningKeyOutput) ElementType 

func (GetKeysKeySigningKeyOutput) ElementType() reflect.Type

func (GetKeysKeySigningKeyOutput) Id 

func (o GetKeysKeySigningKeyOutput) Id() pulumi.StringOutput

Unique identifier for the resource; defined by the server.

func (GetKeysKeySigningKeyOutput) IsActive 

func (o GetKeysKeySigningKeyOutput) IsActive() pulumi.BoolOutput

Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.

func (GetKeysKeySigningKeyOutput) KeyLength 

func (o GetKeysKeySigningKeyOutput) KeyLength() pulumi.IntOutput

Length of the key in bits. Specified at creation time then immutable.

func (GetKeysKeySigningKeyOutput) KeyTag 

func (o GetKeysKeySigningKeyOutput) KeyTag() pulumi.IntOutput

The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.

func (GetKeysKeySigningKeyOutput) PublicKey 

func (o GetKeysKeySigningKeyOutput) PublicKey() pulumi.StringOutput

Base64 encoded public half of this key.

func (GetKeysKeySigningKeyOutput) ToGetKeysKeySigningKeyOutput 

func (o GetKeysKeySigningKeyOutput) ToGetKeysKeySigningKeyOutput() GetKeysKeySigningKeyOutput

func (GetKeysKeySigningKeyOutput) ToGetKeysKeySigningKeyOutputWithContext 

func (o GetKeysKeySigningKeyOutput) ToGetKeysKeySigningKeyOutputWithContext(ctx context.Context) GetKeysKeySigningKeyOutput

type GetKeysResult 

type GetKeysResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// A list of Key-signing key (KSK) records. Structure is documented below. Additionally, the DS record is provided:
	KeySigningKeys []GetKeysKeySigningKey `pulumi:"keySigningKeys"`
	ManagedZone    string                 `pulumi:"managedZone"`
	Project        string                 `pulumi:"project"`
	// A list of Zone-signing key (ZSK) records. Structure is documented below.
	ZoneSigningKeys []GetKeysZoneSigningKey `pulumi:"zoneSigningKeys"`
}

A collection of values returned by getKeys.

func GetKeys 

func GetKeys(ctx *pulumi.Context, args *GetKeysArgs, opts ...pulumi.InvokeOption) (*GetKeysResult, error)

Get the DNSKEY and DS records of DNSSEC-signed managed zones. For more information see the [official documentation](https://cloud.google.com/dns/docs/dnskeys/) and [API](https://cloud.google.com/dns/docs/reference/v1/dnsKeys).

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foo, err := dns.NewManagedZone(ctx, "foo", &dns.ManagedZoneArgs{
			DnsName: pulumi.String("foo.bar."),
			DnssecConfig: &dns.ManagedZoneDnssecConfigArgs{
				State:        pulumi.String("on"),
				NonExistence: pulumi.String("nsec3"),
			},
		})
		if err != nil {
			return err
		}
		ctx.Export("fooDnsDsRecord", fooDnsKeys.ApplyT(func(fooDnsKeys dns.GetKeysResult) (string, error) {
			return fooDnsKeys.KeySigningKeys[0].DsRecord, nil
		}).(pulumi.StringOutput))
		return nil
	})
}

```

type GetKeysZoneSigningKey 

type GetKeysZoneSigningKey struct {
	// String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
	Algorithm string `pulumi:"algorithm"`
	// The time that this resource was created in the control plane. This is in RFC3339 text format.
	CreationTime string `pulumi:"creationTime"`
	// A mutable string of at most 1024 characters associated with this resource for the user's convenience.
	Description string `pulumi:"description"`
	// A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:
	Digests []GetKeysZoneSigningKeyDigest `pulumi:"digests"`
	// Unique identifier for the resource; defined by the server.
	Id string `pulumi:"id"`
	// Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
	IsActive bool `pulumi:"isActive"`
	// Length of the key in bits. Specified at creation time then immutable.
	KeyLength int `pulumi:"keyLength"`
	// The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.
	KeyTag int `pulumi:"keyTag"`
	// Base64 encoded public half of this key.
	PublicKey string `pulumi:"publicKey"`
}

type GetKeysZoneSigningKeyArgs 

type GetKeysZoneSigningKeyArgs struct {
	// String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
	Algorithm pulumi.StringInput `pulumi:"algorithm"`
	// The time that this resource was created in the control plane. This is in RFC3339 text format.
	CreationTime pulumi.StringInput `pulumi:"creationTime"`
	// A mutable string of at most 1024 characters associated with this resource for the user's convenience.
	Description pulumi.StringInput `pulumi:"description"`
	// A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:
	Digests GetKeysZoneSigningKeyDigestArrayInput `pulumi:"digests"`
	// Unique identifier for the resource; defined by the server.
	Id pulumi.StringInput `pulumi:"id"`
	// Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
	IsActive pulumi.BoolInput `pulumi:"isActive"`
	// Length of the key in bits. Specified at creation time then immutable.
	KeyLength pulumi.IntInput `pulumi:"keyLength"`
	// The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.
	KeyTag pulumi.IntInput `pulumi:"keyTag"`
	// Base64 encoded public half of this key.
	PublicKey pulumi.StringInput `pulumi:"publicKey"`
}

func (GetKeysZoneSigningKeyArgs) ElementType 

func (GetKeysZoneSigningKeyArgs) ElementType() reflect.Type

func (GetKeysZoneSigningKeyArgs) ToGetKeysZoneSigningKeyOutput 

func (i GetKeysZoneSigningKeyArgs) ToGetKeysZoneSigningKeyOutput() GetKeysZoneSigningKeyOutput

func (GetKeysZoneSigningKeyArgs) ToGetKeysZoneSigningKeyOutputWithContext 

func (i GetKeysZoneSigningKeyArgs) ToGetKeysZoneSigningKeyOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyOutput

type GetKeysZoneSigningKeyArray 

type GetKeysZoneSigningKeyArray []GetKeysZoneSigningKeyInput

func (GetKeysZoneSigningKeyArray) ElementType 

func (GetKeysZoneSigningKeyArray) ElementType() reflect.Type

func (GetKeysZoneSigningKeyArray) ToGetKeysZoneSigningKeyArrayOutput 

func (i GetKeysZoneSigningKeyArray) ToGetKeysZoneSigningKeyArrayOutput() GetKeysZoneSigningKeyArrayOutput

func (GetKeysZoneSigningKeyArray) ToGetKeysZoneSigningKeyArrayOutputWithContext 

func (i GetKeysZoneSigningKeyArray) ToGetKeysZoneSigningKeyArrayOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyArrayOutput

type GetKeysZoneSigningKeyArrayInput 

type GetKeysZoneSigningKeyArrayInput interface {
	pulumi.Input

	ToGetKeysZoneSigningKeyArrayOutput() GetKeysZoneSigningKeyArrayOutput
	ToGetKeysZoneSigningKeyArrayOutputWithContext(context.Context) GetKeysZoneSigningKeyArrayOutput
}

GetKeysZoneSigningKeyArrayInput is an input type that accepts GetKeysZoneSigningKeyArray and GetKeysZoneSigningKeyArrayOutput values. You can construct a concrete instance of `GetKeysZoneSigningKeyArrayInput` via: 

GetKeysZoneSigningKeyArray{ GetKeysZoneSigningKeyArgs{...} }

type GetKeysZoneSigningKeyArrayOutput 

type GetKeysZoneSigningKeyArrayOutput struct{ *pulumi.OutputState }

func (GetKeysZoneSigningKeyArrayOutput) ElementType 

func (GetKeysZoneSigningKeyArrayOutput) ElementType() reflect.Type

func (GetKeysZoneSigningKeyArrayOutput) Index 

func (o GetKeysZoneSigningKeyArrayOutput) Index(i pulumi.IntInput) GetKeysZoneSigningKeyOutput

func (GetKeysZoneSigningKeyArrayOutput) ToGetKeysZoneSigningKeyArrayOutput 

func (o GetKeysZoneSigningKeyArrayOutput) ToGetKeysZoneSigningKeyArrayOutput() GetKeysZoneSigningKeyArrayOutput

func (GetKeysZoneSigningKeyArrayOutput) ToGetKeysZoneSigningKeyArrayOutputWithContext 

func (o GetKeysZoneSigningKeyArrayOutput) ToGetKeysZoneSigningKeyArrayOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyArrayOutput

type GetKeysZoneSigningKeyDigest 

type GetKeysZoneSigningKeyDigest struct {
	// The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
	Digest *string `pulumi:"digest"`
	// Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`
	Type *string `pulumi:"type"`
}

type GetKeysZoneSigningKeyDigestArgs 

type GetKeysZoneSigningKeyDigestArgs struct {
	// The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
	Digest pulumi.StringPtrInput `pulumi:"digest"`
	// Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (GetKeysZoneSigningKeyDigestArgs) ElementType 

func (GetKeysZoneSigningKeyDigestArgs) ElementType() reflect.Type

func (GetKeysZoneSigningKeyDigestArgs) ToGetKeysZoneSigningKeyDigestOutput 

func (i GetKeysZoneSigningKeyDigestArgs) ToGetKeysZoneSigningKeyDigestOutput() GetKeysZoneSigningKeyDigestOutput

func (GetKeysZoneSigningKeyDigestArgs) ToGetKeysZoneSigningKeyDigestOutputWithContext 

func (i GetKeysZoneSigningKeyDigestArgs) ToGetKeysZoneSigningKeyDigestOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyDigestOutput

type GetKeysZoneSigningKeyDigestArray 

type GetKeysZoneSigningKeyDigestArray []GetKeysZoneSigningKeyDigestInput

func (GetKeysZoneSigningKeyDigestArray) ElementType 

func (GetKeysZoneSigningKeyDigestArray) ElementType() reflect.Type

func (GetKeysZoneSigningKeyDigestArray) ToGetKeysZoneSigningKeyDigestArrayOutput 

func (i GetKeysZoneSigningKeyDigestArray) ToGetKeysZoneSigningKeyDigestArrayOutput() GetKeysZoneSigningKeyDigestArrayOutput

func (GetKeysZoneSigningKeyDigestArray) ToGetKeysZoneSigningKeyDigestArrayOutputWithContext 

func (i GetKeysZoneSigningKeyDigestArray) ToGetKeysZoneSigningKeyDigestArrayOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyDigestArrayOutput

type GetKeysZoneSigningKeyDigestArrayInput 

type GetKeysZoneSigningKeyDigestArrayInput interface {
	pulumi.Input

	ToGetKeysZoneSigningKeyDigestArrayOutput() GetKeysZoneSigningKeyDigestArrayOutput
	ToGetKeysZoneSigningKeyDigestArrayOutputWithContext(context.Context) GetKeysZoneSigningKeyDigestArrayOutput
}

GetKeysZoneSigningKeyDigestArrayInput is an input type that accepts GetKeysZoneSigningKeyDigestArray and GetKeysZoneSigningKeyDigestArrayOutput values. You can construct a concrete instance of `GetKeysZoneSigningKeyDigestArrayInput` via: 

GetKeysZoneSigningKeyDigestArray{ GetKeysZoneSigningKeyDigestArgs{...} }

type GetKeysZoneSigningKeyDigestArrayOutput 

type GetKeysZoneSigningKeyDigestArrayOutput struct{ *pulumi.OutputState }

func (GetKeysZoneSigningKeyDigestArrayOutput) ElementType 

func (GetKeysZoneSigningKeyDigestArrayOutput) ElementType() reflect.Type

func (GetKeysZoneSigningKeyDigestArrayOutput) Index 

func (o GetKeysZoneSigningKeyDigestArrayOutput) Index(i pulumi.IntInput) GetKeysZoneSigningKeyDigestOutput

func (GetKeysZoneSigningKeyDigestArrayOutput) ToGetKeysZoneSigningKeyDigestArrayOutput 

func (o GetKeysZoneSigningKeyDigestArrayOutput) ToGetKeysZoneSigningKeyDigestArrayOutput() GetKeysZoneSigningKeyDigestArrayOutput

func (GetKeysZoneSigningKeyDigestArrayOutput) ToGetKeysZoneSigningKeyDigestArrayOutputWithContext 

func (o GetKeysZoneSigningKeyDigestArrayOutput) ToGetKeysZoneSigningKeyDigestArrayOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyDigestArrayOutput

type GetKeysZoneSigningKeyDigestInput 

type GetKeysZoneSigningKeyDigestInput interface {
	pulumi.Input

	ToGetKeysZoneSigningKeyDigestOutput() GetKeysZoneSigningKeyDigestOutput
	ToGetKeysZoneSigningKeyDigestOutputWithContext(context.Context) GetKeysZoneSigningKeyDigestOutput
}

GetKeysZoneSigningKeyDigestInput is an input type that accepts GetKeysZoneSigningKeyDigestArgs and GetKeysZoneSigningKeyDigestOutput values. You can construct a concrete instance of `GetKeysZoneSigningKeyDigestInput` via: 

GetKeysZoneSigningKeyDigestArgs{...}

type GetKeysZoneSigningKeyDigestOutput 

type GetKeysZoneSigningKeyDigestOutput struct{ *pulumi.OutputState }

func (GetKeysZoneSigningKeyDigestOutput) Digest 

func (o GetKeysZoneSigningKeyDigestOutput) Digest() pulumi.StringPtrOutput

The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.

func (GetKeysZoneSigningKeyDigestOutput) ElementType 

func (GetKeysZoneSigningKeyDigestOutput) ElementType() reflect.Type

func (GetKeysZoneSigningKeyDigestOutput) ToGetKeysZoneSigningKeyDigestOutput 

func (o GetKeysZoneSigningKeyDigestOutput) ToGetKeysZoneSigningKeyDigestOutput() GetKeysZoneSigningKeyDigestOutput

func (GetKeysZoneSigningKeyDigestOutput) ToGetKeysZoneSigningKeyDigestOutputWithContext 

func (o GetKeysZoneSigningKeyDigestOutput) ToGetKeysZoneSigningKeyDigestOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyDigestOutput

func (GetKeysZoneSigningKeyDigestOutput) Type 

func (o GetKeysZoneSigningKeyDigestOutput) Type() pulumi.StringPtrOutput

Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`

type GetKeysZoneSigningKeyInput 

type GetKeysZoneSigningKeyInput interface {
	pulumi.Input

	ToGetKeysZoneSigningKeyOutput() GetKeysZoneSigningKeyOutput
	ToGetKeysZoneSigningKeyOutputWithContext(context.Context) GetKeysZoneSigningKeyOutput
}

GetKeysZoneSigningKeyInput is an input type that accepts GetKeysZoneSigningKeyArgs and GetKeysZoneSigningKeyOutput values. You can construct a concrete instance of `GetKeysZoneSigningKeyInput` via: 

GetKeysZoneSigningKeyArgs{...}

type GetKeysZoneSigningKeyOutput 

type GetKeysZoneSigningKeyOutput struct{ *pulumi.OutputState }

func (GetKeysZoneSigningKeyOutput) Algorithm 

func (o GetKeysZoneSigningKeyOutput) Algorithm() pulumi.StringOutput

String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.

func (GetKeysZoneSigningKeyOutput) CreationTime 

func (o GetKeysZoneSigningKeyOutput) CreationTime() pulumi.StringOutput

The time that this resource was created in the control plane. This is in RFC3339 text format.

func (GetKeysZoneSigningKeyOutput) Description 

func (o GetKeysZoneSigningKeyOutput) Description() pulumi.StringOutput

A mutable string of at most 1024 characters associated with this resource for the user's convenience.

func (GetKeysZoneSigningKeyOutput) Digests 

func (o GetKeysZoneSigningKeyOutput) Digests() GetKeysZoneSigningKeyDigestArrayOutput

A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:

func (GetKeysZoneSigningKeyOutput) ElementType 

func (GetKeysZoneSigningKeyOutput) ElementType() reflect.Type

func (GetKeysZoneSigningKeyOutput) Id 

func (o GetKeysZoneSigningKeyOutput) Id() pulumi.StringOutput

Unique identifier for the resource; defined by the server.

func (GetKeysZoneSigningKeyOutput) IsActive 

func (o GetKeysZoneSigningKeyOutput) IsActive() pulumi.BoolOutput

Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.

func (GetKeysZoneSigningKeyOutput) KeyLength 

func (o GetKeysZoneSigningKeyOutput) KeyLength() pulumi.IntOutput

Length of the key in bits. Specified at creation time then immutable.

func (GetKeysZoneSigningKeyOutput) KeyTag 

func (o GetKeysZoneSigningKeyOutput) KeyTag() pulumi.IntOutput

The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.

func (GetKeysZoneSigningKeyOutput) PublicKey 

func (o GetKeysZoneSigningKeyOutput) PublicKey() pulumi.StringOutput

Base64 encoded public half of this key.

func (GetKeysZoneSigningKeyOutput) ToGetKeysZoneSigningKeyOutput 

func (o GetKeysZoneSigningKeyOutput) ToGetKeysZoneSigningKeyOutput() GetKeysZoneSigningKeyOutput

func (GetKeysZoneSigningKeyOutput) ToGetKeysZoneSigningKeyOutputWithContext 

func (o GetKeysZoneSigningKeyOutput) ToGetKeysZoneSigningKeyOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyOutput

type LookupManagedZoneArgs 

type LookupManagedZoneArgs struct {
	// A unique name for the resource.
	Name string `pulumi:"name"`
	// The ID of the project for the Google Cloud DNS zone.
	Project *string `pulumi:"project"`
}

A collection of arguments for invoking getManagedZone.

type LookupManagedZoneResult 

type LookupManagedZoneResult struct {
	// A textual description field.
	Description string `pulumi:"description"`
	// The fully qualified DNS name of this zone, e.g. `example.io.`.
	DnsName string `pulumi:"dnsName"`
	// The provider-assigned unique ID for this managed resource.
	Id   string `pulumi:"id"`
	Name string `pulumi:"name"`
	// The list of nameservers that will be authoritative for this
	// domain. Use NS records to redirect from your DNS provider to these names,
	// thus making Google Cloud DNS authoritative for this zone.
	NameServers []string `pulumi:"nameServers"`
	Project     *string  `pulumi:"project"`
	// The zone's visibility: public zones are exposed to the Internet,
	// while private zones are visible only to Virtual Private Cloud resources.
	Visibility string `pulumi:"visibility"`
}

A collection of values returned by getManagedZone.

func LookupManagedZone 

func LookupManagedZone(ctx *pulumi.Context, args *LookupManagedZoneArgs, opts ...pulumi.InvokeOption) (*LookupManagedZoneResult, error)

Provides access to a zone's attributes within Google Cloud DNS. For more information see [the official documentation](https://cloud.google.com/dns/zones/) and [API](https://cloud.google.com/dns/api/v1/managedZones).

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		envDnsZone, err := dns.LookupManagedZone(ctx, &dns.LookupManagedZoneArgs{
			Name: "qa-zone",
		}, nil)
		if err != nil {
			return err
		}
		_, err = dns.NewRecordSet(ctx, "dns", &dns.RecordSetArgs{
			Name:        pulumi.String(fmt.Sprintf("%v%v", "my-address.", envDnsZone.DnsName)),
			Type:        pulumi.String("TXT"),
			Ttl:         pulumi.Int(300),
			ManagedZone: pulumi.String(envDnsZone.Name),
			Rrdatas: pulumi.StringArray{
				pulumi.String("test"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

type ManagedZone 

type ManagedZone struct {
	pulumi.CustomResourceState

	// A textual description field. Defaults to 'Managed by Pulumi'.
	Description pulumi.StringOutput `pulumi:"description"`
	// The DNS name of this managed zone, for instance "example.com.".
	DnsName pulumi.StringOutput `pulumi:"dnsName"`
	// DNSSEC configuration
	// Structure is documented below.
	DnssecConfig ManagedZoneDnssecConfigPtrOutput `pulumi:"dnssecConfig"`
	// Set this true to delete all records in the zone.
	ForceDestroy pulumi.BoolPtrOutput `pulumi:"forceDestroy"`
	// The presence for this field indicates that outbound forwarding is enabled
	// for this zone. The value of this field contains the set of destinations
	// to forward to.
	// Structure is documented below.
	ForwardingConfig ManagedZoneForwardingConfigPtrOutput `pulumi:"forwardingConfig"`
	// A set of key/value label pairs to assign to this ManagedZone.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// User assigned name for this resource.
	// Must be unique within the project.
	Name pulumi.StringOutput `pulumi:"name"`
	// Delegate your managed_zone to these virtual name servers; defined by the server
	NameServers pulumi.StringArrayOutput `pulumi:"nameServers"`
	// The presence of this field indicates that DNS Peering is enabled for this
	// zone. The value of this field contains the network to peer with.
	// Structure is documented below.
	PeeringConfig ManagedZonePeeringConfigPtrOutput `pulumi:"peeringConfig"`
	// For privately visible zones, the set of Virtual Private Cloud
	// resources that the zone is visible from.
	// Structure is documented below.
	PrivateVisibilityConfig ManagedZonePrivateVisibilityConfigPtrOutput `pulumi:"privateVisibilityConfig"`
	// 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"`
	// Specifies if this is a managed reverse lookup zone. If true, Cloud DNS will resolve reverse
	// lookup queries using automatically configured records for VPC resources. This only applies
	// to networks listed under `privateVisibilityConfig`.
	ReverseLookup pulumi.BoolPtrOutput `pulumi:"reverseLookup"`
	// The presence of this field indicates that this zone is backed by Service Directory. The value of this field contains information related to the namespace associated with the zone.  Structure is documented below.
	ServiceDirectoryConfig ManagedZoneServiceDirectoryConfigPtrOutput `pulumi:"serviceDirectoryConfig"`
	// The zone's visibility: public zones are exposed to the Internet,
	// while private zones are visible only to Virtual Private Cloud resources.
	// Default value is `public`.
	// Possible values are `private` and `public`.
	Visibility pulumi.StringPtrOutput `pulumi:"visibility"`
}

A zone is a subtree of the DNS namespace under one administrative responsibility. A ManagedZone is a resource that represents a DNS zone hosted by the Cloud DNS service.

To get more information about ManagedZone, see:

* [API documentation](https://cloud.google.com/dns/api/v1/managedZones) * How-to Guides

## Example Usage ### Dns Managed Zone Basic

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dns.NewManagedZone(ctx, "example_zone", &dns.ManagedZoneArgs{
			Description: pulumi.String("Example DNS zone"),
			DnsName:     pulumi.String("my-domain.com."),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Dns Managed Zone Private

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/compute"
"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "network_1", &compute.NetworkArgs{
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewNetwork(ctx, "network_2", &compute.NetworkArgs{
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_, err = dns.NewManagedZone(ctx, "private_zone", &dns.ManagedZoneArgs{
			DnsName:     pulumi.String("private.example.com."),
			Description: pulumi.String("Example private DNS zone"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Visibility: pulumi.String("private"),
			PrivateVisibilityConfig: &dns.ManagedZonePrivateVisibilityConfigArgs{
				Networks: dns.ManagedZonePrivateVisibilityConfigNetworkArray{
					&dns.ManagedZonePrivateVisibilityConfigNetworkArgs{
						NetworkUrl: network_1.ID(),
					},
					&dns.ManagedZonePrivateVisibilityConfigNetworkArgs{
						NetworkUrl: network_2.ID(),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Dns Managed Zone Private Forwarding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/compute"
"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "network_1", &compute.NetworkArgs{
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewNetwork(ctx, "network_2", &compute.NetworkArgs{
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_, err = dns.NewManagedZone(ctx, "private_zone", &dns.ManagedZoneArgs{
			DnsName:     pulumi.String("private.example.com."),
			Description: pulumi.String("Example private DNS zone"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Visibility: pulumi.String("private"),
			PrivateVisibilityConfig: &dns.ManagedZonePrivateVisibilityConfigArgs{
				Networks: dns.ManagedZonePrivateVisibilityConfigNetworkArray{
					&dns.ManagedZonePrivateVisibilityConfigNetworkArgs{
						NetworkUrl: network_1.ID(),
					},
					&dns.ManagedZonePrivateVisibilityConfigNetworkArgs{
						NetworkUrl: network_2.ID(),
					},
				},
			},
			ForwardingConfig: &dns.ManagedZoneForwardingConfigArgs{
				TargetNameServers: dns.ManagedZoneForwardingConfigTargetNameServerArray{
					&dns.ManagedZoneForwardingConfigTargetNameServerArgs{
						Ipv4Address: pulumi.String("172.16.1.10"),
					},
					&dns.ManagedZoneForwardingConfigTargetNameServerArgs{
						Ipv4Address: pulumi.String("172.16.1.20"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Dns Managed Zone Private Peering

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/compute"
"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "network_source", &compute.NetworkArgs{
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewNetwork(ctx, "network_target", &compute.NetworkArgs{
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_, err = dns.NewManagedZone(ctx, "peering_zone", &dns.ManagedZoneArgs{
			DnsName:     pulumi.String("peering.example.com."),
			Description: pulumi.String("Example private DNS peering zone"),
			Visibility:  pulumi.String("private"),
			PrivateVisibilityConfig: &dns.ManagedZonePrivateVisibilityConfigArgs{
				Networks: dns.ManagedZonePrivateVisibilityConfigNetworkArray{
					&dns.ManagedZonePrivateVisibilityConfigNetworkArgs{
						NetworkUrl: network_source.ID(),
					},
				},
			},
			PeeringConfig: &dns.ManagedZonePeeringConfigArgs{
				TargetNetwork: &dns.ManagedZonePeeringConfigTargetNetworkArgs{
					NetworkUrl: network_target.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Dns Managed Zone Service Directory

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/compute"
"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/servicedirectory"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := servicedirectory.NewNamespace(ctx, "example", &servicedirectory.NamespaceArgs{
			NamespaceId: pulumi.String("example"),
			Location:    pulumi.String("us-central1"),
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		_, err = dns.NewManagedZone(ctx, "sd_zone", &dns.ManagedZoneArgs{
			DnsName:     pulumi.String("services.example.com."),
			Description: pulumi.String("Example private DNS Service Directory zone"),
			Visibility:  pulumi.String("private"),
			ServiceDirectoryConfig: &dns.ManagedZoneServiceDirectoryConfigArgs{
				Namespace: &dns.ManagedZoneServiceDirectoryConfigNamespaceArgs{
					NamespaceUrl: example.ID(),
				},
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		_, err = compute.NewNetwork(ctx, "network", &compute.NetworkArgs{
			AutoCreateSubnetworks: pulumi.Bool(false),
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

ManagedZone can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:dns/managedZone:ManagedZone default projects/{{project}}/managedZones/{{name}}

```

```sh 

$ pulumi import gcp:dns/managedZone:ManagedZone default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:dns/managedZone:ManagedZone default {{name}}

```

func GetManagedZone 

func GetManagedZone(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ManagedZoneState, opts ...pulumi.ResourceOption) (*ManagedZone, error)

GetManagedZone gets an existing ManagedZone 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 NewManagedZone 

func NewManagedZone(ctx *pulumi.Context,
	name string, args *ManagedZoneArgs, opts ...pulumi.ResourceOption) (*ManagedZone, error)

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

func (*ManagedZone) ElementType added in v4.4.0 

func (*ManagedZone) ElementType() reflect.Type

func (*ManagedZone) ToManagedZoneOutput added in v4.4.0 

func (i *ManagedZone) ToManagedZoneOutput() ManagedZoneOutput

func (*ManagedZone) ToManagedZoneOutputWithContext added in v4.4.0 

func (i *ManagedZone) ToManagedZoneOutputWithContext(ctx context.Context) ManagedZoneOutput

func (*ManagedZone) ToManagedZonePtrOutput added in v4.11.1 

func (i *ManagedZone) ToManagedZonePtrOutput() ManagedZonePtrOutput

func (*ManagedZone) ToManagedZonePtrOutputWithContext added in v4.11.1 

func (i *ManagedZone) ToManagedZonePtrOutputWithContext(ctx context.Context) ManagedZonePtrOutput

type ManagedZoneArgs 

type ManagedZoneArgs struct {
	// A textual description field. Defaults to 'Managed by Pulumi'.
	Description pulumi.StringPtrInput
	// The DNS name of this managed zone, for instance "example.com.".
	DnsName pulumi.StringInput
	// DNSSEC configuration
	// Structure is documented below.
	DnssecConfig ManagedZoneDnssecConfigPtrInput
	// Set this true to delete all records in the zone.
	ForceDestroy pulumi.BoolPtrInput
	// The presence for this field indicates that outbound forwarding is enabled
	// for this zone. The value of this field contains the set of destinations
	// to forward to.
	// Structure is documented below.
	ForwardingConfig ManagedZoneForwardingConfigPtrInput
	// A set of key/value label pairs to assign to this ManagedZone.
	Labels pulumi.StringMapInput
	// User assigned name for this resource.
	// Must be unique within the project.
	Name pulumi.StringPtrInput
	// The presence of this field indicates that DNS Peering is enabled for this
	// zone. The value of this field contains the network to peer with.
	// Structure is documented below.
	PeeringConfig ManagedZonePeeringConfigPtrInput
	// For privately visible zones, the set of Virtual Private Cloud
	// resources that the zone is visible from.
	// Structure is documented below.
	PrivateVisibilityConfig ManagedZonePrivateVisibilityConfigPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// Specifies if this is a managed reverse lookup zone. If true, Cloud DNS will resolve reverse
	// lookup queries using automatically configured records for VPC resources. This only applies
	// to networks listed under `privateVisibilityConfig`.
	ReverseLookup pulumi.BoolPtrInput
	// The presence of this field indicates that this zone is backed by Service Directory. The value of this field contains information related to the namespace associated with the zone.  Structure is documented below.
	ServiceDirectoryConfig ManagedZoneServiceDirectoryConfigPtrInput
	// The zone's visibility: public zones are exposed to the Internet,
	// while private zones are visible only to Virtual Private Cloud resources.
	// Default value is `public`.
	// Possible values are `private` and `public`.
	Visibility pulumi.StringPtrInput
}

The set of arguments for constructing a ManagedZone resource.

func (ManagedZoneArgs) ElementType 

func (ManagedZoneArgs) ElementType() reflect.Type

type ManagedZoneArray added in v4.11.1 

type ManagedZoneArray []ManagedZoneInput

func (ManagedZoneArray) ElementType added in v4.11.1 

func (ManagedZoneArray) ElementType() reflect.Type

func (ManagedZoneArray) ToManagedZoneArrayOutput added in v4.11.1 

func (i ManagedZoneArray) ToManagedZoneArrayOutput() ManagedZoneArrayOutput

func (ManagedZoneArray) ToManagedZoneArrayOutputWithContext added in v4.11.1 

func (i ManagedZoneArray) ToManagedZoneArrayOutputWithContext(ctx context.Context) ManagedZoneArrayOutput

type ManagedZoneArrayInput added in v4.11.1 

type ManagedZoneArrayInput interface {
	pulumi.Input

	ToManagedZoneArrayOutput() ManagedZoneArrayOutput
	ToManagedZoneArrayOutputWithContext(context.Context) ManagedZoneArrayOutput
}

ManagedZoneArrayInput is an input type that accepts ManagedZoneArray and ManagedZoneArrayOutput values. You can construct a concrete instance of `ManagedZoneArrayInput` via: 

ManagedZoneArray{ ManagedZoneArgs{...} }

type ManagedZoneArrayOutput added in v4.11.1 

type ManagedZoneArrayOutput struct{ *pulumi.OutputState }

func (ManagedZoneArrayOutput) ElementType added in v4.11.1 

func (ManagedZoneArrayOutput) ElementType() reflect.Type

func (ManagedZoneArrayOutput) Index added in v4.11.1 

func (o ManagedZoneArrayOutput) Index(i pulumi.IntInput) ManagedZoneOutput

func (ManagedZoneArrayOutput) ToManagedZoneArrayOutput added in v4.11.1 

func (o ManagedZoneArrayOutput) ToManagedZoneArrayOutput() ManagedZoneArrayOutput

func (ManagedZoneArrayOutput) ToManagedZoneArrayOutputWithContext added in v4.11.1 

func (o ManagedZoneArrayOutput) ToManagedZoneArrayOutputWithContext(ctx context.Context) ManagedZoneArrayOutput

type ManagedZoneDnssecConfig 

type ManagedZoneDnssecConfig struct {
	// Specifies parameters that will be used for generating initial DnsKeys
	// for this ManagedZone. If you provide a spec for keySigning or zoneSigning,
	// you must also provide one for the other.
	// defaultKeySpecs can only be updated when the state is `off`.
	// Structure is documented below.
	DefaultKeySpecs []ManagedZoneDnssecConfigDefaultKeySpec `pulumi:"defaultKeySpecs"`
	// Identifies what kind of resource this is
	Kind *string `pulumi:"kind"`
	// Specifies the mechanism used to provide authenticated denial-of-existence responses.
	// nonExistence can only be updated when the state is `off`.
	// Possible values are `nsec` and `nsec3`.
	NonExistence *string `pulumi:"nonExistence"`
	// Specifies whether DNSSEC is enabled, and what mode it is in
	// Possible values are `off`, `on`, and `transfer`.
	State *string `pulumi:"state"`
}

type ManagedZoneDnssecConfigArgs 

type ManagedZoneDnssecConfigArgs struct {
	// Specifies parameters that will be used for generating initial DnsKeys
	// for this ManagedZone. If you provide a spec for keySigning or zoneSigning,
	// you must also provide one for the other.
	// defaultKeySpecs can only be updated when the state is `off`.
	// Structure is documented below.
	DefaultKeySpecs ManagedZoneDnssecConfigDefaultKeySpecArrayInput `pulumi:"defaultKeySpecs"`
	// Identifies what kind of resource this is
	Kind pulumi.StringPtrInput `pulumi:"kind"`
	// Specifies the mechanism used to provide authenticated denial-of-existence responses.
	// nonExistence can only be updated when the state is `off`.
	// Possible values are `nsec` and `nsec3`.
	NonExistence pulumi.StringPtrInput `pulumi:"nonExistence"`
	// Specifies whether DNSSEC is enabled, and what mode it is in
	// Possible values are `off`, `on`, and `transfer`.
	State pulumi.StringPtrInput `pulumi:"state"`
}

func (ManagedZoneDnssecConfigArgs) ElementType 

func (ManagedZoneDnssecConfigArgs) ElementType() reflect.Type

func (ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigOutput 

func (i ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigOutput() ManagedZoneDnssecConfigOutput

func (ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigOutputWithContext 

func (i ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigOutput

func (ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigPtrOutput 

func (i ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigPtrOutput() ManagedZoneDnssecConfigPtrOutput

func (ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigPtrOutputWithContext 

func (i ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigPtrOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigPtrOutput

type ManagedZoneDnssecConfigDefaultKeySpec 

type ManagedZoneDnssecConfigDefaultKeySpec struct {
	// String mnemonic specifying the DNSSEC algorithm of this key
	// Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
	Algorithm *string `pulumi:"algorithm"`
	// Length of the keys in bits
	KeyLength *int `pulumi:"keyLength"`
	// Specifies whether this is a key signing key (KSK) or a zone
	// signing key (ZSK). Key signing keys have the Secure Entry
	// Point flag set and, when active, will only be used to sign
	// resource record sets of type DNSKEY. Zone signing keys do
	// not have the Secure Entry Point flag set and will be used
	// to sign all other types of resource record sets.
	// Possible values are `keySigning` and `zoneSigning`.
	KeyType *string `pulumi:"keyType"`
	// Identifies what kind of resource this is
	Kind *string `pulumi:"kind"`
}

type ManagedZoneDnssecConfigDefaultKeySpecArgs 

type ManagedZoneDnssecConfigDefaultKeySpecArgs struct {
	// String mnemonic specifying the DNSSEC algorithm of this key
	// Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
	Algorithm pulumi.StringPtrInput `pulumi:"algorithm"`
	// Length of the keys in bits
	KeyLength pulumi.IntPtrInput `pulumi:"keyLength"`
	// Specifies whether this is a key signing key (KSK) or a zone
	// signing key (ZSK). Key signing keys have the Secure Entry
	// Point flag set and, when active, will only be used to sign
	// resource record sets of type DNSKEY. Zone signing keys do
	// not have the Secure Entry Point flag set and will be used
	// to sign all other types of resource record sets.
	// Possible values are `keySigning` and `zoneSigning`.
	KeyType pulumi.StringPtrInput `pulumi:"keyType"`
	// Identifies what kind of resource this is
	Kind pulumi.StringPtrInput `pulumi:"kind"`
}

func (ManagedZoneDnssecConfigDefaultKeySpecArgs) ElementType 

func (ManagedZoneDnssecConfigDefaultKeySpecArgs) ElementType() reflect.Type

func (ManagedZoneDnssecConfigDefaultKeySpecArgs) ToManagedZoneDnssecConfigDefaultKeySpecOutput 

func (i ManagedZoneDnssecConfigDefaultKeySpecArgs) ToManagedZoneDnssecConfigDefaultKeySpecOutput() ManagedZoneDnssecConfigDefaultKeySpecOutput

func (ManagedZoneDnssecConfigDefaultKeySpecArgs) ToManagedZoneDnssecConfigDefaultKeySpecOutputWithContext 

func (i ManagedZoneDnssecConfigDefaultKeySpecArgs) ToManagedZoneDnssecConfigDefaultKeySpecOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigDefaultKeySpecOutput

type ManagedZoneDnssecConfigDefaultKeySpecArray 

type ManagedZoneDnssecConfigDefaultKeySpecArray []ManagedZoneDnssecConfigDefaultKeySpecInput

func (ManagedZoneDnssecConfigDefaultKeySpecArray) ElementType 

func (ManagedZoneDnssecConfigDefaultKeySpecArray) ElementType() reflect.Type

func (ManagedZoneDnssecConfigDefaultKeySpecArray) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutput 

func (i ManagedZoneDnssecConfigDefaultKeySpecArray) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutput() ManagedZoneDnssecConfigDefaultKeySpecArrayOutput

func (ManagedZoneDnssecConfigDefaultKeySpecArray) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutputWithContext 

func (i ManagedZoneDnssecConfigDefaultKeySpecArray) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigDefaultKeySpecArrayOutput

type ManagedZoneDnssecConfigDefaultKeySpecArrayInput 

type ManagedZoneDnssecConfigDefaultKeySpecArrayInput interface {
	pulumi.Input

	ToManagedZoneDnssecConfigDefaultKeySpecArrayOutput() ManagedZoneDnssecConfigDefaultKeySpecArrayOutput
	ToManagedZoneDnssecConfigDefaultKeySpecArrayOutputWithContext(context.Context) ManagedZoneDnssecConfigDefaultKeySpecArrayOutput
}

ManagedZoneDnssecConfigDefaultKeySpecArrayInput is an input type that accepts ManagedZoneDnssecConfigDefaultKeySpecArray and ManagedZoneDnssecConfigDefaultKeySpecArrayOutput values. You can construct a concrete instance of `ManagedZoneDnssecConfigDefaultKeySpecArrayInput` via: 

ManagedZoneDnssecConfigDefaultKeySpecArray{ ManagedZoneDnssecConfigDefaultKeySpecArgs{...} }

type ManagedZoneDnssecConfigDefaultKeySpecArrayOutput 

type ManagedZoneDnssecConfigDefaultKeySpecArrayOutput struct{ *pulumi.OutputState }

func (ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) ElementType 

func (ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) ElementType() reflect.Type

func (ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) Index 

func (o ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) Index(i pulumi.IntInput) ManagedZoneDnssecConfigDefaultKeySpecOutput

func (ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutput 

func (o ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutput() ManagedZoneDnssecConfigDefaultKeySpecArrayOutput

func (ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutputWithContext 

func (o ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigDefaultKeySpecArrayOutput

type ManagedZoneDnssecConfigDefaultKeySpecInput 

type ManagedZoneDnssecConfigDefaultKeySpecInput interface {
	pulumi.Input

	ToManagedZoneDnssecConfigDefaultKeySpecOutput() ManagedZoneDnssecConfigDefaultKeySpecOutput
	ToManagedZoneDnssecConfigDefaultKeySpecOutputWithContext(context.Context) ManagedZoneDnssecConfigDefaultKeySpecOutput
}

ManagedZoneDnssecConfigDefaultKeySpecInput is an input type that accepts ManagedZoneDnssecConfigDefaultKeySpecArgs and ManagedZoneDnssecConfigDefaultKeySpecOutput values. You can construct a concrete instance of `ManagedZoneDnssecConfigDefaultKeySpecInput` via: 

ManagedZoneDnssecConfigDefaultKeySpecArgs{...}

type ManagedZoneDnssecConfigDefaultKeySpecOutput 

type ManagedZoneDnssecConfigDefaultKeySpecOutput struct{ *pulumi.OutputState }

func (ManagedZoneDnssecConfigDefaultKeySpecOutput) Algorithm 

func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) Algorithm() pulumi.StringPtrOutput

String mnemonic specifying the DNSSEC algorithm of this key Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.

func (ManagedZoneDnssecConfigDefaultKeySpecOutput) ElementType 

func (ManagedZoneDnssecConfigDefaultKeySpecOutput) ElementType() reflect.Type

func (ManagedZoneDnssecConfigDefaultKeySpecOutput) KeyLength 

func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) KeyLength() pulumi.IntPtrOutput

Length of the keys in bits

func (ManagedZoneDnssecConfigDefaultKeySpecOutput) KeyType 

func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) KeyType() pulumi.StringPtrOutput

Specifies whether this is a key signing key (KSK) or a zone signing key (ZSK). Key signing keys have the Secure Entry Point flag set and, when active, will only be used to sign resource record sets of type DNSKEY. Zone signing keys do not have the Secure Entry Point flag set and will be used to sign all other types of resource record sets. Possible values are `keySigning` and `zoneSigning`.

func (ManagedZoneDnssecConfigDefaultKeySpecOutput) Kind 

func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) Kind() pulumi.StringPtrOutput

Identifies what kind of resource this is

func (ManagedZoneDnssecConfigDefaultKeySpecOutput) ToManagedZoneDnssecConfigDefaultKeySpecOutput 

func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) ToManagedZoneDnssecConfigDefaultKeySpecOutput() ManagedZoneDnssecConfigDefaultKeySpecOutput

func (ManagedZoneDnssecConfigDefaultKeySpecOutput) ToManagedZoneDnssecConfigDefaultKeySpecOutputWithContext 

func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) ToManagedZoneDnssecConfigDefaultKeySpecOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigDefaultKeySpecOutput

type ManagedZoneDnssecConfigInput 

type ManagedZoneDnssecConfigInput interface {
	pulumi.Input

	ToManagedZoneDnssecConfigOutput() ManagedZoneDnssecConfigOutput
	ToManagedZoneDnssecConfigOutputWithContext(context.Context) ManagedZoneDnssecConfigOutput
}

ManagedZoneDnssecConfigInput is an input type that accepts ManagedZoneDnssecConfigArgs and ManagedZoneDnssecConfigOutput values. You can construct a concrete instance of `ManagedZoneDnssecConfigInput` via: 

ManagedZoneDnssecConfigArgs{...}

type ManagedZoneDnssecConfigOutput 

type ManagedZoneDnssecConfigOutput struct{ *pulumi.OutputState }

func (ManagedZoneDnssecConfigOutput) DefaultKeySpecs 

func (o ManagedZoneDnssecConfigOutput) DefaultKeySpecs() ManagedZoneDnssecConfigDefaultKeySpecArrayOutput

Specifies parameters that will be used for generating initial DnsKeys for this ManagedZone. If you provide a spec for keySigning or zoneSigning, you must also provide one for the other. defaultKeySpecs can only be updated when the state is `off`. Structure is documented below.

func (ManagedZoneDnssecConfigOutput) ElementType 

func (ManagedZoneDnssecConfigOutput) ElementType() reflect.Type

func (ManagedZoneDnssecConfigOutput) Kind 

func (o ManagedZoneDnssecConfigOutput) Kind() pulumi.StringPtrOutput

Identifies what kind of resource this is

func (ManagedZoneDnssecConfigOutput) NonExistence 

func (o ManagedZoneDnssecConfigOutput) NonExistence() pulumi.StringPtrOutput

Specifies the mechanism used to provide authenticated denial-of-existence responses. nonExistence can only be updated when the state is `off`. Possible values are `nsec` and `nsec3`.

func (ManagedZoneDnssecConfigOutput) State 

func (o ManagedZoneDnssecConfigOutput) State() pulumi.StringPtrOutput

Specifies whether DNSSEC is enabled, and what mode it is in Possible values are `off`, `on`, and `transfer`.

func (ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigOutput 

func (o ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigOutput() ManagedZoneDnssecConfigOutput

func (ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigOutputWithContext 

func (o ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigOutput

func (ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigPtrOutput 

func (o ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigPtrOutput() ManagedZoneDnssecConfigPtrOutput

func (ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigPtrOutputWithContext 

func (o ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigPtrOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigPtrOutput

type ManagedZoneDnssecConfigPtrInput 

type ManagedZoneDnssecConfigPtrInput interface {
	pulumi.Input

	ToManagedZoneDnssecConfigPtrOutput() ManagedZoneDnssecConfigPtrOutput
	ToManagedZoneDnssecConfigPtrOutputWithContext(context.Context) ManagedZoneDnssecConfigPtrOutput
}

ManagedZoneDnssecConfigPtrInput is an input type that accepts ManagedZoneDnssecConfigArgs, ManagedZoneDnssecConfigPtr and ManagedZoneDnssecConfigPtrOutput values. You can construct a concrete instance of `ManagedZoneDnssecConfigPtrInput` via: 

        ManagedZoneDnssecConfigArgs{...}

or:

        nil

func ManagedZoneDnssecConfigPtr 

func ManagedZoneDnssecConfigPtr(v *ManagedZoneDnssecConfigArgs) ManagedZoneDnssecConfigPtrInput

type ManagedZoneDnssecConfigPtrOutput 

type ManagedZoneDnssecConfigPtrOutput struct{ *pulumi.OutputState }

func (ManagedZoneDnssecConfigPtrOutput) DefaultKeySpecs 

func (o ManagedZoneDnssecConfigPtrOutput) DefaultKeySpecs() ManagedZoneDnssecConfigDefaultKeySpecArrayOutput

Specifies parameters that will be used for generating initial DnsKeys for this ManagedZone. If you provide a spec for keySigning or zoneSigning, you must also provide one for the other. defaultKeySpecs can only be updated when the state is `off`. Structure is documented below.

func (ManagedZoneDnssecConfigPtrOutput) Elem 

func (o ManagedZoneDnssecConfigPtrOutput) Elem() ManagedZoneDnssecConfigOutput

func (ManagedZoneDnssecConfigPtrOutput) ElementType 

func (ManagedZoneDnssecConfigPtrOutput) ElementType() reflect.Type

func (ManagedZoneDnssecConfigPtrOutput) Kind 

func (o ManagedZoneDnssecConfigPtrOutput) Kind() pulumi.StringPtrOutput

Identifies what kind of resource this is

func (ManagedZoneDnssecConfigPtrOutput) NonExistence 

func (o ManagedZoneDnssecConfigPtrOutput) NonExistence() pulumi.StringPtrOutput

Specifies the mechanism used to provide authenticated denial-of-existence responses. nonExistence can only be updated when the state is `off`. Possible values are `nsec` and `nsec3`.

func (ManagedZoneDnssecConfigPtrOutput) State 

func (o ManagedZoneDnssecConfigPtrOutput) State() pulumi.StringPtrOutput

Specifies whether DNSSEC is enabled, and what mode it is in Possible values are `off`, `on`, and `transfer`.

func (ManagedZoneDnssecConfigPtrOutput) ToManagedZoneDnssecConfigPtrOutput 

func (o ManagedZoneDnssecConfigPtrOutput) ToManagedZoneDnssecConfigPtrOutput() ManagedZoneDnssecConfigPtrOutput

func (ManagedZoneDnssecConfigPtrOutput) ToManagedZoneDnssecConfigPtrOutputWithContext 

func (o ManagedZoneDnssecConfigPtrOutput) ToManagedZoneDnssecConfigPtrOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigPtrOutput

type ManagedZoneForwardingConfig 

type ManagedZoneForwardingConfig struct {
	// List of target name servers to forward to. Cloud DNS will
	// select the best available name server if more than
	// one target is given.
	// Structure is documented below.
	TargetNameServers []ManagedZoneForwardingConfigTargetNameServer `pulumi:"targetNameServers"`
}

type ManagedZoneForwardingConfigArgs 

type ManagedZoneForwardingConfigArgs struct {
	// List of target name servers to forward to. Cloud DNS will
	// select the best available name server if more than
	// one target is given.
	// Structure is documented below.
	TargetNameServers ManagedZoneForwardingConfigTargetNameServerArrayInput `pulumi:"targetNameServers"`
}

func (ManagedZoneForwardingConfigArgs) ElementType 

func (ManagedZoneForwardingConfigArgs) ElementType() reflect.Type

func (ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigOutput 

func (i ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigOutput() ManagedZoneForwardingConfigOutput

func (ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigOutputWithContext 

func (i ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigOutput

func (ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigPtrOutput 

func (i ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigPtrOutput() ManagedZoneForwardingConfigPtrOutput

func (ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigPtrOutputWithContext 

func (i ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigPtrOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigPtrOutput

type ManagedZoneForwardingConfigInput 

type ManagedZoneForwardingConfigInput interface {
	pulumi.Input

	ToManagedZoneForwardingConfigOutput() ManagedZoneForwardingConfigOutput
	ToManagedZoneForwardingConfigOutputWithContext(context.Context) ManagedZoneForwardingConfigOutput
}

ManagedZoneForwardingConfigInput is an input type that accepts ManagedZoneForwardingConfigArgs and ManagedZoneForwardingConfigOutput values. You can construct a concrete instance of `ManagedZoneForwardingConfigInput` via: 

ManagedZoneForwardingConfigArgs{...}

type ManagedZoneForwardingConfigOutput 

type ManagedZoneForwardingConfigOutput struct{ *pulumi.OutputState }

func (ManagedZoneForwardingConfigOutput) ElementType 

func (ManagedZoneForwardingConfigOutput) ElementType() reflect.Type

func (ManagedZoneForwardingConfigOutput) TargetNameServers 

func (o ManagedZoneForwardingConfigOutput) TargetNameServers() ManagedZoneForwardingConfigTargetNameServerArrayOutput

List of target name servers to forward to. Cloud DNS will select the best available name server if more than one target is given. Structure is documented below.

func (ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigOutput 

func (o ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigOutput() ManagedZoneForwardingConfigOutput

func (ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigOutputWithContext 

func (o ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigOutput

func (ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigPtrOutput 

func (o ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigPtrOutput() ManagedZoneForwardingConfigPtrOutput

func (ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigPtrOutputWithContext 

func (o ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigPtrOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigPtrOutput

type ManagedZoneForwardingConfigPtrInput 

type ManagedZoneForwardingConfigPtrInput interface {
	pulumi.Input

	ToManagedZoneForwardingConfigPtrOutput() ManagedZoneForwardingConfigPtrOutput
	ToManagedZoneForwardingConfigPtrOutputWithContext(context.Context) ManagedZoneForwardingConfigPtrOutput
}

ManagedZoneForwardingConfigPtrInput is an input type that accepts ManagedZoneForwardingConfigArgs, ManagedZoneForwardingConfigPtr and ManagedZoneForwardingConfigPtrOutput values. You can construct a concrete instance of `ManagedZoneForwardingConfigPtrInput` via: 

        ManagedZoneForwardingConfigArgs{...}

or:

        nil

func ManagedZoneForwardingConfigPtr 

func ManagedZoneForwardingConfigPtr(v *ManagedZoneForwardingConfigArgs) ManagedZoneForwardingConfigPtrInput

type ManagedZoneForwardingConfigPtrOutput 

type ManagedZoneForwardingConfigPtrOutput struct{ *pulumi.OutputState }

func (ManagedZoneForwardingConfigPtrOutput) Elem 

func (o ManagedZoneForwardingConfigPtrOutput) Elem() ManagedZoneForwardingConfigOutput

func (ManagedZoneForwardingConfigPtrOutput) ElementType 

func (ManagedZoneForwardingConfigPtrOutput) ElementType() reflect.Type

func (ManagedZoneForwardingConfigPtrOutput) TargetNameServers 

func (o ManagedZoneForwardingConfigPtrOutput) TargetNameServers() ManagedZoneForwardingConfigTargetNameServerArrayOutput

List of target name servers to forward to. Cloud DNS will select the best available name server if more than one target is given. Structure is documented below.

func (ManagedZoneForwardingConfigPtrOutput) ToManagedZoneForwardingConfigPtrOutput 

func (o ManagedZoneForwardingConfigPtrOutput) ToManagedZoneForwardingConfigPtrOutput() ManagedZoneForwardingConfigPtrOutput

func (ManagedZoneForwardingConfigPtrOutput) ToManagedZoneForwardingConfigPtrOutputWithContext 

func (o ManagedZoneForwardingConfigPtrOutput) ToManagedZoneForwardingConfigPtrOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigPtrOutput

type ManagedZoneForwardingConfigTargetNameServer 

type ManagedZoneForwardingConfigTargetNameServer struct {
	// Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
	// decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
	// to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
	// Possible values are `default` and `private`.
	ForwardingPath *string `pulumi:"forwardingPath"`
	// IPv4 address of a target name server.
	Ipv4Address string `pulumi:"ipv4Address"`
}

type ManagedZoneForwardingConfigTargetNameServerArgs 

type ManagedZoneForwardingConfigTargetNameServerArgs struct {
	// Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
	// decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
	// to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
	// Possible values are `default` and `private`.
	ForwardingPath pulumi.StringPtrInput `pulumi:"forwardingPath"`
	// IPv4 address of a target name server.
	Ipv4Address pulumi.StringInput `pulumi:"ipv4Address"`
}

func (ManagedZoneForwardingConfigTargetNameServerArgs) ElementType 

func (ManagedZoneForwardingConfigTargetNameServerArgs) ElementType() reflect.Type

func (ManagedZoneForwardingConfigTargetNameServerArgs) ToManagedZoneForwardingConfigTargetNameServerOutput 

func (i ManagedZoneForwardingConfigTargetNameServerArgs) ToManagedZoneForwardingConfigTargetNameServerOutput() ManagedZoneForwardingConfigTargetNameServerOutput

func (ManagedZoneForwardingConfigTargetNameServerArgs) ToManagedZoneForwardingConfigTargetNameServerOutputWithContext 

func (i ManagedZoneForwardingConfigTargetNameServerArgs) ToManagedZoneForwardingConfigTargetNameServerOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigTargetNameServerOutput

type ManagedZoneForwardingConfigTargetNameServerArray 

type ManagedZoneForwardingConfigTargetNameServerArray []ManagedZoneForwardingConfigTargetNameServerInput

func (ManagedZoneForwardingConfigTargetNameServerArray) ElementType 

func (ManagedZoneForwardingConfigTargetNameServerArray) ElementType() reflect.Type

func (ManagedZoneForwardingConfigTargetNameServerArray) ToManagedZoneForwardingConfigTargetNameServerArrayOutput 

func (i ManagedZoneForwardingConfigTargetNameServerArray) ToManagedZoneForwardingConfigTargetNameServerArrayOutput() ManagedZoneForwardingConfigTargetNameServerArrayOutput

func (ManagedZoneForwardingConfigTargetNameServerArray) ToManagedZoneForwardingConfigTargetNameServerArrayOutputWithContext 

func (i ManagedZoneForwardingConfigTargetNameServerArray) ToManagedZoneForwardingConfigTargetNameServerArrayOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigTargetNameServerArrayOutput

type ManagedZoneForwardingConfigTargetNameServerArrayInput 

type ManagedZoneForwardingConfigTargetNameServerArrayInput interface {
	pulumi.Input

	ToManagedZoneForwardingConfigTargetNameServerArrayOutput() ManagedZoneForwardingConfigTargetNameServerArrayOutput
	ToManagedZoneForwardingConfigTargetNameServerArrayOutputWithContext(context.Context) ManagedZoneForwardingConfigTargetNameServerArrayOutput
}

ManagedZoneForwardingConfigTargetNameServerArrayInput is an input type that accepts ManagedZoneForwardingConfigTargetNameServerArray and ManagedZoneForwardingConfigTargetNameServerArrayOutput values. You can construct a concrete instance of `ManagedZoneForwardingConfigTargetNameServerArrayInput` via: 

ManagedZoneForwardingConfigTargetNameServerArray{ ManagedZoneForwardingConfigTargetNameServerArgs{...} }

type ManagedZoneForwardingConfigTargetNameServerArrayOutput 

type ManagedZoneForwardingConfigTargetNameServerArrayOutput struct{ *pulumi.OutputState }

func (ManagedZoneForwardingConfigTargetNameServerArrayOutput) ElementType 

func (ManagedZoneForwardingConfigTargetNameServerArrayOutput) ElementType() reflect.Type

func (ManagedZoneForwardingConfigTargetNameServerArrayOutput) Index 

func (o ManagedZoneForwardingConfigTargetNameServerArrayOutput) Index(i pulumi.IntInput) ManagedZoneForwardingConfigTargetNameServerOutput

func (ManagedZoneForwardingConfigTargetNameServerArrayOutput) ToManagedZoneForwardingConfigTargetNameServerArrayOutput 

func (o ManagedZoneForwardingConfigTargetNameServerArrayOutput) ToManagedZoneForwardingConfigTargetNameServerArrayOutput() ManagedZoneForwardingConfigTargetNameServerArrayOutput

func (ManagedZoneForwardingConfigTargetNameServerArrayOutput) ToManagedZoneForwardingConfigTargetNameServerArrayOutputWithContext 

func (o ManagedZoneForwardingConfigTargetNameServerArrayOutput) ToManagedZoneForwardingConfigTargetNameServerArrayOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigTargetNameServerArrayOutput

type ManagedZoneForwardingConfigTargetNameServerInput 

type ManagedZoneForwardingConfigTargetNameServerInput interface {
	pulumi.Input

	ToManagedZoneForwardingConfigTargetNameServerOutput() ManagedZoneForwardingConfigTargetNameServerOutput
	ToManagedZoneForwardingConfigTargetNameServerOutputWithContext(context.Context) ManagedZoneForwardingConfigTargetNameServerOutput
}

ManagedZoneForwardingConfigTargetNameServerInput is an input type that accepts ManagedZoneForwardingConfigTargetNameServerArgs and ManagedZoneForwardingConfigTargetNameServerOutput values. You can construct a concrete instance of `ManagedZoneForwardingConfigTargetNameServerInput` via: 

ManagedZoneForwardingConfigTargetNameServerArgs{...}

type ManagedZoneForwardingConfigTargetNameServerOutput 

type ManagedZoneForwardingConfigTargetNameServerOutput struct{ *pulumi.OutputState }

func (ManagedZoneForwardingConfigTargetNameServerOutput) ElementType 

func (ManagedZoneForwardingConfigTargetNameServerOutput) ElementType() reflect.Type

func (ManagedZoneForwardingConfigTargetNameServerOutput) ForwardingPath 

func (o ManagedZoneForwardingConfigTargetNameServerOutput) ForwardingPath() pulumi.StringPtrOutput

Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target Possible values are `default` and `private`.

func (ManagedZoneForwardingConfigTargetNameServerOutput) Ipv4Address 

func (o ManagedZoneForwardingConfigTargetNameServerOutput) Ipv4Address() pulumi.StringOutput

IPv4 address of a target name server.

func (ManagedZoneForwardingConfigTargetNameServerOutput) ToManagedZoneForwardingConfigTargetNameServerOutput 

func (o ManagedZoneForwardingConfigTargetNameServerOutput) ToManagedZoneForwardingConfigTargetNameServerOutput() ManagedZoneForwardingConfigTargetNameServerOutput

func (ManagedZoneForwardingConfigTargetNameServerOutput) ToManagedZoneForwardingConfigTargetNameServerOutputWithContext 

func (o ManagedZoneForwardingConfigTargetNameServerOutput) ToManagedZoneForwardingConfigTargetNameServerOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigTargetNameServerOutput

type ManagedZoneInput added in v4.4.0 

type ManagedZoneInput interface {
	pulumi.Input

	ToManagedZoneOutput() ManagedZoneOutput
	ToManagedZoneOutputWithContext(ctx context.Context) ManagedZoneOutput
}

type ManagedZoneMap added in v4.11.1 

type ManagedZoneMap map[string]ManagedZoneInput

func (ManagedZoneMap) ElementType added in v4.11.1 

func (ManagedZoneMap) ElementType() reflect.Type

func (ManagedZoneMap) ToManagedZoneMapOutput added in v4.11.1 

func (i ManagedZoneMap) ToManagedZoneMapOutput() ManagedZoneMapOutput

func (ManagedZoneMap) ToManagedZoneMapOutputWithContext added in v4.11.1 

func (i ManagedZoneMap) ToManagedZoneMapOutputWithContext(ctx context.Context) ManagedZoneMapOutput

type ManagedZoneMapInput added in v4.11.1 

type ManagedZoneMapInput interface {
	pulumi.Input

	ToManagedZoneMapOutput() ManagedZoneMapOutput
	ToManagedZoneMapOutputWithContext(context.Context) ManagedZoneMapOutput
}

ManagedZoneMapInput is an input type that accepts ManagedZoneMap and ManagedZoneMapOutput values. You can construct a concrete instance of `ManagedZoneMapInput` via: 

ManagedZoneMap{ "key": ManagedZoneArgs{...} }

type ManagedZoneMapOutput added in v4.11.1 

type ManagedZoneMapOutput struct{ *pulumi.OutputState }

func (ManagedZoneMapOutput) ElementType added in v4.11.1 

func (ManagedZoneMapOutput) ElementType() reflect.Type

func (ManagedZoneMapOutput) MapIndex added in v4.11.1 

func (o ManagedZoneMapOutput) MapIndex(k pulumi.StringInput) ManagedZoneOutput

func (ManagedZoneMapOutput) ToManagedZoneMapOutput added in v4.11.1 

func (o ManagedZoneMapOutput) ToManagedZoneMapOutput() ManagedZoneMapOutput

func (ManagedZoneMapOutput) ToManagedZoneMapOutputWithContext added in v4.11.1 

func (o ManagedZoneMapOutput) ToManagedZoneMapOutputWithContext(ctx context.Context) ManagedZoneMapOutput

type ManagedZoneOutput added in v4.4.0 

type ManagedZoneOutput struct {
	*pulumi.OutputState
}

func (ManagedZoneOutput) ElementType added in v4.4.0 

func (ManagedZoneOutput) ElementType() reflect.Type

func (ManagedZoneOutput) ToManagedZoneOutput added in v4.4.0 

func (o ManagedZoneOutput) ToManagedZoneOutput() ManagedZoneOutput

func (ManagedZoneOutput) ToManagedZoneOutputWithContext added in v4.4.0 

func (o ManagedZoneOutput) ToManagedZoneOutputWithContext(ctx context.Context) ManagedZoneOutput

func (ManagedZoneOutput) ToManagedZonePtrOutput added in v4.11.1 

func (o ManagedZoneOutput) ToManagedZonePtrOutput() ManagedZonePtrOutput

func (ManagedZoneOutput) ToManagedZonePtrOutputWithContext added in v4.11.1 

func (o ManagedZoneOutput) ToManagedZonePtrOutputWithContext(ctx context.Context) ManagedZonePtrOutput

type ManagedZonePeeringConfig 

type ManagedZonePeeringConfig struct {
	// The network with which to peer.
	// Structure is documented below.
	TargetNetwork ManagedZonePeeringConfigTargetNetwork `pulumi:"targetNetwork"`
}

type ManagedZonePeeringConfigArgs 

type ManagedZonePeeringConfigArgs struct {
	// The network with which to peer.
	// Structure is documented below.
	TargetNetwork ManagedZonePeeringConfigTargetNetworkInput `pulumi:"targetNetwork"`
}

func (ManagedZonePeeringConfigArgs) ElementType 

func (ManagedZonePeeringConfigArgs) ElementType() reflect.Type

func (ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigOutput 

func (i ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigOutput() ManagedZonePeeringConfigOutput

func (ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigOutputWithContext 

func (i ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigOutputWithContext(ctx context.Context) ManagedZonePeeringConfigOutput

func (ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigPtrOutput 

func (i ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigPtrOutput() ManagedZonePeeringConfigPtrOutput

func (ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigPtrOutputWithContext 

func (i ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigPtrOutput

type ManagedZonePeeringConfigInput 

type ManagedZonePeeringConfigInput interface {
	pulumi.Input

	ToManagedZonePeeringConfigOutput() ManagedZonePeeringConfigOutput
	ToManagedZonePeeringConfigOutputWithContext(context.Context) ManagedZonePeeringConfigOutput
}

ManagedZonePeeringConfigInput is an input type that accepts ManagedZonePeeringConfigArgs and ManagedZonePeeringConfigOutput values. You can construct a concrete instance of `ManagedZonePeeringConfigInput` via: 

ManagedZonePeeringConfigArgs{...}

type ManagedZonePeeringConfigOutput 

type ManagedZonePeeringConfigOutput struct{ *pulumi.OutputState }

func (ManagedZonePeeringConfigOutput) ElementType 

func (ManagedZonePeeringConfigOutput) ElementType() reflect.Type

func (ManagedZonePeeringConfigOutput) TargetNetwork 

func (o ManagedZonePeeringConfigOutput) TargetNetwork() ManagedZonePeeringConfigTargetNetworkOutput

The network with which to peer. Structure is documented below.

func (ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigOutput 

func (o ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigOutput() ManagedZonePeeringConfigOutput

func (ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigOutputWithContext 

func (o ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigOutputWithContext(ctx context.Context) ManagedZonePeeringConfigOutput

func (ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigPtrOutput 

func (o ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigPtrOutput() ManagedZonePeeringConfigPtrOutput

func (ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigPtrOutputWithContext 

func (o ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigPtrOutput

type ManagedZonePeeringConfigPtrInput 

type ManagedZonePeeringConfigPtrInput interface {
	pulumi.Input

	ToManagedZonePeeringConfigPtrOutput() ManagedZonePeeringConfigPtrOutput
	ToManagedZonePeeringConfigPtrOutputWithContext(context.Context) ManagedZonePeeringConfigPtrOutput
}

ManagedZonePeeringConfigPtrInput is an input type that accepts ManagedZonePeeringConfigArgs, ManagedZonePeeringConfigPtr and ManagedZonePeeringConfigPtrOutput values. You can construct a concrete instance of `ManagedZonePeeringConfigPtrInput` via: 

        ManagedZonePeeringConfigArgs{...}

or:

        nil

func ManagedZonePeeringConfigPtr 

func ManagedZonePeeringConfigPtr(v *ManagedZonePeeringConfigArgs) ManagedZonePeeringConfigPtrInput

type ManagedZonePeeringConfigPtrOutput 

type ManagedZonePeeringConfigPtrOutput struct{ *pulumi.OutputState }

func (ManagedZonePeeringConfigPtrOutput) Elem 

func (o ManagedZonePeeringConfigPtrOutput) Elem() ManagedZonePeeringConfigOutput

func (ManagedZonePeeringConfigPtrOutput) ElementType 

func (ManagedZonePeeringConfigPtrOutput) ElementType() reflect.Type

func (ManagedZonePeeringConfigPtrOutput) TargetNetwork 

func (o ManagedZonePeeringConfigPtrOutput) TargetNetwork() ManagedZonePeeringConfigTargetNetworkPtrOutput

The network with which to peer. Structure is documented below.

func (ManagedZonePeeringConfigPtrOutput) ToManagedZonePeeringConfigPtrOutput 

func (o ManagedZonePeeringConfigPtrOutput) ToManagedZonePeeringConfigPtrOutput() ManagedZonePeeringConfigPtrOutput

func (ManagedZonePeeringConfigPtrOutput) ToManagedZonePeeringConfigPtrOutputWithContext 

func (o ManagedZonePeeringConfigPtrOutput) ToManagedZonePeeringConfigPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigPtrOutput

type ManagedZonePeeringConfigTargetNetwork 

type ManagedZonePeeringConfigTargetNetwork struct {
	// The id or fully qualified URL of the VPC network to forward queries to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl string `pulumi:"networkUrl"`
}

type ManagedZonePeeringConfigTargetNetworkArgs 

type ManagedZonePeeringConfigTargetNetworkArgs struct {
	// The id or fully qualified URL of the VPC network to forward queries to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl pulumi.StringInput `pulumi:"networkUrl"`
}

func (ManagedZonePeeringConfigTargetNetworkArgs) ElementType 

func (ManagedZonePeeringConfigTargetNetworkArgs) ElementType() reflect.Type

func (ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkOutput 

func (i ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkOutput() ManagedZonePeeringConfigTargetNetworkOutput

func (ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkOutputWithContext 

func (i ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkOutputWithContext(ctx context.Context) ManagedZonePeeringConfigTargetNetworkOutput

func (ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkPtrOutput 

func (i ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkPtrOutput() ManagedZonePeeringConfigTargetNetworkPtrOutput

func (ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext 

func (i ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigTargetNetworkPtrOutput

type ManagedZonePeeringConfigTargetNetworkInput 

type ManagedZonePeeringConfigTargetNetworkInput interface {
	pulumi.Input

	ToManagedZonePeeringConfigTargetNetworkOutput() ManagedZonePeeringConfigTargetNetworkOutput
	ToManagedZonePeeringConfigTargetNetworkOutputWithContext(context.Context) ManagedZonePeeringConfigTargetNetworkOutput
}

ManagedZonePeeringConfigTargetNetworkInput is an input type that accepts ManagedZonePeeringConfigTargetNetworkArgs and ManagedZonePeeringConfigTargetNetworkOutput values. You can construct a concrete instance of `ManagedZonePeeringConfigTargetNetworkInput` via: 

ManagedZonePeeringConfigTargetNetworkArgs{...}

type ManagedZonePeeringConfigTargetNetworkOutput 

type ManagedZonePeeringConfigTargetNetworkOutput struct{ *pulumi.OutputState }

func (ManagedZonePeeringConfigTargetNetworkOutput) ElementType 

func (ManagedZonePeeringConfigTargetNetworkOutput) ElementType() reflect.Type

func (ManagedZonePeeringConfigTargetNetworkOutput) NetworkUrl 

func (o ManagedZonePeeringConfigTargetNetworkOutput) NetworkUrl() pulumi.StringOutput

The id or fully qualified URL of the VPC network to forward queries to. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`

func (ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkOutput 

func (o ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkOutput() ManagedZonePeeringConfigTargetNetworkOutput

func (ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkOutputWithContext 

func (o ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkOutputWithContext(ctx context.Context) ManagedZonePeeringConfigTargetNetworkOutput

func (ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutput 

func (o ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutput() ManagedZonePeeringConfigTargetNetworkPtrOutput

func (ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext 

func (o ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigTargetNetworkPtrOutput

type ManagedZonePeeringConfigTargetNetworkPtrInput 

type ManagedZonePeeringConfigTargetNetworkPtrInput interface {
	pulumi.Input

	ToManagedZonePeeringConfigTargetNetworkPtrOutput() ManagedZonePeeringConfigTargetNetworkPtrOutput
	ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(context.Context) ManagedZonePeeringConfigTargetNetworkPtrOutput
}

ManagedZonePeeringConfigTargetNetworkPtrInput is an input type that accepts ManagedZonePeeringConfigTargetNetworkArgs, ManagedZonePeeringConfigTargetNetworkPtr and ManagedZonePeeringConfigTargetNetworkPtrOutput values. You can construct a concrete instance of `ManagedZonePeeringConfigTargetNetworkPtrInput` via: 

        ManagedZonePeeringConfigTargetNetworkArgs{...}

or:

        nil

func ManagedZonePeeringConfigTargetNetworkPtr 

func ManagedZonePeeringConfigTargetNetworkPtr(v *ManagedZonePeeringConfigTargetNetworkArgs) ManagedZonePeeringConfigTargetNetworkPtrInput

type ManagedZonePeeringConfigTargetNetworkPtrOutput 

type ManagedZonePeeringConfigTargetNetworkPtrOutput struct{ *pulumi.OutputState }

func (ManagedZonePeeringConfigTargetNetworkPtrOutput) Elem 

func (o ManagedZonePeeringConfigTargetNetworkPtrOutput) Elem() ManagedZonePeeringConfigTargetNetworkOutput

func (ManagedZonePeeringConfigTargetNetworkPtrOutput) ElementType 

func (ManagedZonePeeringConfigTargetNetworkPtrOutput) ElementType() reflect.Type

func (ManagedZonePeeringConfigTargetNetworkPtrOutput) NetworkUrl 

func (o ManagedZonePeeringConfigTargetNetworkPtrOutput) NetworkUrl() pulumi.StringPtrOutput

The id or fully qualified URL of the VPC network to forward queries to. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`

func (ManagedZonePeeringConfigTargetNetworkPtrOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutput 

func (o ManagedZonePeeringConfigTargetNetworkPtrOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutput() ManagedZonePeeringConfigTargetNetworkPtrOutput

func (ManagedZonePeeringConfigTargetNetworkPtrOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext 

func (o ManagedZonePeeringConfigTargetNetworkPtrOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigTargetNetworkPtrOutput

type ManagedZonePrivateVisibilityConfig 

type ManagedZonePrivateVisibilityConfig struct {
	// The list of VPC networks that can see this zone. Structure is documented below.
	Networks []ManagedZonePrivateVisibilityConfigNetwork `pulumi:"networks"`
}

type ManagedZonePrivateVisibilityConfigArgs 

type ManagedZonePrivateVisibilityConfigArgs struct {
	// The list of VPC networks that can see this zone. Structure is documented below.
	Networks ManagedZonePrivateVisibilityConfigNetworkArrayInput `pulumi:"networks"`
}

func (ManagedZonePrivateVisibilityConfigArgs) ElementType 

func (ManagedZonePrivateVisibilityConfigArgs) ElementType() reflect.Type

func (ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigOutput 

func (i ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigOutput() ManagedZonePrivateVisibilityConfigOutput

func (ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigOutputWithContext 

func (i ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigOutput

func (ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigPtrOutput 

func (i ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigPtrOutput() ManagedZonePrivateVisibilityConfigPtrOutput

func (ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigPtrOutputWithContext 

func (i ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigPtrOutput

type ManagedZonePrivateVisibilityConfigInput 

type ManagedZonePrivateVisibilityConfigInput interface {
	pulumi.Input

	ToManagedZonePrivateVisibilityConfigOutput() ManagedZonePrivateVisibilityConfigOutput
	ToManagedZonePrivateVisibilityConfigOutputWithContext(context.Context) ManagedZonePrivateVisibilityConfigOutput
}

ManagedZonePrivateVisibilityConfigInput is an input type that accepts ManagedZonePrivateVisibilityConfigArgs and ManagedZonePrivateVisibilityConfigOutput values. You can construct a concrete instance of `ManagedZonePrivateVisibilityConfigInput` via: 

ManagedZonePrivateVisibilityConfigArgs{...}

type ManagedZonePrivateVisibilityConfigNetwork 

type ManagedZonePrivateVisibilityConfigNetwork struct {
	// The id or fully qualified URL of the VPC network to forward queries to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl string `pulumi:"networkUrl"`
}

type ManagedZonePrivateVisibilityConfigNetworkArgs 

type ManagedZonePrivateVisibilityConfigNetworkArgs struct {
	// The id or fully qualified URL of the VPC network to forward queries to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl pulumi.StringInput `pulumi:"networkUrl"`
}

func (ManagedZonePrivateVisibilityConfigNetworkArgs) ElementType 

func (ManagedZonePrivateVisibilityConfigNetworkArgs) ElementType() reflect.Type

func (ManagedZonePrivateVisibilityConfigNetworkArgs) ToManagedZonePrivateVisibilityConfigNetworkOutput 

func (i ManagedZonePrivateVisibilityConfigNetworkArgs) ToManagedZonePrivateVisibilityConfigNetworkOutput() ManagedZonePrivateVisibilityConfigNetworkOutput

func (ManagedZonePrivateVisibilityConfigNetworkArgs) ToManagedZonePrivateVisibilityConfigNetworkOutputWithContext 

func (i ManagedZonePrivateVisibilityConfigNetworkArgs) ToManagedZonePrivateVisibilityConfigNetworkOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigNetworkOutput

type ManagedZonePrivateVisibilityConfigNetworkArray 

type ManagedZonePrivateVisibilityConfigNetworkArray []ManagedZonePrivateVisibilityConfigNetworkInput

func (ManagedZonePrivateVisibilityConfigNetworkArray) ElementType 

func (ManagedZonePrivateVisibilityConfigNetworkArray) ElementType() reflect.Type

func (ManagedZonePrivateVisibilityConfigNetworkArray) ToManagedZonePrivateVisibilityConfigNetworkArrayOutput 

func (i ManagedZonePrivateVisibilityConfigNetworkArray) ToManagedZonePrivateVisibilityConfigNetworkArrayOutput() ManagedZonePrivateVisibilityConfigNetworkArrayOutput

func (ManagedZonePrivateVisibilityConfigNetworkArray) ToManagedZonePrivateVisibilityConfigNetworkArrayOutputWithContext 

func (i ManagedZonePrivateVisibilityConfigNetworkArray) ToManagedZonePrivateVisibilityConfigNetworkArrayOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigNetworkArrayOutput

type ManagedZonePrivateVisibilityConfigNetworkArrayInput 

type ManagedZonePrivateVisibilityConfigNetworkArrayInput interface {
	pulumi.Input

	ToManagedZonePrivateVisibilityConfigNetworkArrayOutput() ManagedZonePrivateVisibilityConfigNetworkArrayOutput
	ToManagedZonePrivateVisibilityConfigNetworkArrayOutputWithContext(context.Context) ManagedZonePrivateVisibilityConfigNetworkArrayOutput
}

ManagedZonePrivateVisibilityConfigNetworkArrayInput is an input type that accepts ManagedZonePrivateVisibilityConfigNetworkArray and ManagedZonePrivateVisibilityConfigNetworkArrayOutput values. You can construct a concrete instance of `ManagedZonePrivateVisibilityConfigNetworkArrayInput` via: 

ManagedZonePrivateVisibilityConfigNetworkArray{ ManagedZonePrivateVisibilityConfigNetworkArgs{...} }

type ManagedZonePrivateVisibilityConfigNetworkArrayOutput 

type ManagedZonePrivateVisibilityConfigNetworkArrayOutput struct{ *pulumi.OutputState }

func (ManagedZonePrivateVisibilityConfigNetworkArrayOutput) ElementType 

func (ManagedZonePrivateVisibilityConfigNetworkArrayOutput) ElementType() reflect.Type

func (ManagedZonePrivateVisibilityConfigNetworkArrayOutput) Index 

func (o ManagedZonePrivateVisibilityConfigNetworkArrayOutput) Index(i pulumi.IntInput) ManagedZonePrivateVisibilityConfigNetworkOutput

func (ManagedZonePrivateVisibilityConfigNetworkArrayOutput) ToManagedZonePrivateVisibilityConfigNetworkArrayOutput 

func (o ManagedZonePrivateVisibilityConfigNetworkArrayOutput) ToManagedZonePrivateVisibilityConfigNetworkArrayOutput() ManagedZonePrivateVisibilityConfigNetworkArrayOutput

func (ManagedZonePrivateVisibilityConfigNetworkArrayOutput) ToManagedZonePrivateVisibilityConfigNetworkArrayOutputWithContext 

func (o ManagedZonePrivateVisibilityConfigNetworkArrayOutput) ToManagedZonePrivateVisibilityConfigNetworkArrayOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigNetworkArrayOutput

type ManagedZonePrivateVisibilityConfigNetworkInput 

type ManagedZonePrivateVisibilityConfigNetworkInput interface {
	pulumi.Input

	ToManagedZonePrivateVisibilityConfigNetworkOutput() ManagedZonePrivateVisibilityConfigNetworkOutput
	ToManagedZonePrivateVisibilityConfigNetworkOutputWithContext(context.Context) ManagedZonePrivateVisibilityConfigNetworkOutput
}

ManagedZonePrivateVisibilityConfigNetworkInput is an input type that accepts ManagedZonePrivateVisibilityConfigNetworkArgs and ManagedZonePrivateVisibilityConfigNetworkOutput values. You can construct a concrete instance of `ManagedZonePrivateVisibilityConfigNetworkInput` via: 

ManagedZonePrivateVisibilityConfigNetworkArgs{...}

type ManagedZonePrivateVisibilityConfigNetworkOutput 

type ManagedZonePrivateVisibilityConfigNetworkOutput struct{ *pulumi.OutputState }

func (ManagedZonePrivateVisibilityConfigNetworkOutput) ElementType 

func (ManagedZonePrivateVisibilityConfigNetworkOutput) ElementType() reflect.Type

func (ManagedZonePrivateVisibilityConfigNetworkOutput) NetworkUrl 

func (o ManagedZonePrivateVisibilityConfigNetworkOutput) NetworkUrl() pulumi.StringOutput

The id or fully qualified URL of the VPC network to forward queries to. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`

func (ManagedZonePrivateVisibilityConfigNetworkOutput) ToManagedZonePrivateVisibilityConfigNetworkOutput 

func (o ManagedZonePrivateVisibilityConfigNetworkOutput) ToManagedZonePrivateVisibilityConfigNetworkOutput() ManagedZonePrivateVisibilityConfigNetworkOutput

func (ManagedZonePrivateVisibilityConfigNetworkOutput) ToManagedZonePrivateVisibilityConfigNetworkOutputWithContext 

func (o ManagedZonePrivateVisibilityConfigNetworkOutput) ToManagedZonePrivateVisibilityConfigNetworkOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigNetworkOutput

type ManagedZonePrivateVisibilityConfigOutput 

type ManagedZonePrivateVisibilityConfigOutput struct{ *pulumi.OutputState }

func (ManagedZonePrivateVisibilityConfigOutput) ElementType 

func (ManagedZonePrivateVisibilityConfigOutput) ElementType() reflect.Type

func (ManagedZonePrivateVisibilityConfigOutput) Networks 

func (o ManagedZonePrivateVisibilityConfigOutput) Networks() ManagedZonePrivateVisibilityConfigNetworkArrayOutput

The list of VPC networks that can see this zone. Structure is documented below.

func (ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigOutput 

func (o ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigOutput() ManagedZonePrivateVisibilityConfigOutput

func (ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigOutputWithContext 

func (o ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigOutput

func (ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigPtrOutput 

func (o ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigPtrOutput() ManagedZonePrivateVisibilityConfigPtrOutput

func (ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigPtrOutputWithContext 

func (o ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigPtrOutput

type ManagedZonePrivateVisibilityConfigPtrInput 

type ManagedZonePrivateVisibilityConfigPtrInput interface {
	pulumi.Input

	ToManagedZonePrivateVisibilityConfigPtrOutput() ManagedZonePrivateVisibilityConfigPtrOutput
	ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(context.Context) ManagedZonePrivateVisibilityConfigPtrOutput
}

ManagedZonePrivateVisibilityConfigPtrInput is an input type that accepts ManagedZonePrivateVisibilityConfigArgs, ManagedZonePrivateVisibilityConfigPtr and ManagedZonePrivateVisibilityConfigPtrOutput values. You can construct a concrete instance of `ManagedZonePrivateVisibilityConfigPtrInput` via: 

        ManagedZonePrivateVisibilityConfigArgs{...}

or:

        nil

func ManagedZonePrivateVisibilityConfigPtr 

func ManagedZonePrivateVisibilityConfigPtr(v *ManagedZonePrivateVisibilityConfigArgs) ManagedZonePrivateVisibilityConfigPtrInput

type ManagedZonePrivateVisibilityConfigPtrOutput 

type ManagedZonePrivateVisibilityConfigPtrOutput struct{ *pulumi.OutputState }

func (ManagedZonePrivateVisibilityConfigPtrOutput) Elem 

func (o ManagedZonePrivateVisibilityConfigPtrOutput) Elem() ManagedZonePrivateVisibilityConfigOutput

func (ManagedZonePrivateVisibilityConfigPtrOutput) ElementType 

func (ManagedZonePrivateVisibilityConfigPtrOutput) ElementType() reflect.Type

func (ManagedZonePrivateVisibilityConfigPtrOutput) Networks 

func (o ManagedZonePrivateVisibilityConfigPtrOutput) Networks() ManagedZonePrivateVisibilityConfigNetworkArrayOutput

The list of VPC networks that can see this zone. Structure is documented below.

func (ManagedZonePrivateVisibilityConfigPtrOutput) ToManagedZonePrivateVisibilityConfigPtrOutput 

func (o ManagedZonePrivateVisibilityConfigPtrOutput) ToManagedZonePrivateVisibilityConfigPtrOutput() ManagedZonePrivateVisibilityConfigPtrOutput

func (ManagedZonePrivateVisibilityConfigPtrOutput) ToManagedZonePrivateVisibilityConfigPtrOutputWithContext 

func (o ManagedZonePrivateVisibilityConfigPtrOutput) ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigPtrOutput

type ManagedZonePtrInput added in v4.11.1 

type ManagedZonePtrInput interface {
	pulumi.Input

	ToManagedZonePtrOutput() ManagedZonePtrOutput
	ToManagedZonePtrOutputWithContext(ctx context.Context) ManagedZonePtrOutput
}

type ManagedZonePtrOutput added in v4.11.1 

type ManagedZonePtrOutput struct {
	*pulumi.OutputState
}

func (ManagedZonePtrOutput) ElementType added in v4.11.1 

func (ManagedZonePtrOutput) ElementType() reflect.Type

func (ManagedZonePtrOutput) ToManagedZonePtrOutput added in v4.11.1 

func (o ManagedZonePtrOutput) ToManagedZonePtrOutput() ManagedZonePtrOutput

func (ManagedZonePtrOutput) ToManagedZonePtrOutputWithContext added in v4.11.1 

func (o ManagedZonePtrOutput) ToManagedZonePtrOutputWithContext(ctx context.Context) ManagedZonePtrOutput

type ManagedZoneServiceDirectoryConfig 

type ManagedZoneServiceDirectoryConfig struct {
	// The namespace associated with the zone.
	// Structure is documented below.
	Namespace ManagedZoneServiceDirectoryConfigNamespace `pulumi:"namespace"`
}

type ManagedZoneServiceDirectoryConfigArgs 

type ManagedZoneServiceDirectoryConfigArgs struct {
	// The namespace associated with the zone.
	// Structure is documented below.
	Namespace ManagedZoneServiceDirectoryConfigNamespaceInput `pulumi:"namespace"`
}

func (ManagedZoneServiceDirectoryConfigArgs) ElementType 

func (ManagedZoneServiceDirectoryConfigArgs) ElementType() reflect.Type

func (ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigOutput 

func (i ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigOutput() ManagedZoneServiceDirectoryConfigOutput

func (ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigOutputWithContext 

func (i ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigOutput

func (ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigPtrOutput 

func (i ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigPtrOutput() ManagedZoneServiceDirectoryConfigPtrOutput

func (ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigPtrOutputWithContext 

func (i ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigPtrOutput

type ManagedZoneServiceDirectoryConfigInput 

type ManagedZoneServiceDirectoryConfigInput interface {
	pulumi.Input

	ToManagedZoneServiceDirectoryConfigOutput() ManagedZoneServiceDirectoryConfigOutput
	ToManagedZoneServiceDirectoryConfigOutputWithContext(context.Context) ManagedZoneServiceDirectoryConfigOutput
}

ManagedZoneServiceDirectoryConfigInput is an input type that accepts ManagedZoneServiceDirectoryConfigArgs and ManagedZoneServiceDirectoryConfigOutput values. You can construct a concrete instance of `ManagedZoneServiceDirectoryConfigInput` via: 

ManagedZoneServiceDirectoryConfigArgs{...}

type ManagedZoneServiceDirectoryConfigNamespace 

type ManagedZoneServiceDirectoryConfigNamespace struct {
	// The fully qualified or partial URL of the service directory namespace that should be
	// associated with the zone. This should be formatted like
	// `https://servicedirectory.googleapis.com/v1/projects/{project}/locations/{location}/namespaces/{namespace_id}`
	// or simply `projects/{project}/locations/{location}/namespaces/{namespace_id}`
	// Ignored for `public` visibility zones.
	NamespaceUrl string `pulumi:"namespaceUrl"`
}

type ManagedZoneServiceDirectoryConfigNamespaceArgs 

type ManagedZoneServiceDirectoryConfigNamespaceArgs struct {
	// The fully qualified or partial URL of the service directory namespace that should be
	// associated with the zone. This should be formatted like
	// `https://servicedirectory.googleapis.com/v1/projects/{project}/locations/{location}/namespaces/{namespace_id}`
	// or simply `projects/{project}/locations/{location}/namespaces/{namespace_id}`
	// Ignored for `public` visibility zones.
	NamespaceUrl pulumi.StringInput `pulumi:"namespaceUrl"`
}

func (ManagedZoneServiceDirectoryConfigNamespaceArgs) ElementType 

func (ManagedZoneServiceDirectoryConfigNamespaceArgs) ElementType() reflect.Type

func (ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespaceOutput 

func (i ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespaceOutput() ManagedZoneServiceDirectoryConfigNamespaceOutput

func (ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespaceOutputWithContext 

func (i ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespaceOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigNamespaceOutput

func (ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespacePtrOutput 

func (i ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespacePtrOutput() ManagedZoneServiceDirectoryConfigNamespacePtrOutput

func (ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext 

func (i ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigNamespacePtrOutput

type ManagedZoneServiceDirectoryConfigNamespaceInput 

type ManagedZoneServiceDirectoryConfigNamespaceInput interface {
	pulumi.Input

	ToManagedZoneServiceDirectoryConfigNamespaceOutput() ManagedZoneServiceDirectoryConfigNamespaceOutput
	ToManagedZoneServiceDirectoryConfigNamespaceOutputWithContext(context.Context) ManagedZoneServiceDirectoryConfigNamespaceOutput
}

ManagedZoneServiceDirectoryConfigNamespaceInput is an input type that accepts ManagedZoneServiceDirectoryConfigNamespaceArgs and ManagedZoneServiceDirectoryConfigNamespaceOutput values. You can construct a concrete instance of `ManagedZoneServiceDirectoryConfigNamespaceInput` via: 

ManagedZoneServiceDirectoryConfigNamespaceArgs{...}

type ManagedZoneServiceDirectoryConfigNamespaceOutput 

type ManagedZoneServiceDirectoryConfigNamespaceOutput struct{ *pulumi.OutputState }

func (ManagedZoneServiceDirectoryConfigNamespaceOutput) ElementType 

func (ManagedZoneServiceDirectoryConfigNamespaceOutput) ElementType() reflect.Type

func (ManagedZoneServiceDirectoryConfigNamespaceOutput) NamespaceUrl 

func (o ManagedZoneServiceDirectoryConfigNamespaceOutput) NamespaceUrl() pulumi.StringOutput

The fully qualified or partial URL of the service directory namespace that should be associated with the zone. This should be formatted like `https://servicedirectory.googleapis.com/v1/projects/{project}/locations/{location}/namespaces/{namespace_id}` or simply `projects/{project}/locations/{location}/namespaces/{namespace_id}` Ignored for `public` visibility zones.

func (ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespaceOutput 

func (o ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespaceOutput() ManagedZoneServiceDirectoryConfigNamespaceOutput

func (ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespaceOutputWithContext 

func (o ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespaceOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigNamespaceOutput

func (ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutput 

func (o ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutput() ManagedZoneServiceDirectoryConfigNamespacePtrOutput

func (ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext 

func (o ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigNamespacePtrOutput

type ManagedZoneServiceDirectoryConfigNamespacePtrInput 

type ManagedZoneServiceDirectoryConfigNamespacePtrInput interface {
	pulumi.Input

	ToManagedZoneServiceDirectoryConfigNamespacePtrOutput() ManagedZoneServiceDirectoryConfigNamespacePtrOutput
	ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(context.Context) ManagedZoneServiceDirectoryConfigNamespacePtrOutput
}

ManagedZoneServiceDirectoryConfigNamespacePtrInput is an input type that accepts ManagedZoneServiceDirectoryConfigNamespaceArgs, ManagedZoneServiceDirectoryConfigNamespacePtr and ManagedZoneServiceDirectoryConfigNamespacePtrOutput values. You can construct a concrete instance of `ManagedZoneServiceDirectoryConfigNamespacePtrInput` via: 

        ManagedZoneServiceDirectoryConfigNamespaceArgs{...}

or:

        nil

func ManagedZoneServiceDirectoryConfigNamespacePtr 

func ManagedZoneServiceDirectoryConfigNamespacePtr(v *ManagedZoneServiceDirectoryConfigNamespaceArgs) ManagedZoneServiceDirectoryConfigNamespacePtrInput

type ManagedZoneServiceDirectoryConfigNamespacePtrOutput 

type ManagedZoneServiceDirectoryConfigNamespacePtrOutput struct{ *pulumi.OutputState }

func (ManagedZoneServiceDirectoryConfigNamespacePtrOutput) Elem 

func (o ManagedZoneServiceDirectoryConfigNamespacePtrOutput) Elem() ManagedZoneServiceDirectoryConfigNamespaceOutput

func (ManagedZoneServiceDirectoryConfigNamespacePtrOutput) ElementType 

func (ManagedZoneServiceDirectoryConfigNamespacePtrOutput) ElementType() reflect.Type

func (ManagedZoneServiceDirectoryConfigNamespacePtrOutput) NamespaceUrl 

func (o ManagedZoneServiceDirectoryConfigNamespacePtrOutput) NamespaceUrl() pulumi.StringPtrOutput

The fully qualified or partial URL of the service directory namespace that should be associated with the zone. This should be formatted like `https://servicedirectory.googleapis.com/v1/projects/{project}/locations/{location}/namespaces/{namespace_id}` or simply `projects/{project}/locations/{location}/namespaces/{namespace_id}` Ignored for `public` visibility zones.

func (ManagedZoneServiceDirectoryConfigNamespacePtrOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutput 

func (o ManagedZoneServiceDirectoryConfigNamespacePtrOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutput() ManagedZoneServiceDirectoryConfigNamespacePtrOutput

func (ManagedZoneServiceDirectoryConfigNamespacePtrOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext 

func (o ManagedZoneServiceDirectoryConfigNamespacePtrOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigNamespacePtrOutput

type ManagedZoneServiceDirectoryConfigOutput 

type ManagedZoneServiceDirectoryConfigOutput struct{ *pulumi.OutputState }

func (ManagedZoneServiceDirectoryConfigOutput) ElementType 

func (ManagedZoneServiceDirectoryConfigOutput) ElementType() reflect.Type

func (ManagedZoneServiceDirectoryConfigOutput) Namespace 

func (o ManagedZoneServiceDirectoryConfigOutput) Namespace() ManagedZoneServiceDirectoryConfigNamespaceOutput

The namespace associated with the zone. Structure is documented below.

func (ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigOutput 

func (o ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigOutput() ManagedZoneServiceDirectoryConfigOutput

func (ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigOutputWithContext 

func (o ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigOutput

func (ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigPtrOutput 

func (o ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigPtrOutput() ManagedZoneServiceDirectoryConfigPtrOutput

func (ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigPtrOutputWithContext 

func (o ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigPtrOutput

type ManagedZoneServiceDirectoryConfigPtrInput 

type ManagedZoneServiceDirectoryConfigPtrInput interface {
	pulumi.Input

	ToManagedZoneServiceDirectoryConfigPtrOutput() ManagedZoneServiceDirectoryConfigPtrOutput
	ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(context.Context) ManagedZoneServiceDirectoryConfigPtrOutput
}

ManagedZoneServiceDirectoryConfigPtrInput is an input type that accepts ManagedZoneServiceDirectoryConfigArgs, ManagedZoneServiceDirectoryConfigPtr and ManagedZoneServiceDirectoryConfigPtrOutput values. You can construct a concrete instance of `ManagedZoneServiceDirectoryConfigPtrInput` via: 

        ManagedZoneServiceDirectoryConfigArgs{...}

or:

        nil

func ManagedZoneServiceDirectoryConfigPtr 

func ManagedZoneServiceDirectoryConfigPtr(v *ManagedZoneServiceDirectoryConfigArgs) ManagedZoneServiceDirectoryConfigPtrInput

type ManagedZoneServiceDirectoryConfigPtrOutput 

type ManagedZoneServiceDirectoryConfigPtrOutput struct{ *pulumi.OutputState }

func (ManagedZoneServiceDirectoryConfigPtrOutput) Elem 

func (o ManagedZoneServiceDirectoryConfigPtrOutput) Elem() ManagedZoneServiceDirectoryConfigOutput

func (ManagedZoneServiceDirectoryConfigPtrOutput) ElementType 

func (ManagedZoneServiceDirectoryConfigPtrOutput) ElementType() reflect.Type

func (ManagedZoneServiceDirectoryConfigPtrOutput) Namespace 

func (o ManagedZoneServiceDirectoryConfigPtrOutput) Namespace() ManagedZoneServiceDirectoryConfigNamespacePtrOutput

The namespace associated with the zone. Structure is documented below.

func (ManagedZoneServiceDirectoryConfigPtrOutput) ToManagedZoneServiceDirectoryConfigPtrOutput 

func (o ManagedZoneServiceDirectoryConfigPtrOutput) ToManagedZoneServiceDirectoryConfigPtrOutput() ManagedZoneServiceDirectoryConfigPtrOutput

func (ManagedZoneServiceDirectoryConfigPtrOutput) ToManagedZoneServiceDirectoryConfigPtrOutputWithContext 

func (o ManagedZoneServiceDirectoryConfigPtrOutput) ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigPtrOutput

type ManagedZoneState 

type ManagedZoneState struct {
	// A textual description field. Defaults to 'Managed by Pulumi'.
	Description pulumi.StringPtrInput
	// The DNS name of this managed zone, for instance "example.com.".
	DnsName pulumi.StringPtrInput
	// DNSSEC configuration
	// Structure is documented below.
	DnssecConfig ManagedZoneDnssecConfigPtrInput
	// Set this true to delete all records in the zone.
	ForceDestroy pulumi.BoolPtrInput
	// The presence for this field indicates that outbound forwarding is enabled
	// for this zone. The value of this field contains the set of destinations
	// to forward to.
	// Structure is documented below.
	ForwardingConfig ManagedZoneForwardingConfigPtrInput
	// A set of key/value label pairs to assign to this ManagedZone.
	Labels pulumi.StringMapInput
	// User assigned name for this resource.
	// Must be unique within the project.
	Name pulumi.StringPtrInput
	// Delegate your managed_zone to these virtual name servers; defined by the server
	NameServers pulumi.StringArrayInput
	// The presence of this field indicates that DNS Peering is enabled for this
	// zone. The value of this field contains the network to peer with.
	// Structure is documented below.
	PeeringConfig ManagedZonePeeringConfigPtrInput
	// For privately visible zones, the set of Virtual Private Cloud
	// resources that the zone is visible from.
	// Structure is documented below.
	PrivateVisibilityConfig ManagedZonePrivateVisibilityConfigPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// Specifies if this is a managed reverse lookup zone. If true, Cloud DNS will resolve reverse
	// lookup queries using automatically configured records for VPC resources. This only applies
	// to networks listed under `privateVisibilityConfig`.
	ReverseLookup pulumi.BoolPtrInput
	// The presence of this field indicates that this zone is backed by Service Directory. The value of this field contains information related to the namespace associated with the zone.  Structure is documented below.
	ServiceDirectoryConfig ManagedZoneServiceDirectoryConfigPtrInput
	// The zone's visibility: public zones are exposed to the Internet,
	// while private zones are visible only to Virtual Private Cloud resources.
	// Default value is `public`.
	// Possible values are `private` and `public`.
	Visibility pulumi.StringPtrInput
}

func (ManagedZoneState) ElementType 

func (ManagedZoneState) ElementType() reflect.Type

type Policy 

type Policy struct {
	pulumi.CustomResourceState

	// Sets an alternative name server for the associated networks.
	// When specified, all DNS queries are forwarded to a name server that you choose.
	// Names such as .internal are not available when an alternative name server is specified.
	// Structure is documented below.
	AlternativeNameServerConfig PolicyAlternativeNameServerConfigPtrOutput `pulumi:"alternativeNameServerConfig"`
	// A textual description field. Defaults to 'Managed by Pulumi'.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Allows networks bound to this policy to receive DNS queries sent
	// by VMs or applications over VPN connections. When enabled, a
	// virtual IP address will be allocated from each of the sub-networks
	// that are bound to this policy.
	EnableInboundForwarding pulumi.BoolPtrOutput `pulumi:"enableInboundForwarding"`
	// Controls whether logging is enabled for the networks bound to this policy.
	// Defaults to no logging if not set.
	EnableLogging pulumi.BoolPtrOutput `pulumi:"enableLogging"`
	// User assigned name for this policy.
	Name pulumi.StringOutput `pulumi:"name"`
	// List of network names specifying networks to which this policy is applied.
	// Structure is documented below.
	Networks PolicyNetworkArrayOutput `pulumi:"networks"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
}

A policy is a collection of DNS rules applied to one or more Virtual Private Cloud resources.

To get more information about Policy, see:

* [API documentation](https://cloud.google.com/dns/docs/reference/v1beta2/policies) * How-to Guides

## Example Usage ### Dns Policy Basic

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/compute"
"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "network_1", &compute.NetworkArgs{
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewNetwork(ctx, "network_2", &compute.NetworkArgs{
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		_, err = dns.NewPolicy(ctx, "example_policy", &dns.PolicyArgs{
			EnableInboundForwarding: pulumi.Bool(true),
			EnableLogging:           pulumi.Bool(true),
			AlternativeNameServerConfig: &dns.PolicyAlternativeNameServerConfigArgs{
				TargetNameServers: dns.PolicyAlternativeNameServerConfigTargetNameServerArray{
					&dns.PolicyAlternativeNameServerConfigTargetNameServerArgs{
						Ipv4Address:    pulumi.String("172.16.1.10"),
						ForwardingPath: pulumi.String("private"),
					},
					&dns.PolicyAlternativeNameServerConfigTargetNameServerArgs{
						Ipv4Address: pulumi.String("172.16.1.20"),
					},
				},
			},
			Networks: dns.PolicyNetworkArray{
				&dns.PolicyNetworkArgs{
					NetworkUrl: network_1.ID(),
				},
				&dns.PolicyNetworkArgs{
					NetworkUrl: network_2.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Policy can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:dns/policy:Policy default projects/{{project}}/policies/{{name}}

```

```sh 

$ pulumi import gcp:dns/policy:Policy default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:dns/policy:Policy default {{name}}

```

func GetPolicy 

func GetPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *PolicyState, opts ...pulumi.ResourceOption) (*Policy, error)

GetPolicy gets an existing Policy 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 NewPolicy 

func NewPolicy(ctx *pulumi.Context,
	name string, args *PolicyArgs, opts ...pulumi.ResourceOption) (*Policy, error)

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

func (*Policy) ElementType added in v4.4.0 

func (*Policy) ElementType() reflect.Type

func (*Policy) ToPolicyOutput added in v4.4.0 

func (i *Policy) ToPolicyOutput() PolicyOutput

func (*Policy) ToPolicyOutputWithContext added in v4.4.0 

func (i *Policy) ToPolicyOutputWithContext(ctx context.Context) PolicyOutput

func (*Policy) ToPolicyPtrOutput added in v4.11.1 

func (i *Policy) ToPolicyPtrOutput() PolicyPtrOutput

func (*Policy) ToPolicyPtrOutputWithContext added in v4.11.1 

func (i *Policy) ToPolicyPtrOutputWithContext(ctx context.Context) PolicyPtrOutput

type PolicyAlternativeNameServerConfig 

type PolicyAlternativeNameServerConfig struct {
	// Sets an alternative name server for the associated networks. When specified,
	// all DNS queries are forwarded to a name server that you choose. Names such as .internal
	// are not available when an alternative name server is specified.
	// Structure is documented below.
	TargetNameServers []PolicyAlternativeNameServerConfigTargetNameServer `pulumi:"targetNameServers"`
}

type PolicyAlternativeNameServerConfigArgs 

type PolicyAlternativeNameServerConfigArgs struct {
	// Sets an alternative name server for the associated networks. When specified,
	// all DNS queries are forwarded to a name server that you choose. Names such as .internal
	// are not available when an alternative name server is specified.
	// Structure is documented below.
	TargetNameServers PolicyAlternativeNameServerConfigTargetNameServerArrayInput `pulumi:"targetNameServers"`
}

func (PolicyAlternativeNameServerConfigArgs) ElementType 

func (PolicyAlternativeNameServerConfigArgs) ElementType() reflect.Type

func (PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigOutput 

func (i PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigOutput() PolicyAlternativeNameServerConfigOutput

func (PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigOutputWithContext 

func (i PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigOutput

func (PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigPtrOutput 

func (i PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigPtrOutput() PolicyAlternativeNameServerConfigPtrOutput

func (PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigPtrOutputWithContext 

func (i PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigPtrOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigPtrOutput

type PolicyAlternativeNameServerConfigInput 

type PolicyAlternativeNameServerConfigInput interface {
	pulumi.Input

	ToPolicyAlternativeNameServerConfigOutput() PolicyAlternativeNameServerConfigOutput
	ToPolicyAlternativeNameServerConfigOutputWithContext(context.Context) PolicyAlternativeNameServerConfigOutput
}

PolicyAlternativeNameServerConfigInput is an input type that accepts PolicyAlternativeNameServerConfigArgs and PolicyAlternativeNameServerConfigOutput values. You can construct a concrete instance of `PolicyAlternativeNameServerConfigInput` via: 

PolicyAlternativeNameServerConfigArgs{...}

type PolicyAlternativeNameServerConfigOutput 

type PolicyAlternativeNameServerConfigOutput struct{ *pulumi.OutputState }

func (PolicyAlternativeNameServerConfigOutput) ElementType 

func (PolicyAlternativeNameServerConfigOutput) ElementType() reflect.Type

func (PolicyAlternativeNameServerConfigOutput) TargetNameServers 

func (o PolicyAlternativeNameServerConfigOutput) TargetNameServers() PolicyAlternativeNameServerConfigTargetNameServerArrayOutput

Sets an alternative name server for the associated networks. When specified, all DNS queries are forwarded to a name server that you choose. Names such as .internal are not available when an alternative name server is specified. Structure is documented below.

func (PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigOutput 

func (o PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigOutput() PolicyAlternativeNameServerConfigOutput

func (PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigOutputWithContext 

func (o PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigOutput

func (PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigPtrOutput 

func (o PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigPtrOutput() PolicyAlternativeNameServerConfigPtrOutput

func (PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigPtrOutputWithContext 

func (o PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigPtrOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigPtrOutput

type PolicyAlternativeNameServerConfigPtrInput 

type PolicyAlternativeNameServerConfigPtrInput interface {
	pulumi.Input

	ToPolicyAlternativeNameServerConfigPtrOutput() PolicyAlternativeNameServerConfigPtrOutput
	ToPolicyAlternativeNameServerConfigPtrOutputWithContext(context.Context) PolicyAlternativeNameServerConfigPtrOutput
}

PolicyAlternativeNameServerConfigPtrInput is an input type that accepts PolicyAlternativeNameServerConfigArgs, PolicyAlternativeNameServerConfigPtr and PolicyAlternativeNameServerConfigPtrOutput values. You can construct a concrete instance of `PolicyAlternativeNameServerConfigPtrInput` via: 

        PolicyAlternativeNameServerConfigArgs{...}

or:

        nil

func PolicyAlternativeNameServerConfigPtr 

func PolicyAlternativeNameServerConfigPtr(v *PolicyAlternativeNameServerConfigArgs) PolicyAlternativeNameServerConfigPtrInput

type PolicyAlternativeNameServerConfigPtrOutput 

type PolicyAlternativeNameServerConfigPtrOutput struct{ *pulumi.OutputState }

func (PolicyAlternativeNameServerConfigPtrOutput) Elem 

func (o PolicyAlternativeNameServerConfigPtrOutput) Elem() PolicyAlternativeNameServerConfigOutput

func (PolicyAlternativeNameServerConfigPtrOutput) ElementType 

func (PolicyAlternativeNameServerConfigPtrOutput) ElementType() reflect.Type

func (PolicyAlternativeNameServerConfigPtrOutput) TargetNameServers 

func (o PolicyAlternativeNameServerConfigPtrOutput) TargetNameServers() PolicyAlternativeNameServerConfigTargetNameServerArrayOutput

Sets an alternative name server for the associated networks. When specified, all DNS queries are forwarded to a name server that you choose. Names such as .internal are not available when an alternative name server is specified. Structure is documented below.

func (PolicyAlternativeNameServerConfigPtrOutput) ToPolicyAlternativeNameServerConfigPtrOutput 

func (o PolicyAlternativeNameServerConfigPtrOutput) ToPolicyAlternativeNameServerConfigPtrOutput() PolicyAlternativeNameServerConfigPtrOutput

func (PolicyAlternativeNameServerConfigPtrOutput) ToPolicyAlternativeNameServerConfigPtrOutputWithContext 

func (o PolicyAlternativeNameServerConfigPtrOutput) ToPolicyAlternativeNameServerConfigPtrOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigPtrOutput

type PolicyAlternativeNameServerConfigTargetNameServer 

type PolicyAlternativeNameServerConfigTargetNameServer struct {
	// Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
	// decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
	// to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
	// Possible values are `default` and `private`.
	ForwardingPath *string `pulumi:"forwardingPath"`
	// IPv4 address to forward to.
	Ipv4Address string `pulumi:"ipv4Address"`
}

type PolicyAlternativeNameServerConfigTargetNameServerArgs 

type PolicyAlternativeNameServerConfigTargetNameServerArgs struct {
	// Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
	// decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
	// to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
	// Possible values are `default` and `private`.
	ForwardingPath pulumi.StringPtrInput `pulumi:"forwardingPath"`
	// IPv4 address to forward to.
	Ipv4Address pulumi.StringInput `pulumi:"ipv4Address"`
}

func (PolicyAlternativeNameServerConfigTargetNameServerArgs) ElementType 

func (PolicyAlternativeNameServerConfigTargetNameServerArgs) ElementType() reflect.Type

func (PolicyAlternativeNameServerConfigTargetNameServerArgs) ToPolicyAlternativeNameServerConfigTargetNameServerOutput 

func (i PolicyAlternativeNameServerConfigTargetNameServerArgs) ToPolicyAlternativeNameServerConfigTargetNameServerOutput() PolicyAlternativeNameServerConfigTargetNameServerOutput

func (PolicyAlternativeNameServerConfigTargetNameServerArgs) ToPolicyAlternativeNameServerConfigTargetNameServerOutputWithContext 

func (i PolicyAlternativeNameServerConfigTargetNameServerArgs) ToPolicyAlternativeNameServerConfigTargetNameServerOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigTargetNameServerOutput

type PolicyAlternativeNameServerConfigTargetNameServerArray 

type PolicyAlternativeNameServerConfigTargetNameServerArray []PolicyAlternativeNameServerConfigTargetNameServerInput

func (PolicyAlternativeNameServerConfigTargetNameServerArray) ElementType 

func (PolicyAlternativeNameServerConfigTargetNameServerArray) ElementType() reflect.Type

func (PolicyAlternativeNameServerConfigTargetNameServerArray) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutput 

func (i PolicyAlternativeNameServerConfigTargetNameServerArray) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutput() PolicyAlternativeNameServerConfigTargetNameServerArrayOutput

func (PolicyAlternativeNameServerConfigTargetNameServerArray) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutputWithContext 

func (i PolicyAlternativeNameServerConfigTargetNameServerArray) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigTargetNameServerArrayOutput

type PolicyAlternativeNameServerConfigTargetNameServerArrayInput 

type PolicyAlternativeNameServerConfigTargetNameServerArrayInput interface {
	pulumi.Input

	ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutput() PolicyAlternativeNameServerConfigTargetNameServerArrayOutput
	ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutputWithContext(context.Context) PolicyAlternativeNameServerConfigTargetNameServerArrayOutput
}

PolicyAlternativeNameServerConfigTargetNameServerArrayInput is an input type that accepts PolicyAlternativeNameServerConfigTargetNameServerArray and PolicyAlternativeNameServerConfigTargetNameServerArrayOutput values. You can construct a concrete instance of `PolicyAlternativeNameServerConfigTargetNameServerArrayInput` via: 

PolicyAlternativeNameServerConfigTargetNameServerArray{ PolicyAlternativeNameServerConfigTargetNameServerArgs{...} }

type PolicyAlternativeNameServerConfigTargetNameServerArrayOutput 

type PolicyAlternativeNameServerConfigTargetNameServerArrayOutput struct{ *pulumi.OutputState }

func (PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) ElementType 

func (PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) ElementType() reflect.Type

func (PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) Index 

func (o PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) Index(i pulumi.IntInput) PolicyAlternativeNameServerConfigTargetNameServerOutput

func (PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutput 

func (o PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutput() PolicyAlternativeNameServerConfigTargetNameServerArrayOutput

func (PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutputWithContext 

func (o PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigTargetNameServerArrayOutput

type PolicyAlternativeNameServerConfigTargetNameServerInput 

type PolicyAlternativeNameServerConfigTargetNameServerInput interface {
	pulumi.Input

	ToPolicyAlternativeNameServerConfigTargetNameServerOutput() PolicyAlternativeNameServerConfigTargetNameServerOutput
	ToPolicyAlternativeNameServerConfigTargetNameServerOutputWithContext(context.Context) PolicyAlternativeNameServerConfigTargetNameServerOutput
}

PolicyAlternativeNameServerConfigTargetNameServerInput is an input type that accepts PolicyAlternativeNameServerConfigTargetNameServerArgs and PolicyAlternativeNameServerConfigTargetNameServerOutput values. You can construct a concrete instance of `PolicyAlternativeNameServerConfigTargetNameServerInput` via: 

PolicyAlternativeNameServerConfigTargetNameServerArgs{...}

type PolicyAlternativeNameServerConfigTargetNameServerOutput 

type PolicyAlternativeNameServerConfigTargetNameServerOutput struct{ *pulumi.OutputState }

func (PolicyAlternativeNameServerConfigTargetNameServerOutput) ElementType 

func (PolicyAlternativeNameServerConfigTargetNameServerOutput) ElementType() reflect.Type

func (PolicyAlternativeNameServerConfigTargetNameServerOutput) ForwardingPath 

func (o PolicyAlternativeNameServerConfigTargetNameServerOutput) ForwardingPath() pulumi.StringPtrOutput

Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target Possible values are `default` and `private`.

func (PolicyAlternativeNameServerConfigTargetNameServerOutput) Ipv4Address 

func (o PolicyAlternativeNameServerConfigTargetNameServerOutput) Ipv4Address() pulumi.StringOutput

IPv4 address to forward to.

func (PolicyAlternativeNameServerConfigTargetNameServerOutput) ToPolicyAlternativeNameServerConfigTargetNameServerOutput 

func (o PolicyAlternativeNameServerConfigTargetNameServerOutput) ToPolicyAlternativeNameServerConfigTargetNameServerOutput() PolicyAlternativeNameServerConfigTargetNameServerOutput

func (PolicyAlternativeNameServerConfigTargetNameServerOutput) ToPolicyAlternativeNameServerConfigTargetNameServerOutputWithContext 

func (o PolicyAlternativeNameServerConfigTargetNameServerOutput) ToPolicyAlternativeNameServerConfigTargetNameServerOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigTargetNameServerOutput

type PolicyArgs 

type PolicyArgs struct {
	// Sets an alternative name server for the associated networks.
	// When specified, all DNS queries are forwarded to a name server that you choose.
	// Names such as .internal are not available when an alternative name server is specified.
	// Structure is documented below.
	AlternativeNameServerConfig PolicyAlternativeNameServerConfigPtrInput
	// A textual description field. Defaults to 'Managed by Pulumi'.
	Description pulumi.StringPtrInput
	// Allows networks bound to this policy to receive DNS queries sent
	// by VMs or applications over VPN connections. When enabled, a
	// virtual IP address will be allocated from each of the sub-networks
	// that are bound to this policy.
	EnableInboundForwarding pulumi.BoolPtrInput
	// Controls whether logging is enabled for the networks bound to this policy.
	// Defaults to no logging if not set.
	EnableLogging pulumi.BoolPtrInput
	// User assigned name for this policy.
	Name pulumi.StringPtrInput
	// List of network names specifying networks to which this policy is applied.
	// Structure is documented below.
	Networks PolicyNetworkArrayInput
	// 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 Policy resource.

func (PolicyArgs) ElementType 

func (PolicyArgs) ElementType() reflect.Type

type PolicyArray added in v4.11.1 

type PolicyArray []PolicyInput

func (PolicyArray) ElementType added in v4.11.1 

func (PolicyArray) ElementType() reflect.Type

func (PolicyArray) ToPolicyArrayOutput added in v4.11.1 

func (i PolicyArray) ToPolicyArrayOutput() PolicyArrayOutput

func (PolicyArray) ToPolicyArrayOutputWithContext added in v4.11.1 

func (i PolicyArray) ToPolicyArrayOutputWithContext(ctx context.Context) PolicyArrayOutput

type PolicyArrayInput added in v4.11.1 

type PolicyArrayInput interface {
	pulumi.Input

	ToPolicyArrayOutput() PolicyArrayOutput
	ToPolicyArrayOutputWithContext(context.Context) PolicyArrayOutput
}

PolicyArrayInput is an input type that accepts PolicyArray and PolicyArrayOutput values. You can construct a concrete instance of `PolicyArrayInput` via: 

PolicyArray{ PolicyArgs{...} }

type PolicyArrayOutput added in v4.11.1 

type PolicyArrayOutput struct{ *pulumi.OutputState }

func (PolicyArrayOutput) ElementType added in v4.11.1 

func (PolicyArrayOutput) ElementType() reflect.Type

func (PolicyArrayOutput) Index added in v4.11.1 

func (o PolicyArrayOutput) Index(i pulumi.IntInput) PolicyOutput

func (PolicyArrayOutput) ToPolicyArrayOutput added in v4.11.1 

func (o PolicyArrayOutput) ToPolicyArrayOutput() PolicyArrayOutput

func (PolicyArrayOutput) ToPolicyArrayOutputWithContext added in v4.11.1 

func (o PolicyArrayOutput) ToPolicyArrayOutputWithContext(ctx context.Context) PolicyArrayOutput

type PolicyInput added in v4.4.0 

type PolicyInput interface {
	pulumi.Input

	ToPolicyOutput() PolicyOutput
	ToPolicyOutputWithContext(ctx context.Context) PolicyOutput
}

type PolicyMap added in v4.11.1 

type PolicyMap map[string]PolicyInput

func (PolicyMap) ElementType added in v4.11.1 

func (PolicyMap) ElementType() reflect.Type

func (PolicyMap) ToPolicyMapOutput added in v4.11.1 

func (i PolicyMap) ToPolicyMapOutput() PolicyMapOutput

func (PolicyMap) ToPolicyMapOutputWithContext added in v4.11.1 

func (i PolicyMap) ToPolicyMapOutputWithContext(ctx context.Context) PolicyMapOutput

type PolicyMapInput added in v4.11.1 

type PolicyMapInput interface {
	pulumi.Input

	ToPolicyMapOutput() PolicyMapOutput
	ToPolicyMapOutputWithContext(context.Context) PolicyMapOutput
}

PolicyMapInput is an input type that accepts PolicyMap and PolicyMapOutput values. You can construct a concrete instance of `PolicyMapInput` via: 

PolicyMap{ "key": PolicyArgs{...} }

type PolicyMapOutput added in v4.11.1 

type PolicyMapOutput struct{ *pulumi.OutputState }

func (PolicyMapOutput) ElementType added in v4.11.1 

func (PolicyMapOutput) ElementType() reflect.Type

func (PolicyMapOutput) MapIndex added in v4.11.1 

func (o PolicyMapOutput) MapIndex(k pulumi.StringInput) PolicyOutput

func (PolicyMapOutput) ToPolicyMapOutput added in v4.11.1 

func (o PolicyMapOutput) ToPolicyMapOutput() PolicyMapOutput

func (PolicyMapOutput) ToPolicyMapOutputWithContext added in v4.11.1 

func (o PolicyMapOutput) ToPolicyMapOutputWithContext(ctx context.Context) PolicyMapOutput

type PolicyNetwork 

type PolicyNetwork struct {
	// The id or fully qualified URL of the VPC network to forward queries to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl string `pulumi:"networkUrl"`
}

type PolicyNetworkArgs 

type PolicyNetworkArgs struct {
	// The id or fully qualified URL of the VPC network to forward queries to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl pulumi.StringInput `pulumi:"networkUrl"`
}

func (PolicyNetworkArgs) ElementType 

func (PolicyNetworkArgs) ElementType() reflect.Type

func (PolicyNetworkArgs) ToPolicyNetworkOutput 

func (i PolicyNetworkArgs) ToPolicyNetworkOutput() PolicyNetworkOutput

func (PolicyNetworkArgs) ToPolicyNetworkOutputWithContext 

func (i PolicyNetworkArgs) ToPolicyNetworkOutputWithContext(ctx context.Context) PolicyNetworkOutput

type PolicyNetworkArray 

type PolicyNetworkArray []PolicyNetworkInput

func (PolicyNetworkArray) ElementType 

func (PolicyNetworkArray) ElementType() reflect.Type

func (PolicyNetworkArray) ToPolicyNetworkArrayOutput 

func (i PolicyNetworkArray) ToPolicyNetworkArrayOutput() PolicyNetworkArrayOutput

func (PolicyNetworkArray) ToPolicyNetworkArrayOutputWithContext 

func (i PolicyNetworkArray) ToPolicyNetworkArrayOutputWithContext(ctx context.Context) PolicyNetworkArrayOutput

type PolicyNetworkArrayInput 

type PolicyNetworkArrayInput interface {
	pulumi.Input

	ToPolicyNetworkArrayOutput() PolicyNetworkArrayOutput
	ToPolicyNetworkArrayOutputWithContext(context.Context) PolicyNetworkArrayOutput
}

PolicyNetworkArrayInput is an input type that accepts PolicyNetworkArray and PolicyNetworkArrayOutput values. You can construct a concrete instance of `PolicyNetworkArrayInput` via: 

PolicyNetworkArray{ PolicyNetworkArgs{...} }

type PolicyNetworkArrayOutput 

type PolicyNetworkArrayOutput struct{ *pulumi.OutputState }

func (PolicyNetworkArrayOutput) ElementType 

func (PolicyNetworkArrayOutput) ElementType() reflect.Type

func (PolicyNetworkArrayOutput) Index 

func (o PolicyNetworkArrayOutput) Index(i pulumi.IntInput) PolicyNetworkOutput

func (PolicyNetworkArrayOutput) ToPolicyNetworkArrayOutput 

func (o PolicyNetworkArrayOutput) ToPolicyNetworkArrayOutput() PolicyNetworkArrayOutput

func (PolicyNetworkArrayOutput) ToPolicyNetworkArrayOutputWithContext 

func (o PolicyNetworkArrayOutput) ToPolicyNetworkArrayOutputWithContext(ctx context.Context) PolicyNetworkArrayOutput

type PolicyNetworkInput 

type PolicyNetworkInput interface {
	pulumi.Input

	ToPolicyNetworkOutput() PolicyNetworkOutput
	ToPolicyNetworkOutputWithContext(context.Context) PolicyNetworkOutput
}

PolicyNetworkInput is an input type that accepts PolicyNetworkArgs and PolicyNetworkOutput values. You can construct a concrete instance of `PolicyNetworkInput` via: 

PolicyNetworkArgs{...}

type PolicyNetworkOutput 

type PolicyNetworkOutput struct{ *pulumi.OutputState }

func (PolicyNetworkOutput) ElementType 

func (PolicyNetworkOutput) ElementType() reflect.Type

func (PolicyNetworkOutput) NetworkUrl 

func (o PolicyNetworkOutput) NetworkUrl() pulumi.StringOutput

The id or fully qualified URL of the VPC network to forward queries to. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`

func (PolicyNetworkOutput) ToPolicyNetworkOutput 

func (o PolicyNetworkOutput) ToPolicyNetworkOutput() PolicyNetworkOutput

func (PolicyNetworkOutput) ToPolicyNetworkOutputWithContext 

func (o PolicyNetworkOutput) ToPolicyNetworkOutputWithContext(ctx context.Context) PolicyNetworkOutput

type PolicyOutput added in v4.4.0 

type PolicyOutput struct {
	*pulumi.OutputState
}

func (PolicyOutput) ElementType added in v4.4.0 

func (PolicyOutput) ElementType() reflect.Type

func (PolicyOutput) ToPolicyOutput added in v4.4.0 

func (o PolicyOutput) ToPolicyOutput() PolicyOutput

func (PolicyOutput) ToPolicyOutputWithContext added in v4.4.0 

func (o PolicyOutput) ToPolicyOutputWithContext(ctx context.Context) PolicyOutput

func (PolicyOutput) ToPolicyPtrOutput added in v4.11.1 

func (o PolicyOutput) ToPolicyPtrOutput() PolicyPtrOutput

func (PolicyOutput) ToPolicyPtrOutputWithContext added in v4.11.1 

func (o PolicyOutput) ToPolicyPtrOutputWithContext(ctx context.Context) PolicyPtrOutput

type PolicyPtrInput added in v4.11.1 

type PolicyPtrInput interface {
	pulumi.Input

	ToPolicyPtrOutput() PolicyPtrOutput
	ToPolicyPtrOutputWithContext(ctx context.Context) PolicyPtrOutput
}

type PolicyPtrOutput added in v4.11.1 

type PolicyPtrOutput struct {
	*pulumi.OutputState
}

func (PolicyPtrOutput) ElementType added in v4.11.1 

func (PolicyPtrOutput) ElementType() reflect.Type

func (PolicyPtrOutput) ToPolicyPtrOutput added in v4.11.1 

func (o PolicyPtrOutput) ToPolicyPtrOutput() PolicyPtrOutput

func (PolicyPtrOutput) ToPolicyPtrOutputWithContext added in v4.11.1 

func (o PolicyPtrOutput) ToPolicyPtrOutputWithContext(ctx context.Context) PolicyPtrOutput

type PolicyState 

type PolicyState struct {
	// Sets an alternative name server for the associated networks.
	// When specified, all DNS queries are forwarded to a name server that you choose.
	// Names such as .internal are not available when an alternative name server is specified.
	// Structure is documented below.
	AlternativeNameServerConfig PolicyAlternativeNameServerConfigPtrInput
	// A textual description field. Defaults to 'Managed by Pulumi'.
	Description pulumi.StringPtrInput
	// Allows networks bound to this policy to receive DNS queries sent
	// by VMs or applications over VPN connections. When enabled, a
	// virtual IP address will be allocated from each of the sub-networks
	// that are bound to this policy.
	EnableInboundForwarding pulumi.BoolPtrInput
	// Controls whether logging is enabled for the networks bound to this policy.
	// Defaults to no logging if not set.
	EnableLogging pulumi.BoolPtrInput
	// User assigned name for this policy.
	Name pulumi.StringPtrInput
	// List of network names specifying networks to which this policy is applied.
	// Structure is documented below.
	Networks PolicyNetworkArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

func (PolicyState) ElementType 

func (PolicyState) ElementType() reflect.Type

type RecordSet 

type RecordSet struct {
	pulumi.CustomResourceState

	// The name of the zone in which this record set will
	// reside.
	ManagedZone pulumi.StringOutput `pulumi:"managedZone"`
	// The DNS name this record set will apply to.
	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 string data for the records in this record set
	// whose meaning depends on the DNS type. For TXT record, if the string data contains spaces, add surrounding `\"` if you don't want your string to get split on spaces. To specify a single record value longer than 255 characters such as a TXT record for DKIM, add `\" \"` inside the provider configuration string (e.g. `"first255characters\" \"morecharacters"`).
	Rrdatas pulumi.StringArrayOutput `pulumi:"rrdatas"`
	// The time-to-live of this record set (seconds).
	Ttl pulumi.IntPtrOutput `pulumi:"ttl"`
	// The DNS record set type.
	Type pulumi.StringOutput `pulumi:"type"`
}

Manages a set of DNS records within Google Cloud DNS. For more information see [the official documentation](https://cloud.google.com/dns/records/) and [API](https://cloud.google.com/dns/api/v1/resourceRecordSets).

> **Note:** The provider treats this resource as an authoritative record set. This means existing records (including the default records) for the given type will be overwritten when you create this resource in the provider. In addition, the Google Cloud DNS API requires NS records to be present at all times, so the provider will not actually remove NS records during destroy but will report that it did.

## Example Usage ### Adding an A record

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		prod, err := dns.NewManagedZone(ctx, "prod", &dns.ManagedZoneArgs{
			DnsName: pulumi.String("prod.mydomain.com."),
		})
		if err != nil {
			return err
		}
		_, err = dns.NewRecordSet(ctx, "recordSet", &dns.RecordSetArgs{
			Name: prod.DnsName.ApplyT(func(dnsName string) (string, error) {
				return fmt.Sprintf("%v%v", "backend.", dnsName), nil
			}).(pulumi.StringOutput),
			ManagedZone: prod.Name,
			Type:        pulumi.String("A"),
			Ttl:         pulumi.Int(300),
			Rrdatas: pulumi.StringArray{
				pulumi.String("8.8.8.8"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Adding an MX record

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		prod, err := dns.NewManagedZone(ctx, "prod", &dns.ManagedZoneArgs{
			DnsName: pulumi.String("prod.mydomain.com."),
		})
		if err != nil {
			return err
		}
		_, err = dns.NewRecordSet(ctx, "mx", &dns.RecordSetArgs{
			Name:        prod.DnsName,
			ManagedZone: prod.Name,
			Type:        pulumi.String("MX"),
			Ttl:         pulumi.Int(3600),
			Rrdatas: pulumi.StringArray{
				pulumi.String("1 aspmx.l.google.com."),
				pulumi.String("5 alt1.aspmx.l.google.com."),
				pulumi.String("5 alt2.aspmx.l.google.com."),
				pulumi.String("10 alt3.aspmx.l.google.com."),
				pulumi.String("10 alt4.aspmx.l.google.com."),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Adding an SPF record

Quotes (`""`) must be added around your `rrdatas` for a SPF record. Otherwise `rrdatas` string gets split on spaces.

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		prod, err := dns.NewManagedZone(ctx, "prod", &dns.ManagedZoneArgs{
			DnsName: pulumi.String("prod.mydomain.com."),
		})
		if err != nil {
			return err
		}
		_, err = dns.NewRecordSet(ctx, "spf", &dns.RecordSetArgs{
			Name: prod.DnsName.ApplyT(func(dnsName string) (string, error) {
				return fmt.Sprintf("%v%v", "frontend.", dnsName), nil
			}).(pulumi.StringOutput),
			ManagedZone: prod.Name,
			Type:        pulumi.String("TXT"),
			Ttl:         pulumi.Int(300),
			Rrdatas: pulumi.StringArray{
				pulumi.String("\"v=spf1 ip4:111.111.111.111 include:backoff.email-example.com -all\""),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Adding a CNAME record 

The list of `rrdatas` should only contain a single string corresponding to the Canonical Name intended.

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-gcp/sdk/v4/go/gcp/dns"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		prod, err := dns.NewManagedZone(ctx, "prod", &dns.ManagedZoneArgs{
			DnsName: pulumi.String("prod.mydomain.com."),
		})
		if err != nil {
			return err
		}
		_, err = dns.NewRecordSet(ctx, "cname", &dns.RecordSetArgs{
			Name: prod.DnsName.ApplyT(func(dnsName string) (string, error) {
				return fmt.Sprintf("%v%v", "frontend.", dnsName), nil
			}).(pulumi.StringOutput),
			ManagedZone: prod.Name,
			Type:        pulumi.String("CNAME"),
			Ttl:         pulumi.Int(300),
			Rrdatas: pulumi.StringArray{
				pulumi.String("frontend.mydomain.com."),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

DNS record sets can be imported using either of these accepted formats

```sh 

$ pulumi import gcp:dns/recordSet:RecordSet frontend {{project}}/{{zone}}/{{name}}/{{type}}

```

```sh 

$ pulumi import gcp:dns/recordSet:RecordSet frontend {{zone}}/{{name}}/{{type}}

``` 

NoteThe record name must include the trailing dot at the end.

func GetRecordSet 

func GetRecordSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RecordSetState, opts ...pulumi.ResourceOption) (*RecordSet, error)

GetRecordSet gets an existing RecordSet 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 NewRecordSet 

func NewRecordSet(ctx *pulumi.Context,
	name string, args *RecordSetArgs, opts ...pulumi.ResourceOption) (*RecordSet, error)

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

func (*RecordSet) ElementType added in v4.4.0 

func (*RecordSet) ElementType() reflect.Type

func (*RecordSet) ToRecordSetOutput added in v4.4.0 

func (i *RecordSet) ToRecordSetOutput() RecordSetOutput

func (*RecordSet) ToRecordSetOutputWithContext added in v4.4.0 

func (i *RecordSet) ToRecordSetOutputWithContext(ctx context.Context) RecordSetOutput

func (*RecordSet) ToRecordSetPtrOutput added in v4.11.1 

func (i *RecordSet) ToRecordSetPtrOutput() RecordSetPtrOutput

func (*RecordSet) ToRecordSetPtrOutputWithContext added in v4.11.1 

func (i *RecordSet) ToRecordSetPtrOutputWithContext(ctx context.Context) RecordSetPtrOutput

type RecordSetArgs 

type RecordSetArgs struct {
	// The name of the zone in which this record set will
	// reside.
	ManagedZone pulumi.StringInput
	// The DNS name this record set will apply to.
	Name pulumi.StringInput
	// The ID of the project in which the resource belongs. If it
	// is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// The string data for the records in this record set
	// whose meaning depends on the DNS type. For TXT record, if the string data contains spaces, add surrounding `\"` if you don't want your string to get split on spaces. To specify a single record value longer than 255 characters such as a TXT record for DKIM, add `\" \"` inside the provider configuration string (e.g. `"first255characters\" \"morecharacters"`).
	Rrdatas pulumi.StringArrayInput
	// The time-to-live of this record set (seconds).
	Ttl pulumi.IntPtrInput
	// The DNS record set type.
	Type pulumi.StringInput
}

The set of arguments for constructing a RecordSet resource.

func (RecordSetArgs) ElementType 

func (RecordSetArgs) ElementType() reflect.Type

type RecordSetArray added in v4.11.1 

type RecordSetArray []RecordSetInput

func (RecordSetArray) ElementType added in v4.11.1 

func (RecordSetArray) ElementType() reflect.Type

func (RecordSetArray) ToRecordSetArrayOutput added in v4.11.1 

func (i RecordSetArray) ToRecordSetArrayOutput() RecordSetArrayOutput

func (RecordSetArray) ToRecordSetArrayOutputWithContext added in v4.11.1 

func (i RecordSetArray) ToRecordSetArrayOutputWithContext(ctx context.Context) RecordSetArrayOutput

type RecordSetArrayInput added in v4.11.1 

type RecordSetArrayInput interface {
	pulumi.Input

	ToRecordSetArrayOutput() RecordSetArrayOutput
	ToRecordSetArrayOutputWithContext(context.Context) RecordSetArrayOutput
}

RecordSetArrayInput is an input type that accepts RecordSetArray and RecordSetArrayOutput values. You can construct a concrete instance of `RecordSetArrayInput` via: 

RecordSetArray{ RecordSetArgs{...} }

type RecordSetArrayOutput added in v4.11.1 

type RecordSetArrayOutput struct{ *pulumi.OutputState }

func (RecordSetArrayOutput) ElementType added in v4.11.1 

func (RecordSetArrayOutput) ElementType() reflect.Type

func (RecordSetArrayOutput) Index added in v4.11.1 

func (o RecordSetArrayOutput) Index(i pulumi.IntInput) RecordSetOutput

func (RecordSetArrayOutput) ToRecordSetArrayOutput added in v4.11.1 

func (o RecordSetArrayOutput) ToRecordSetArrayOutput() RecordSetArrayOutput

func (RecordSetArrayOutput) ToRecordSetArrayOutputWithContext added in v4.11.1 

func (o RecordSetArrayOutput) ToRecordSetArrayOutputWithContext(ctx context.Context) RecordSetArrayOutput

type RecordSetInput added in v4.4.0 

type RecordSetInput interface {
	pulumi.Input

	ToRecordSetOutput() RecordSetOutput
	ToRecordSetOutputWithContext(ctx context.Context) RecordSetOutput
}

type RecordSetMap added in v4.11.1 

type RecordSetMap map[string]RecordSetInput

func (RecordSetMap) ElementType added in v4.11.1 

func (RecordSetMap) ElementType() reflect.Type

func (RecordSetMap) ToRecordSetMapOutput added in v4.11.1 

func (i RecordSetMap) ToRecordSetMapOutput() RecordSetMapOutput

func (RecordSetMap) ToRecordSetMapOutputWithContext added in v4.11.1 

func (i RecordSetMap) ToRecordSetMapOutputWithContext(ctx context.Context) RecordSetMapOutput

type RecordSetMapInput added in v4.11.1 

type RecordSetMapInput interface {
	pulumi.Input

	ToRecordSetMapOutput() RecordSetMapOutput
	ToRecordSetMapOutputWithContext(context.Context) RecordSetMapOutput
}

RecordSetMapInput is an input type that accepts RecordSetMap and RecordSetMapOutput values. You can construct a concrete instance of `RecordSetMapInput` via: 

RecordSetMap{ "key": RecordSetArgs{...} }

type RecordSetMapOutput added in v4.11.1 

type RecordSetMapOutput struct{ *pulumi.OutputState }

func (RecordSetMapOutput) ElementType added in v4.11.1 

func (RecordSetMapOutput) ElementType() reflect.Type

func (RecordSetMapOutput) MapIndex added in v4.11.1 

func (o RecordSetMapOutput) MapIndex(k pulumi.StringInput) RecordSetOutput

func (RecordSetMapOutput) ToRecordSetMapOutput added in v4.11.1 

func (o RecordSetMapOutput) ToRecordSetMapOutput() RecordSetMapOutput

func (RecordSetMapOutput) ToRecordSetMapOutputWithContext added in v4.11.1 

func (o RecordSetMapOutput) ToRecordSetMapOutputWithContext(ctx context.Context) RecordSetMapOutput

type RecordSetOutput added in v4.4.0 

type RecordSetOutput struct {
	*pulumi.OutputState
}

func (RecordSetOutput) ElementType added in v4.4.0 

func (RecordSetOutput) ElementType() reflect.Type

func (RecordSetOutput) ToRecordSetOutput added in v4.4.0 

func (o RecordSetOutput) ToRecordSetOutput() RecordSetOutput

func (RecordSetOutput) ToRecordSetOutputWithContext added in v4.4.0 

func (o RecordSetOutput) ToRecordSetOutputWithContext(ctx context.Context) RecordSetOutput

func (RecordSetOutput) ToRecordSetPtrOutput added in v4.11.1 

func (o RecordSetOutput) ToRecordSetPtrOutput() RecordSetPtrOutput

func (RecordSetOutput) ToRecordSetPtrOutputWithContext added in v4.11.1 

func (o RecordSetOutput) ToRecordSetPtrOutputWithContext(ctx context.Context) RecordSetPtrOutput

type RecordSetPtrInput added in v4.11.1 

type RecordSetPtrInput interface {
	pulumi.Input

	ToRecordSetPtrOutput() RecordSetPtrOutput
	ToRecordSetPtrOutputWithContext(ctx context.Context) RecordSetPtrOutput
}

type RecordSetPtrOutput added in v4.11.1 

type RecordSetPtrOutput struct {
	*pulumi.OutputState
}

func (RecordSetPtrOutput) ElementType added in v4.11.1 

func (RecordSetPtrOutput) ElementType() reflect.Type

func (RecordSetPtrOutput) ToRecordSetPtrOutput added in v4.11.1 

func (o RecordSetPtrOutput) ToRecordSetPtrOutput() RecordSetPtrOutput

func (RecordSetPtrOutput) ToRecordSetPtrOutputWithContext added in v4.11.1 

func (o RecordSetPtrOutput) ToRecordSetPtrOutputWithContext(ctx context.Context) RecordSetPtrOutput

type RecordSetState 

type RecordSetState struct {
	// The name of the zone in which this record set will
	// reside.
	ManagedZone pulumi.StringPtrInput
	// The DNS name this record set will apply to.
	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 string data for the records in this record set
	// whose meaning depends on the DNS type. For TXT record, if the string data contains spaces, add surrounding `\"` if you don't want your string to get split on spaces. To specify a single record value longer than 255 characters such as a TXT record for DKIM, add `\" \"` inside the provider configuration string (e.g. `"first255characters\" \"morecharacters"`).
	Rrdatas pulumi.StringArrayInput
	// The time-to-live of this record set (seconds).
	Ttl pulumi.IntPtrInput
	// The DNS record set type.
	Type pulumi.StringPtrInput
}

func (RecordSetState) ElementType 

func (RecordSetState) 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.