route53

package
v3.16.0 Latest Latest
Warning

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

 Go to latest Published: Nov 26, 2020 License: Apache-2.0 Imports: 4 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DelegationSet 

type DelegationSet struct {
	pulumi.CustomResourceState

	// A list of authoritative name servers for the hosted zone
	// (effectively a list of NS records).
	NameServers pulumi.StringArrayOutput `pulumi:"nameServers"`
	// This is a reference name used in Caller Reference
	// (helpful for identifying single delegation set amongst others)
	ReferenceName pulumi.StringPtrOutput `pulumi:"referenceName"`
}

Provides a [Route53 Delegation Set](https://docs.aws.amazon.com/Route53/latest/APIReference/API-actions-by-function.html#actions-by-function-reusable-delegation-sets) resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := route53.NewDelegationSet(ctx, "main", &route53.DelegationSetArgs{
			ReferenceName: pulumi.String("DynDNS"),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewZone(ctx, "primary", &route53.ZoneArgs{
			DelegationSetId: main.ID(),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewZone(ctx, "secondary", &route53.ZoneArgs{
			DelegationSetId: main.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Delegation Sets can be imported using the `delegation set id`, e.g.

```sh 

$ pulumi import aws:route53/delegationSet:DelegationSet set1 N1PA6795SAMPLE

```

func GetDelegationSet 

func GetDelegationSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DelegationSetState, opts ...pulumi.ResourceOption) (*DelegationSet, error)

GetDelegationSet gets an existing DelegationSet 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 NewDelegationSet 

func NewDelegationSet(ctx *pulumi.Context,
	name string, args *DelegationSetArgs, opts ...pulumi.ResourceOption) (*DelegationSet, error)

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

func (DelegationSet) ElementType added in v3.13.0 

func (DelegationSet) ElementType() reflect.Type

func (DelegationSet) ToDelegationSetOutput added in v3.13.0 

func (i DelegationSet) ToDelegationSetOutput() DelegationSetOutput

func (DelegationSet) ToDelegationSetOutputWithContext added in v3.13.0 

func (i DelegationSet) ToDelegationSetOutputWithContext(ctx context.Context) DelegationSetOutput

type DelegationSetArgs 

type DelegationSetArgs struct {
	// This is a reference name used in Caller Reference
	// (helpful for identifying single delegation set amongst others)
	ReferenceName pulumi.StringPtrInput
}

The set of arguments for constructing a DelegationSet resource.

func (DelegationSetArgs) ElementType 

func (DelegationSetArgs) ElementType() reflect.Type

type DelegationSetInput added in v3.13.0 

type DelegationSetInput interface {
	pulumi.Input

	ToDelegationSetOutput() DelegationSetOutput
	ToDelegationSetOutputWithContext(ctx context.Context) DelegationSetOutput
}

type DelegationSetOutput added in v3.13.0 

type DelegationSetOutput struct {
	*pulumi.OutputState
}

func (DelegationSetOutput) ElementType added in v3.13.0 

func (DelegationSetOutput) ElementType() reflect.Type

func (DelegationSetOutput) ToDelegationSetOutput added in v3.13.0 

func (o DelegationSetOutput) ToDelegationSetOutput() DelegationSetOutput

func (DelegationSetOutput) ToDelegationSetOutputWithContext added in v3.13.0 

func (o DelegationSetOutput) ToDelegationSetOutputWithContext(ctx context.Context) DelegationSetOutput

type DelegationSetState 

type DelegationSetState struct {
	// A list of authoritative name servers for the hosted zone
	// (effectively a list of NS records).
	NameServers pulumi.StringArrayInput
	// This is a reference name used in Caller Reference
	// (helpful for identifying single delegation set amongst others)
	ReferenceName pulumi.StringPtrInput
}

func (DelegationSetState) ElementType 

func (DelegationSetState) ElementType() reflect.Type

type GetResolverEndpointFilter added in v3.12.0 

type GetResolverEndpointFilter struct {
	Name   string   `pulumi:"name"`
	Values []string `pulumi:"values"`
}

type GetResolverEndpointFilterArgs added in v3.12.0 

type GetResolverEndpointFilterArgs struct {
	Name   pulumi.StringInput      `pulumi:"name"`
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetResolverEndpointFilterArgs) ElementType added in v3.12.0 

func (GetResolverEndpointFilterArgs) ElementType() reflect.Type

func (GetResolverEndpointFilterArgs) ToGetResolverEndpointFilterOutput added in v3.12.0 

func (i GetResolverEndpointFilterArgs) ToGetResolverEndpointFilterOutput() GetResolverEndpointFilterOutput

func (GetResolverEndpointFilterArgs) ToGetResolverEndpointFilterOutputWithContext added in v3.12.0 

func (i GetResolverEndpointFilterArgs) ToGetResolverEndpointFilterOutputWithContext(ctx context.Context) GetResolverEndpointFilterOutput

type GetResolverEndpointFilterArray added in v3.12.0 

type GetResolverEndpointFilterArray []GetResolverEndpointFilterInput

func (GetResolverEndpointFilterArray) ElementType added in v3.12.0 

func (GetResolverEndpointFilterArray) ElementType() reflect.Type

func (GetResolverEndpointFilterArray) ToGetResolverEndpointFilterArrayOutput added in v3.12.0 

func (i GetResolverEndpointFilterArray) ToGetResolverEndpointFilterArrayOutput() GetResolverEndpointFilterArrayOutput

func (GetResolverEndpointFilterArray) ToGetResolverEndpointFilterArrayOutputWithContext added in v3.12.0 

func (i GetResolverEndpointFilterArray) ToGetResolverEndpointFilterArrayOutputWithContext(ctx context.Context) GetResolverEndpointFilterArrayOutput

type GetResolverEndpointFilterArrayInput added in v3.12.0 

type GetResolverEndpointFilterArrayInput interface {
	pulumi.Input

	ToGetResolverEndpointFilterArrayOutput() GetResolverEndpointFilterArrayOutput
	ToGetResolverEndpointFilterArrayOutputWithContext(context.Context) GetResolverEndpointFilterArrayOutput
}

GetResolverEndpointFilterArrayInput is an input type that accepts GetResolverEndpointFilterArray and GetResolverEndpointFilterArrayOutput values. You can construct a concrete instance of `GetResolverEndpointFilterArrayInput` via: 

GetResolverEndpointFilterArray{ GetResolverEndpointFilterArgs{...} }

type GetResolverEndpointFilterArrayOutput added in v3.12.0 

type GetResolverEndpointFilterArrayOutput struct{ *pulumi.OutputState }

func (GetResolverEndpointFilterArrayOutput) ElementType added in v3.12.0 

func (GetResolverEndpointFilterArrayOutput) ElementType() reflect.Type

func (GetResolverEndpointFilterArrayOutput) Index added in v3.12.0 

func (o GetResolverEndpointFilterArrayOutput) Index(i pulumi.IntInput) GetResolverEndpointFilterOutput

func (GetResolverEndpointFilterArrayOutput) ToGetResolverEndpointFilterArrayOutput added in v3.12.0 

func (o GetResolverEndpointFilterArrayOutput) ToGetResolverEndpointFilterArrayOutput() GetResolverEndpointFilterArrayOutput

func (GetResolverEndpointFilterArrayOutput) ToGetResolverEndpointFilterArrayOutputWithContext added in v3.12.0 

func (o GetResolverEndpointFilterArrayOutput) ToGetResolverEndpointFilterArrayOutputWithContext(ctx context.Context) GetResolverEndpointFilterArrayOutput

type GetResolverEndpointFilterInput added in v3.12.0 

type GetResolverEndpointFilterInput interface {
	pulumi.Input

	ToGetResolverEndpointFilterOutput() GetResolverEndpointFilterOutput
	ToGetResolverEndpointFilterOutputWithContext(context.Context) GetResolverEndpointFilterOutput
}

GetResolverEndpointFilterInput is an input type that accepts GetResolverEndpointFilterArgs and GetResolverEndpointFilterOutput values. You can construct a concrete instance of `GetResolverEndpointFilterInput` via: 

GetResolverEndpointFilterArgs{...}

type GetResolverEndpointFilterOutput added in v3.12.0 

type GetResolverEndpointFilterOutput struct{ *pulumi.OutputState }

func (GetResolverEndpointFilterOutput) ElementType added in v3.12.0 

func (GetResolverEndpointFilterOutput) ElementType() reflect.Type

func (GetResolverEndpointFilterOutput) Name added in v3.12.0 

func (o GetResolverEndpointFilterOutput) Name() pulumi.StringOutput

func (GetResolverEndpointFilterOutput) ToGetResolverEndpointFilterOutput added in v3.12.0 

func (o GetResolverEndpointFilterOutput) ToGetResolverEndpointFilterOutput() GetResolverEndpointFilterOutput

func (GetResolverEndpointFilterOutput) ToGetResolverEndpointFilterOutputWithContext added in v3.12.0 

func (o GetResolverEndpointFilterOutput) ToGetResolverEndpointFilterOutputWithContext(ctx context.Context) GetResolverEndpointFilterOutput

func (GetResolverEndpointFilterOutput) Values added in v3.12.0 

func (o GetResolverEndpointFilterOutput) Values() pulumi.StringArrayOutput

type GetResolverRulesArgs 

type GetResolverRulesArgs struct {
	// When the desired resolver rules are shared with another AWS account, the account ID of the account that the rules are shared with.
	OwnerId *string `pulumi:"ownerId"`
	// The ID of the outbound resolver endpoint for the desired resolver rules.
	ResolverEndpointId *string `pulumi:"resolverEndpointId"`
	// The rule type of the desired resolver rules. Valid values are `FORWARD`, `SYSTEM` and `RECURSIVE`.
	RuleType *string `pulumi:"ruleType"`
	// Whether the desired resolver rules are shared and, if so, whether the current account is sharing the rules with another account, or another account is sharing the rules with the current account. Valid values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus *string `pulumi:"shareStatus"`
}

A collection of arguments for invoking getResolverRules.

type GetResolverRulesResult 

type GetResolverRulesResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id                 string  `pulumi:"id"`
	OwnerId            *string `pulumi:"ownerId"`
	ResolverEndpointId *string `pulumi:"resolverEndpointId"`
	// The IDs of the matched resolver rules.
	ResolverRuleIds []string `pulumi:"resolverRuleIds"`
	RuleType        *string  `pulumi:"ruleType"`
	ShareStatus     *string  `pulumi:"shareStatus"`
}

A collection of values returned by getResolverRules.

func GetResolverRules 

func GetResolverRules(ctx *pulumi.Context, args *GetResolverRulesArgs, opts ...pulumi.InvokeOption) (*GetResolverRulesResult, error)

`route53.getResolverRules` provides details about a set of Route53 Resolver rules.

## Example Usage

Retrieving the default resolver rule.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "Route 53 Resolver"
		opt1 := "RECURSIVE"
		opt2 := "NOT_SHARED"
		_, err := route53.GetResolverRules(ctx, &route53.GetResolverRulesArgs{
			OwnerId:     &opt0,
			RuleType:    &opt1,
			ShareStatus: &opt2,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "FORWARD"
		opt1 := "SHARED_WITH_ME"
		_, err := route53.GetResolverRules(ctx, &route53.GetResolverRulesArgs{
			RuleType:    &opt0,
			ShareStatus: &opt1,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type HealthCheck 

type HealthCheck struct {
	pulumi.CustomResourceState

	// The minimum number of child health checks that must be healthy for Route 53 to consider the parent health check to be healthy. Valid values are integers between 0 and 256, inclusive
	ChildHealthThreshold pulumi.IntPtrOutput `pulumi:"childHealthThreshold"`
	// For a specified parent health check, a list of HealthCheckId values for the associated child health checks.
	ChildHealthchecks pulumi.StringArrayOutput `pulumi:"childHealthchecks"`
	// The name of the CloudWatch alarm.
	CloudwatchAlarmName pulumi.StringPtrOutput `pulumi:"cloudwatchAlarmName"`
	// The CloudWatchRegion that the CloudWatch alarm was created in.
	CloudwatchAlarmRegion pulumi.StringPtrOutput `pulumi:"cloudwatchAlarmRegion"`
	// A boolean value that stops Route 53 from performing health checks. When set to true, Route 53 will do the following depending on the type of health check:
	// * For health checks that check the health of endpoints, Route5 53 stops submitting requests to your application, server, or other resource.
	// * For calculated health checks, Route 53 stops aggregating the status of the referenced health checks.
	// * For health checks that monitor CloudWatch alarms, Route 53 stops monitoring the corresponding CloudWatch metrics.
	Disabled pulumi.BoolPtrOutput `pulumi:"disabled"`
	// A boolean value that indicates whether Route53 should send the `fqdn` to the endpoint when performing the health check. This defaults to AWS' defaults: when the `type` is "HTTPS" `enableSni` defaults to `true`, when `type` is anything else `enableSni` defaults to `false`.
	EnableSni pulumi.BoolOutput `pulumi:"enableSni"`
	// The number of consecutive health checks that an endpoint must pass or fail.
	FailureThreshold pulumi.IntPtrOutput `pulumi:"failureThreshold"`
	// The fully qualified domain name of the endpoint to be checked.
	Fqdn pulumi.StringPtrOutput `pulumi:"fqdn"`
	// The status of the health check when CloudWatch has insufficient data about the state of associated alarm. Valid values are `Healthy` , `Unhealthy` and `LastKnownStatus`.
	InsufficientDataHealthStatus pulumi.StringPtrOutput `pulumi:"insufficientDataHealthStatus"`
	// A boolean value that indicates whether the status of health check should be inverted. For example, if a health check is healthy but Inverted is True , then Route 53 considers the health check to be unhealthy.
	InvertHealthcheck pulumi.BoolPtrOutput `pulumi:"invertHealthcheck"`
	// The IP address of the endpoint to be checked.
	IpAddress pulumi.StringPtrOutput `pulumi:"ipAddress"`
	// A Boolean value that indicates whether you want Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint and to display CloudWatch latency graphs in the Route 53 console.
	MeasureLatency pulumi.BoolPtrOutput `pulumi:"measureLatency"`
	// The port of the endpoint to be checked.
	Port pulumi.IntPtrOutput `pulumi:"port"`
	// This is a reference name used in Caller Reference
	// (helpful for identifying single healthCheck set amongst others)
	ReferenceName pulumi.StringPtrOutput `pulumi:"referenceName"`
	// A list of AWS regions that you want Amazon Route 53 health checkers to check the specified endpoint from.
	Regions pulumi.StringArrayOutput `pulumi:"regions"`
	// The number of seconds between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health-check request.
	RequestInterval pulumi.IntPtrOutput `pulumi:"requestInterval"`
	// The path that you want Amazon Route 53 to request when performing health checks.
	ResourcePath pulumi.StringPtrOutput `pulumi:"resourcePath"`
	// String searched in the first 5120 bytes of the response body for check to be considered healthy. Only valid with `HTTP_STR_MATCH` and `HTTPS_STR_MATCH`.
	SearchString pulumi.StringPtrOutput `pulumi:"searchString"`
	// A map of tags to assign to the health check.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// The protocol to use when performing health checks. Valid values are `HTTP`, `HTTPS`, `HTTP_STR_MATCH`, `HTTPS_STR_MATCH`, `TCP`, `CALCULATED` and `CLOUDWATCH_METRIC`.
	Type pulumi.StringOutput `pulumi:"type"`
}

Provides a Route53 health check.

## Example Usage ### Connectivity and HTTP Status Code Check

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewHealthCheck(ctx, "example", &route53.HealthCheckArgs{
			FailureThreshold: pulumi.Int(5),
			Fqdn:             pulumi.String("example.com"),
			Port:             pulumi.Int(80),
			RequestInterval:  pulumi.Int(30),
			ResourcePath:     pulumi.String("/"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("tf-test-health-check"),
			},
			Type: pulumi.String("HTTP"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Connectivity and String Matching Check

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewHealthCheck(ctx, "example", &route53.HealthCheckArgs{
			FailureThreshold: pulumi.Int(5),
			Fqdn:             pulumi.String("example.com"),
			Port:             pulumi.Int(443),
			RequestInterval:  pulumi.Int(30),
			ResourcePath:     pulumi.String("/"),
			SearchString:     pulumi.String("example"),
			Type:             pulumi.String("HTTPS_STR_MATCH"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### CloudWatch Alarm Check

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/cloudwatch"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foobar, err := cloudwatch.NewMetricAlarm(ctx, "foobar", &cloudwatch.MetricAlarmArgs{
			ComparisonOperator: pulumi.String("GreaterThanOrEqualToThreshold"),
			EvaluationPeriods:  pulumi.Int(2),
			MetricName:         pulumi.String("CPUUtilization"),
			Namespace:          pulumi.String("AWS/EC2"),
			Period:             pulumi.Int(120),
			Statistic:          pulumi.String("Average"),
			Threshold:          pulumi.Float64(80),
			AlarmDescription:   pulumi.String("This metric monitors ec2 cpu utilization"),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewHealthCheck(ctx, "foo", &route53.HealthCheckArgs{
			Type:                         pulumi.String("CLOUDWATCH_METRIC"),
			CloudwatchAlarmName:          foobar.Name,
			CloudwatchAlarmRegion:        pulumi.String("us-west-2"),
			InsufficientDataHealthStatus: pulumi.String("Healthy"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Health Checks can be imported using the `health check id`, e.g.

```sh 

$ pulumi import aws:route53/healthCheck:HealthCheck http_check abcdef11-2222-3333-4444-555555fedcba

```

func GetHealthCheck 

func GetHealthCheck(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *HealthCheckState, opts ...pulumi.ResourceOption) (*HealthCheck, error)

GetHealthCheck gets an existing HealthCheck 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 NewHealthCheck 

func NewHealthCheck(ctx *pulumi.Context,
	name string, args *HealthCheckArgs, opts ...pulumi.ResourceOption) (*HealthCheck, error)

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

func (HealthCheck) ElementType added in v3.13.0 

func (HealthCheck) ElementType() reflect.Type

func (HealthCheck) ToHealthCheckOutput added in v3.13.0 

func (i HealthCheck) ToHealthCheckOutput() HealthCheckOutput

func (HealthCheck) ToHealthCheckOutputWithContext added in v3.13.0 

func (i HealthCheck) ToHealthCheckOutputWithContext(ctx context.Context) HealthCheckOutput

type HealthCheckArgs 

type HealthCheckArgs struct {
	// The minimum number of child health checks that must be healthy for Route 53 to consider the parent health check to be healthy. Valid values are integers between 0 and 256, inclusive
	ChildHealthThreshold pulumi.IntPtrInput
	// For a specified parent health check, a list of HealthCheckId values for the associated child health checks.
	ChildHealthchecks pulumi.StringArrayInput
	// The name of the CloudWatch alarm.
	CloudwatchAlarmName pulumi.StringPtrInput
	// The CloudWatchRegion that the CloudWatch alarm was created in.
	CloudwatchAlarmRegion pulumi.StringPtrInput
	// A boolean value that stops Route 53 from performing health checks. When set to true, Route 53 will do the following depending on the type of health check:
	// * For health checks that check the health of endpoints, Route5 53 stops submitting requests to your application, server, or other resource.
	// * For calculated health checks, Route 53 stops aggregating the status of the referenced health checks.
	// * For health checks that monitor CloudWatch alarms, Route 53 stops monitoring the corresponding CloudWatch metrics.
	Disabled pulumi.BoolPtrInput
	// A boolean value that indicates whether Route53 should send the `fqdn` to the endpoint when performing the health check. This defaults to AWS' defaults: when the `type` is "HTTPS" `enableSni` defaults to `true`, when `type` is anything else `enableSni` defaults to `false`.
	EnableSni pulumi.BoolPtrInput
	// The number of consecutive health checks that an endpoint must pass or fail.
	FailureThreshold pulumi.IntPtrInput
	// The fully qualified domain name of the endpoint to be checked.
	Fqdn pulumi.StringPtrInput
	// The status of the health check when CloudWatch has insufficient data about the state of associated alarm. Valid values are `Healthy` , `Unhealthy` and `LastKnownStatus`.
	InsufficientDataHealthStatus pulumi.StringPtrInput
	// A boolean value that indicates whether the status of health check should be inverted. For example, if a health check is healthy but Inverted is True , then Route 53 considers the health check to be unhealthy.
	InvertHealthcheck pulumi.BoolPtrInput
	// The IP address of the endpoint to be checked.
	IpAddress pulumi.StringPtrInput
	// A Boolean value that indicates whether you want Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint and to display CloudWatch latency graphs in the Route 53 console.
	MeasureLatency pulumi.BoolPtrInput
	// The port of the endpoint to be checked.
	Port pulumi.IntPtrInput
	// This is a reference name used in Caller Reference
	// (helpful for identifying single healthCheck set amongst others)
	ReferenceName pulumi.StringPtrInput
	// A list of AWS regions that you want Amazon Route 53 health checkers to check the specified endpoint from.
	Regions pulumi.StringArrayInput
	// The number of seconds between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health-check request.
	RequestInterval pulumi.IntPtrInput
	// The path that you want Amazon Route 53 to request when performing health checks.
	ResourcePath pulumi.StringPtrInput
	// String searched in the first 5120 bytes of the response body for check to be considered healthy. Only valid with `HTTP_STR_MATCH` and `HTTPS_STR_MATCH`.
	SearchString pulumi.StringPtrInput
	// A map of tags to assign to the health check.
	Tags pulumi.StringMapInput
	// The protocol to use when performing health checks. Valid values are `HTTP`, `HTTPS`, `HTTP_STR_MATCH`, `HTTPS_STR_MATCH`, `TCP`, `CALCULATED` and `CLOUDWATCH_METRIC`.
	Type pulumi.StringInput
}

The set of arguments for constructing a HealthCheck resource.

func (HealthCheckArgs) ElementType 

func (HealthCheckArgs) ElementType() reflect.Type

type HealthCheckInput added in v3.13.0 

type HealthCheckInput interface {
	pulumi.Input

	ToHealthCheckOutput() HealthCheckOutput
	ToHealthCheckOutputWithContext(ctx context.Context) HealthCheckOutput
}

type HealthCheckOutput added in v3.13.0 

type HealthCheckOutput struct {
	*pulumi.OutputState
}

func (HealthCheckOutput) ElementType added in v3.13.0 

func (HealthCheckOutput) ElementType() reflect.Type

func (HealthCheckOutput) ToHealthCheckOutput added in v3.13.0 

func (o HealthCheckOutput) ToHealthCheckOutput() HealthCheckOutput

func (HealthCheckOutput) ToHealthCheckOutputWithContext added in v3.13.0 

func (o HealthCheckOutput) ToHealthCheckOutputWithContext(ctx context.Context) HealthCheckOutput

type HealthCheckState 

type HealthCheckState struct {
	// The minimum number of child health checks that must be healthy for Route 53 to consider the parent health check to be healthy. Valid values are integers between 0 and 256, inclusive
	ChildHealthThreshold pulumi.IntPtrInput
	// For a specified parent health check, a list of HealthCheckId values for the associated child health checks.
	ChildHealthchecks pulumi.StringArrayInput
	// The name of the CloudWatch alarm.
	CloudwatchAlarmName pulumi.StringPtrInput
	// The CloudWatchRegion that the CloudWatch alarm was created in.
	CloudwatchAlarmRegion pulumi.StringPtrInput
	// A boolean value that stops Route 53 from performing health checks. When set to true, Route 53 will do the following depending on the type of health check:
	// * For health checks that check the health of endpoints, Route5 53 stops submitting requests to your application, server, or other resource.
	// * For calculated health checks, Route 53 stops aggregating the status of the referenced health checks.
	// * For health checks that monitor CloudWatch alarms, Route 53 stops monitoring the corresponding CloudWatch metrics.
	Disabled pulumi.BoolPtrInput
	// A boolean value that indicates whether Route53 should send the `fqdn` to the endpoint when performing the health check. This defaults to AWS' defaults: when the `type` is "HTTPS" `enableSni` defaults to `true`, when `type` is anything else `enableSni` defaults to `false`.
	EnableSni pulumi.BoolPtrInput
	// The number of consecutive health checks that an endpoint must pass or fail.
	FailureThreshold pulumi.IntPtrInput
	// The fully qualified domain name of the endpoint to be checked.
	Fqdn pulumi.StringPtrInput
	// The status of the health check when CloudWatch has insufficient data about the state of associated alarm. Valid values are `Healthy` , `Unhealthy` and `LastKnownStatus`.
	InsufficientDataHealthStatus pulumi.StringPtrInput
	// A boolean value that indicates whether the status of health check should be inverted. For example, if a health check is healthy but Inverted is True , then Route 53 considers the health check to be unhealthy.
	InvertHealthcheck pulumi.BoolPtrInput
	// The IP address of the endpoint to be checked.
	IpAddress pulumi.StringPtrInput
	// A Boolean value that indicates whether you want Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint and to display CloudWatch latency graphs in the Route 53 console.
	MeasureLatency pulumi.BoolPtrInput
	// The port of the endpoint to be checked.
	Port pulumi.IntPtrInput
	// This is a reference name used in Caller Reference
	// (helpful for identifying single healthCheck set amongst others)
	ReferenceName pulumi.StringPtrInput
	// A list of AWS regions that you want Amazon Route 53 health checkers to check the specified endpoint from.
	Regions pulumi.StringArrayInput
	// The number of seconds between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health-check request.
	RequestInterval pulumi.IntPtrInput
	// The path that you want Amazon Route 53 to request when performing health checks.
	ResourcePath pulumi.StringPtrInput
	// String searched in the first 5120 bytes of the response body for check to be considered healthy. Only valid with `HTTP_STR_MATCH` and `HTTPS_STR_MATCH`.
	SearchString pulumi.StringPtrInput
	// A map of tags to assign to the health check.
	Tags pulumi.StringMapInput
	// The protocol to use when performing health checks. Valid values are `HTTP`, `HTTPS`, `HTTP_STR_MATCH`, `HTTPS_STR_MATCH`, `TCP`, `CALCULATED` and `CLOUDWATCH_METRIC`.
	Type pulumi.StringPtrInput
}

func (HealthCheckState) ElementType 

func (HealthCheckState) ElementType() reflect.Type

type LookupDelegationSetArgs 

type LookupDelegationSetArgs struct {
	// The Hosted Zone id of the desired delegation set.
	Id string `pulumi:"id"`
}

A collection of arguments for invoking getDelegationSet.

type LookupDelegationSetResult 

type LookupDelegationSetResult struct {
	CallerReference string   `pulumi:"callerReference"`
	Id              string   `pulumi:"id"`
	NameServers     []string `pulumi:"nameServers"`
}

A collection of values returned by getDelegationSet.

func LookupDelegationSet 

func LookupDelegationSet(ctx *pulumi.Context, args *LookupDelegationSetArgs, opts ...pulumi.InvokeOption) (*LookupDelegationSetResult, error)

`route53.DelegationSet` provides details about a specific Route 53 Delegation Set.

This data source allows to find a list of name servers associated with a specific delegation set.

## Example Usage

The following example shows how to get a delegation set from its id.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.LookupDelegationSet(ctx, &route53.LookupDelegationSetArgs{
			Id: "MQWGHCBFAKEID",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupResolverEndpointArgs added in v3.12.0 

type LookupResolverEndpointArgs struct {
	// One or more name/value pairs to use as filters. There are
	// several valid keys, for a full reference, check out
	// [Route53resolver Filter value in the AWS API reference][1].
	Filters []GetResolverEndpointFilter `pulumi:"filters"`
	// The ID of the Route53 Resolver Endpoint.
	ResolverEndpointId *string `pulumi:"resolverEndpointId"`
}

A collection of arguments for invoking getResolverEndpoint.

type LookupResolverEndpointResult added in v3.12.0 

type LookupResolverEndpointResult struct {
	Arn       string                      `pulumi:"arn"`
	Direction string                      `pulumi:"direction"`
	Filters   []GetResolverEndpointFilter `pulumi:"filters"`
	// The provider-assigned unique ID for this managed resource.
	Id                 string   `pulumi:"id"`
	IpAddresses        []string `pulumi:"ipAddresses"`
	Name               string   `pulumi:"name"`
	ResolverEndpointId *string  `pulumi:"resolverEndpointId"`
	Status             string   `pulumi:"status"`
	VpcId              string   `pulumi:"vpcId"`
}

A collection of values returned by getResolverEndpoint.

func LookupResolverEndpoint added in v3.12.0 

func LookupResolverEndpoint(ctx *pulumi.Context, args *LookupResolverEndpointArgs, opts ...pulumi.InvokeOption) (*LookupResolverEndpointResult, error)

`route53.ResolverEndpoint` provides details about a specific Route53 Resolver Endpoint.

This data source allows to find a list of IPaddresses associated with a specific Route53 Resolver Endpoint.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "rslvr-in-1abc2345ef678g91h"
		_, err := route53.LookupResolverEndpoint(ctx, &route53.LookupResolverEndpointArgs{
			ResolverEndpointId: &opt0,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.LookupResolverEndpoint(ctx, &route53.LookupResolverEndpointArgs{
			Filters: []route53.GetResolverEndpointFilter{
				route53.GetResolverEndpointFilter{
					Name: "NAME",
					Values: []string{
						"MyResolverExampleName",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupResolverRuleArgs 

type LookupResolverRuleArgs struct {
	// The domain name the desired resolver rule forwards DNS queries for. Conflicts with `resolverRuleId`.
	DomainName *string `pulumi:"domainName"`
	// The friendly name of the desired resolver rule. Conflicts with `resolverRuleId`.
	Name *string `pulumi:"name"`
	// The ID of the outbound resolver endpoint of the desired resolver rule. Conflicts with `resolverRuleId`.
	ResolverEndpointId *string `pulumi:"resolverEndpointId"`
	// The ID of the desired resolver rule. Conflicts with `domainName`, `name`, `resolverEndpointId` and `ruleType`.
	ResolverRuleId *string `pulumi:"resolverRuleId"`
	// The rule type of the desired resolver rule. Valid values are `FORWARD`, `SYSTEM` and `RECURSIVE`. Conflicts with `resolverRuleId`.
	RuleType *string `pulumi:"ruleType"`
	// A map of tags assigned to the resolver rule.
	Tags map[string]string `pulumi:"tags"`
}

A collection of arguments for invoking getResolverRule.

type LookupResolverRuleResult 

type LookupResolverRuleResult struct {
	// The ARN (Amazon Resource Name) for the resolver rule.
	Arn        string `pulumi:"arn"`
	DomainName string `pulumi:"domainName"`
	// The provider-assigned unique ID for this managed resource.
	Id   string `pulumi:"id"`
	Name string `pulumi:"name"`
	// When a rule is shared with another AWS account, the account ID of the account that the rule is shared with.
	OwnerId            string `pulumi:"ownerId"`
	ResolverEndpointId string `pulumi:"resolverEndpointId"`
	ResolverRuleId     string `pulumi:"resolverRuleId"`
	RuleType           string `pulumi:"ruleType"`
	// Whether the rules is shared and, if so, whether the current account is sharing the rule with another account, or another account is sharing the rule with the current account.
	// Values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus string `pulumi:"shareStatus"`
	// A map of tags assigned to the resolver rule.
	Tags map[string]string `pulumi:"tags"`
}

A collection of values returned by getResolverRule.

func LookupResolverRule 

func LookupResolverRule(ctx *pulumi.Context, args *LookupResolverRuleArgs, opts ...pulumi.InvokeOption) (*LookupResolverRuleResult, error)

`route53.ResolverRule` provides details about a specific Route53 Resolver rule.

## Example Usage

The following example shows how to get a Route53 Resolver rule based on its associated domain name and rule type.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "subdomain.example.com"
		opt1 := "SYSTEM"
		_, err := route53.LookupResolverRule(ctx, &route53.LookupResolverRuleArgs{
			DomainName: &opt0,
			RuleType:   &opt1,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupZoneArgs 

type LookupZoneArgs struct {
	// The Hosted Zone name of the desired Hosted Zone.
	Name *string `pulumi:"name"`
	// Used with `name` field to get a private Hosted Zone.
	PrivateZone *bool `pulumi:"privateZone"`
	// The number of Record Set in the Hosted Zone.
	ResourceRecordSetCount *int `pulumi:"resourceRecordSetCount"`
	// Used with `name` field. A map of tags, each pair of which must exactly match a pair on the desired Hosted Zone.
	Tags map[string]string `pulumi:"tags"`
	// Used with `name` field to get a private Hosted Zone associated with the vpcId (in this case, privateZone is not mandatory).
	VpcId *string `pulumi:"vpcId"`
	// The Hosted Zone id of the desired Hosted Zone.
	ZoneId *string `pulumi:"zoneId"`
}

A collection of arguments for invoking getZone.

type LookupZoneResult 

type LookupZoneResult struct {
	// Caller Reference of the Hosted Zone.
	CallerReference string `pulumi:"callerReference"`
	// The comment field of the Hosted Zone.
	Comment string `pulumi:"comment"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The description provided by the service that created the Hosted Zone (e.g. `arn:aws:servicediscovery:us-east-1:1234567890:namespace/ns-xxxxxxxxxxxxxxxx`).
	LinkedServiceDescription string `pulumi:"linkedServiceDescription"`
	// The service that created the Hosted Zone (e.g. `servicediscovery.amazonaws.com`).
	LinkedServicePrincipal string `pulumi:"linkedServicePrincipal"`
	Name                   string `pulumi:"name"`
	// The list of DNS name servers for the Hosted Zone.
	NameServers []string `pulumi:"nameServers"`
	PrivateZone *bool    `pulumi:"privateZone"`
	// The number of Record Set in the Hosted Zone.
	ResourceRecordSetCount int               `pulumi:"resourceRecordSetCount"`
	Tags                   map[string]string `pulumi:"tags"`
	VpcId                  string            `pulumi:"vpcId"`
	ZoneId                 string            `pulumi:"zoneId"`
}

A collection of values returned by getZone.

func LookupZone 

func LookupZone(ctx *pulumi.Context, args *LookupZoneArgs, opts ...pulumi.InvokeOption) (*LookupZoneResult, error)

`route53.Zone` provides details about a specific Route 53 Hosted Zone.

This data source allows to find a Hosted Zone ID given Hosted Zone name and certain search criteria.

## Example Usage

The following example shows how to get a Hosted Zone from its name and from this data how to create a Record Set.

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "test.com."
		opt1 := true
		selected, err := route53.LookupZone(ctx, &route53.LookupZoneArgs{
			Name:        &opt0,
			PrivateZone: &opt1,
		}, nil)
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "www", &route53.RecordArgs{
			ZoneId: pulumi.String(selected.ZoneId),
			Name:   pulumi.String(fmt.Sprintf("%v%v", "www.", selected.Name)),
			Type:   pulumi.String("A"),
			Ttl:    pulumi.Int(300),
			Records: pulumi.StringArray{
				pulumi.String("10.0.0.1"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

type QueryLog 

type QueryLog struct {
	pulumi.CustomResourceState

	// CloudWatch log group ARN to send query logs.
	CloudwatchLogGroupArn pulumi.StringOutput `pulumi:"cloudwatchLogGroupArn"`
	// Route53 hosted zone ID to enable query logs.
	ZoneId pulumi.StringOutput `pulumi:"zoneId"`
}

Provides a Route53 query logging configuration resource.

> **NOTE:** There are restrictions on the configuration of query logging. Notably, the CloudWatch log group must be in the `us-east-1` region, a permissive CloudWatch log resource policy must be in place, and the Route53 hosted zone must be public. See [Configuring Logging for DNS Queries](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/query-logs.html?console_help=true#query-logs-configuring) for additional details.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/cloudwatch"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/providers"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := providers.Newaws(ctx, "us_east_1", &providers.awsArgs{
			Region: pulumi.String("us-east-1"),
		})
		if err != nil {
			return err
		}
		awsRoute53ExampleCom, err := cloudwatch.NewLogGroup(ctx, "awsRoute53ExampleCom", &cloudwatch.LogGroupArgs{
			RetentionInDays: pulumi.Int(30),
		}, pulumi.Provider(aws.Us-east-1))
		if err != nil {
			return err
		}
		route53_query_logging_policyPolicyDocument, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				iam.GetPolicyDocumentStatement{
					Actions: []string{
						"logs:CreateLogStream",
						"logs:PutLogEvents",
					},
					Resources: []string{
						"arn:aws:logs:*:*:log-group:/aws/route53/*",
					},
					Principals: []iam.GetPolicyDocumentStatementPrincipal{
						iam.GetPolicyDocumentStatementPrincipal{
							Identifiers: []string{
								"route53.amazonaws.com",
							},
							Type: "Service",
						},
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = cloudwatch.NewLogResourcePolicy(ctx, "route53_query_logging_policyLogResourcePolicy", &cloudwatch.LogResourcePolicyArgs{
			PolicyDocument: pulumi.String(route53_query_logging_policyPolicyDocument.Json),
			PolicyName:     pulumi.String("route53-query-logging-policy"),
		}, pulumi.Provider(aws.Us-east-1))
		if err != nil {
			return err
		}
		exampleComZone, err := route53.NewZone(ctx, "exampleComZone", nil)
		if err != nil {
			return err
		}
		_, err = route53.NewQueryLog(ctx, "exampleComQueryLog", &route53.QueryLogArgs{
			CloudwatchLogGroupArn: awsRoute53ExampleCom.Arn,
			ZoneId:                exampleComZone.ZoneId,
		}, pulumi.DependsOn([]pulumi.Resource{
			route53_query_logging_policyLogResourcePolicy,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 query logging configurations can be imported using their ID, e.g.

```sh 

$ pulumi import aws:route53/queryLog:QueryLog example_com xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

```

func GetQueryLog 

func GetQueryLog(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *QueryLogState, opts ...pulumi.ResourceOption) (*QueryLog, error)

GetQueryLog gets an existing QueryLog 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 NewQueryLog 

func NewQueryLog(ctx *pulumi.Context,
	name string, args *QueryLogArgs, opts ...pulumi.ResourceOption) (*QueryLog, error)

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

func (QueryLog) ElementType added in v3.13.0 

func (QueryLog) ElementType() reflect.Type

func (QueryLog) ToQueryLogOutput added in v3.13.0 

func (i QueryLog) ToQueryLogOutput() QueryLogOutput

func (QueryLog) ToQueryLogOutputWithContext added in v3.13.0 

func (i QueryLog) ToQueryLogOutputWithContext(ctx context.Context) QueryLogOutput

type QueryLogArgs 

type QueryLogArgs struct {
	// CloudWatch log group ARN to send query logs.
	CloudwatchLogGroupArn pulumi.StringInput
	// Route53 hosted zone ID to enable query logs.
	ZoneId pulumi.StringInput
}

The set of arguments for constructing a QueryLog resource.

func (QueryLogArgs) ElementType 

func (QueryLogArgs) ElementType() reflect.Type

type QueryLogInput added in v3.13.0 

type QueryLogInput interface {
	pulumi.Input

	ToQueryLogOutput() QueryLogOutput
	ToQueryLogOutputWithContext(ctx context.Context) QueryLogOutput
}

type QueryLogOutput added in v3.13.0 

type QueryLogOutput struct {
	*pulumi.OutputState
}

func (QueryLogOutput) ElementType added in v3.13.0 

func (QueryLogOutput) ElementType() reflect.Type

func (QueryLogOutput) ToQueryLogOutput added in v3.13.0 

func (o QueryLogOutput) ToQueryLogOutput() QueryLogOutput

func (QueryLogOutput) ToQueryLogOutputWithContext added in v3.13.0 

func (o QueryLogOutput) ToQueryLogOutputWithContext(ctx context.Context) QueryLogOutput

type QueryLogState 

type QueryLogState struct {
	// CloudWatch log group ARN to send query logs.
	CloudwatchLogGroupArn pulumi.StringPtrInput
	// Route53 hosted zone ID to enable query logs.
	ZoneId pulumi.StringPtrInput
}

func (QueryLogState) ElementType 

func (QueryLogState) ElementType() reflect.Type

type Record 

type Record struct {
	pulumi.CustomResourceState

	// An alias block. Conflicts with `ttl` & `records`.
	// Alias record documented below.
	Aliases RecordAliasArrayOutput `pulumi:"aliases"`
	// Allow creation of this record to overwrite an existing record, if any. This does not affect the ability to update the record using this provider and does not prevent other resources within this provider or manual Route 53 changes outside this provider from overwriting this record. `false` by default. This configuration is not recommended for most environments.
	AllowOverwrite pulumi.BoolOutput `pulumi:"allowOverwrite"`
	// A block indicating the routing behavior when associated health check fails. Conflicts with any other routing policy. Documented below.
	FailoverRoutingPolicies RecordFailoverRoutingPolicyArrayOutput `pulumi:"failoverRoutingPolicies"`
	// [FQDN](https://en.wikipedia.org/wiki/Fully_qualified_domain_name) built using the zone domain and `name`.
	Fqdn pulumi.StringOutput `pulumi:"fqdn"`
	// A block indicating a routing policy based on the geolocation of the requestor. Conflicts with any other routing policy. Documented below.
	GeolocationRoutingPolicies RecordGeolocationRoutingPolicyArrayOutput `pulumi:"geolocationRoutingPolicies"`
	// The health check the record should be associated with.
	HealthCheckId pulumi.StringPtrOutput `pulumi:"healthCheckId"`
	// A block indicating a routing policy based on the latency between the requestor and an AWS region. Conflicts with any other routing policy. Documented below.
	LatencyRoutingPolicies RecordLatencyRoutingPolicyArrayOutput `pulumi:"latencyRoutingPolicies"`
	// Set to `true` to indicate a multivalue answer routing policy. Conflicts with any other routing policy.
	MultivalueAnswerRoutingPolicy pulumi.BoolPtrOutput `pulumi:"multivalueAnswerRoutingPolicy"`
	// DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.
	Name pulumi.StringOutput `pulumi:"name"`
	// A string list of records. To specify a single record value longer than 255 characters such as a TXT record for DKIM, add `\"\"` inside the configuration string (e.g. `"first255characters\"\"morecharacters"`).
	Records pulumi.StringArrayOutput `pulumi:"records"`
	// Unique identifier to differentiate records with routing policies from one another. Required if using `failover`, `geolocation`, `latency`, or `weighted` routing policies documented below.
	SetIdentifier pulumi.StringPtrOutput `pulumi:"setIdentifier"`
	// The TTL of the record.
	Ttl pulumi.IntPtrOutput `pulumi:"ttl"`
	// `PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets
	Type pulumi.StringOutput `pulumi:"type"`
	// A block indicating a weighted routing policy. Conflicts with any other routing policy. Documented below.
	WeightedRoutingPolicies RecordWeightedRoutingPolicyArrayOutput `pulumi:"weightedRoutingPolicies"`
	// Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.
	ZoneId pulumi.StringOutput `pulumi:"zoneId"`
}

Provides a Route53 record resource.

## Example Usage ### Weighted routing policy Other routing policies are configured similarly. See [AWS Route53 Developer Guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html) for details.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewRecord(ctx, "www_dev", &route53.RecordArgs{
			ZoneId: pulumi.Any(aws_route53_zone.Primary.Zone_id),
			Name:   pulumi.String("www"),
			Type:   pulumi.String("CNAME"),
			Ttl:    pulumi.Int(5),
			WeightedRoutingPolicies: route53.RecordWeightedRoutingPolicyArray{
				&route53.RecordWeightedRoutingPolicyArgs{
					Weight: pulumi.Int(10),
				},
			},
			SetIdentifier: pulumi.String("dev"),
			Records: pulumi.StringArray{
				pulumi.String("dev.example.com"),
			},
		})
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "www_live", &route53.RecordArgs{
			ZoneId: pulumi.Any(aws_route53_zone.Primary.Zone_id),
			Name:   pulumi.String("www"),
			Type:   pulumi.String("CNAME"),
			Ttl:    pulumi.Int(5),
			WeightedRoutingPolicies: route53.RecordWeightedRoutingPolicyArray{
				&route53.RecordWeightedRoutingPolicyArgs{
					Weight: pulumi.Int(90),
				},
			},
			SetIdentifier: pulumi.String("live"),
			Records: pulumi.StringArray{
				pulumi.String("live.example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Alias record See [related part of AWS Route53 Developer Guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-choosing-alias-non-alias.html) to understand differences between alias and non-alias records.

TTL for all alias records is [60 seconds](https://aws.amazon.com/route53/faqs/#dns_failover_do_i_need_to_adjust), you cannot change this, therefore `ttl` has to be omitted in alias records.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/elb"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := elb.NewLoadBalancer(ctx, "main", &elb.LoadBalancerArgs{
			AvailabilityZones: pulumi.StringArray{
				pulumi.String("us-east-1c"),
			},
			Listeners: elb.LoadBalancerListenerArray{
				&elb.LoadBalancerListenerArgs{
					InstancePort:     pulumi.Int(80),
					InstanceProtocol: pulumi.String("http"),
					LbPort:           pulumi.Int(80),
					LbProtocol:       pulumi.String("http"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "www", &route53.RecordArgs{
			ZoneId: pulumi.Any(aws_route53_zone.Primary.Zone_id),
			Name:   pulumi.String("example.com"),
			Type:   pulumi.String("A"),
			Aliases: route53.RecordAliasArray{
				&route53.RecordAliasArgs{
					Name:                 main.DnsName,
					ZoneId:               main.ZoneId,
					EvaluateTargetHealth: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### NS and SOA Record Management

When creating Route 53 zones, the `NS` and `SOA` records for the zone are automatically created. Enabling the `allowOverwrite` argument will allow managing these records in a single deployment without the requirement for `import`.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleZone, err := route53.NewZone(ctx, "exampleZone", nil)
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "exampleRecord", &route53.RecordArgs{
			AllowOverwrite: pulumi.Bool(true),
			Name:           pulumi.String("test.example.com"),
			Ttl:            pulumi.Int(30),
			Type:           pulumi.String("NS"),
			ZoneId:         exampleZone.ZoneId,
			Records: pulumi.StringArray{
				exampleZone.NameServers.ApplyT(func(nameServers []string) (string, error) {
					return nameServers[0], nil
				}).(pulumi.StringOutput),
				exampleZone.NameServers.ApplyT(func(nameServers []string) (string, error) {
					return nameServers[1], nil
				}).(pulumi.StringOutput),
				exampleZone.NameServers.ApplyT(func(nameServers []string) (string, error) {
					return nameServers[2], nil
				}).(pulumi.StringOutput),
				exampleZone.NameServers.ApplyT(func(nameServers []string) (string, error) {
					return nameServers[3], nil
				}).(pulumi.StringOutput),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Records can be imported using ID of the record, which is the zone identifier, record name, and record type, separated by underscores (`_`). e.g.

```sh 

$ pulumi import aws:route53/record:Record myrecord Z4KAPRWWNC7JR_dev.example.com_NS

``` 

If the record also contains a delegated set identifier, it can be appended

```sh 

$ pulumi import aws:route53/record:Record myrecord Z4KAPRWWNC7JR_dev.example.com_NS_dev

```

func GetRecord 

func GetRecord(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RecordState, opts ...pulumi.ResourceOption) (*Record, error)

GetRecord gets an existing Record 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 NewRecord 

func NewRecord(ctx *pulumi.Context,
	name string, args *RecordArgs, opts ...pulumi.ResourceOption) (*Record, error)

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

func (Record) ElementType added in v3.13.0 

func (Record) ElementType() reflect.Type

func (Record) ToRecordOutput added in v3.13.0 

func (i Record) ToRecordOutput() RecordOutput

func (Record) ToRecordOutputWithContext added in v3.13.0 

func (i Record) ToRecordOutputWithContext(ctx context.Context) RecordOutput

type RecordAlias 

type RecordAlias struct {
	// Set to `true` if you want Route 53 to determine whether to respond to DNS queries using this resource record set by checking the health of the resource record set. Some resources have special requirements, see [related part of documentation](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-values.html#rrsets-values-alias-evaluate-target-health).
	EvaluateTargetHealth bool `pulumi:"evaluateTargetHealth"`
	// DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.
	Name string `pulumi:"name"`
	// Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.
	ZoneId string `pulumi:"zoneId"`
}

type RecordAliasArgs 

type RecordAliasArgs struct {
	// Set to `true` if you want Route 53 to determine whether to respond to DNS queries using this resource record set by checking the health of the resource record set. Some resources have special requirements, see [related part of documentation](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-values.html#rrsets-values-alias-evaluate-target-health).
	EvaluateTargetHealth pulumi.BoolInput `pulumi:"evaluateTargetHealth"`
	// DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.
	Name pulumi.StringInput `pulumi:"name"`
	// Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.
	ZoneId pulumi.StringInput `pulumi:"zoneId"`
}

func (RecordAliasArgs) ElementType 

func (RecordAliasArgs) ElementType() reflect.Type

func (RecordAliasArgs) ToRecordAliasOutput 

func (i RecordAliasArgs) ToRecordAliasOutput() RecordAliasOutput

func (RecordAliasArgs) ToRecordAliasOutputWithContext 

func (i RecordAliasArgs) ToRecordAliasOutputWithContext(ctx context.Context) RecordAliasOutput

type RecordAliasArray 

type RecordAliasArray []RecordAliasInput

func (RecordAliasArray) ElementType 

func (RecordAliasArray) ElementType() reflect.Type

func (RecordAliasArray) ToRecordAliasArrayOutput 

func (i RecordAliasArray) ToRecordAliasArrayOutput() RecordAliasArrayOutput

func (RecordAliasArray) ToRecordAliasArrayOutputWithContext 

func (i RecordAliasArray) ToRecordAliasArrayOutputWithContext(ctx context.Context) RecordAliasArrayOutput

type RecordAliasArrayInput 

type RecordAliasArrayInput interface {
	pulumi.Input

	ToRecordAliasArrayOutput() RecordAliasArrayOutput
	ToRecordAliasArrayOutputWithContext(context.Context) RecordAliasArrayOutput
}

RecordAliasArrayInput is an input type that accepts RecordAliasArray and RecordAliasArrayOutput values. You can construct a concrete instance of `RecordAliasArrayInput` via: 

RecordAliasArray{ RecordAliasArgs{...} }

type RecordAliasArrayOutput 

type RecordAliasArrayOutput struct{ *pulumi.OutputState }

func (RecordAliasArrayOutput) ElementType 

func (RecordAliasArrayOutput) ElementType() reflect.Type

func (RecordAliasArrayOutput) Index 

func (o RecordAliasArrayOutput) Index(i pulumi.IntInput) RecordAliasOutput

func (RecordAliasArrayOutput) ToRecordAliasArrayOutput 

func (o RecordAliasArrayOutput) ToRecordAliasArrayOutput() RecordAliasArrayOutput

func (RecordAliasArrayOutput) ToRecordAliasArrayOutputWithContext 

func (o RecordAliasArrayOutput) ToRecordAliasArrayOutputWithContext(ctx context.Context) RecordAliasArrayOutput

type RecordAliasInput 

type RecordAliasInput interface {
	pulumi.Input

	ToRecordAliasOutput() RecordAliasOutput
	ToRecordAliasOutputWithContext(context.Context) RecordAliasOutput
}

RecordAliasInput is an input type that accepts RecordAliasArgs and RecordAliasOutput values. You can construct a concrete instance of `RecordAliasInput` via: 

RecordAliasArgs{...}

type RecordAliasOutput 

type RecordAliasOutput struct{ *pulumi.OutputState }

func (RecordAliasOutput) ElementType 

func (RecordAliasOutput) ElementType() reflect.Type

func (RecordAliasOutput) EvaluateTargetHealth 

func (o RecordAliasOutput) EvaluateTargetHealth() pulumi.BoolOutput

Set to `true` if you want Route 53 to determine whether to respond to DNS queries using this resource record set by checking the health of the resource record set. Some resources have special requirements, see [related part of documentation](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-values.html#rrsets-values-alias-evaluate-target-health).

func (RecordAliasOutput) Name 

func (o RecordAliasOutput) Name() pulumi.StringOutput

DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.

func (RecordAliasOutput) ToRecordAliasOutput 

func (o RecordAliasOutput) ToRecordAliasOutput() RecordAliasOutput

func (RecordAliasOutput) ToRecordAliasOutputWithContext 

func (o RecordAliasOutput) ToRecordAliasOutputWithContext(ctx context.Context) RecordAliasOutput

func (RecordAliasOutput) ZoneId 

func (o RecordAliasOutput) ZoneId() pulumi.StringOutput

Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.

type RecordArgs 

type RecordArgs struct {
	// An alias block. Conflicts with `ttl` & `records`.
	// Alias record documented below.
	Aliases RecordAliasArrayInput
	// Allow creation of this record to overwrite an existing record, if any. This does not affect the ability to update the record using this provider and does not prevent other resources within this provider or manual Route 53 changes outside this provider from overwriting this record. `false` by default. This configuration is not recommended for most environments.
	AllowOverwrite pulumi.BoolPtrInput
	// A block indicating the routing behavior when associated health check fails. Conflicts with any other routing policy. Documented below.
	FailoverRoutingPolicies RecordFailoverRoutingPolicyArrayInput
	// A block indicating a routing policy based on the geolocation of the requestor. Conflicts with any other routing policy. Documented below.
	GeolocationRoutingPolicies RecordGeolocationRoutingPolicyArrayInput
	// The health check the record should be associated with.
	HealthCheckId pulumi.StringPtrInput
	// A block indicating a routing policy based on the latency between the requestor and an AWS region. Conflicts with any other routing policy. Documented below.
	LatencyRoutingPolicies RecordLatencyRoutingPolicyArrayInput
	// Set to `true` to indicate a multivalue answer routing policy. Conflicts with any other routing policy.
	MultivalueAnswerRoutingPolicy pulumi.BoolPtrInput
	// DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.
	Name pulumi.StringInput
	// A string list of records. To specify a single record value longer than 255 characters such as a TXT record for DKIM, add `\"\"` inside the configuration string (e.g. `"first255characters\"\"morecharacters"`).
	Records pulumi.StringArrayInput
	// Unique identifier to differentiate records with routing policies from one another. Required if using `failover`, `geolocation`, `latency`, or `weighted` routing policies documented below.
	SetIdentifier pulumi.StringPtrInput
	// The TTL of the record.
	Ttl pulumi.IntPtrInput
	// `PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets
	Type pulumi.Input
	// A block indicating a weighted routing policy. Conflicts with any other routing policy. Documented below.
	WeightedRoutingPolicies RecordWeightedRoutingPolicyArrayInput
	// Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.
	ZoneId pulumi.StringInput
}

The set of arguments for constructing a Record resource.

func (RecordArgs) ElementType 

func (RecordArgs) ElementType() reflect.Type

type RecordFailoverRoutingPolicy 

type RecordFailoverRoutingPolicy struct {
	// `PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets
	Type string `pulumi:"type"`
}

type RecordFailoverRoutingPolicyArgs 

type RecordFailoverRoutingPolicyArgs struct {
	// `PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets
	Type pulumi.StringInput `pulumi:"type"`
}

func (RecordFailoverRoutingPolicyArgs) ElementType 

func (RecordFailoverRoutingPolicyArgs) ElementType() reflect.Type

func (RecordFailoverRoutingPolicyArgs) ToRecordFailoverRoutingPolicyOutput 

func (i RecordFailoverRoutingPolicyArgs) ToRecordFailoverRoutingPolicyOutput() RecordFailoverRoutingPolicyOutput

func (RecordFailoverRoutingPolicyArgs) ToRecordFailoverRoutingPolicyOutputWithContext 

func (i RecordFailoverRoutingPolicyArgs) ToRecordFailoverRoutingPolicyOutputWithContext(ctx context.Context) RecordFailoverRoutingPolicyOutput

type RecordFailoverRoutingPolicyArray 

type RecordFailoverRoutingPolicyArray []RecordFailoverRoutingPolicyInput

func (RecordFailoverRoutingPolicyArray) ElementType 

func (RecordFailoverRoutingPolicyArray) ElementType() reflect.Type

func (RecordFailoverRoutingPolicyArray) ToRecordFailoverRoutingPolicyArrayOutput 

func (i RecordFailoverRoutingPolicyArray) ToRecordFailoverRoutingPolicyArrayOutput() RecordFailoverRoutingPolicyArrayOutput

func (RecordFailoverRoutingPolicyArray) ToRecordFailoverRoutingPolicyArrayOutputWithContext 

func (i RecordFailoverRoutingPolicyArray) ToRecordFailoverRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordFailoverRoutingPolicyArrayOutput

type RecordFailoverRoutingPolicyArrayInput 

type RecordFailoverRoutingPolicyArrayInput interface {
	pulumi.Input

	ToRecordFailoverRoutingPolicyArrayOutput() RecordFailoverRoutingPolicyArrayOutput
	ToRecordFailoverRoutingPolicyArrayOutputWithContext(context.Context) RecordFailoverRoutingPolicyArrayOutput
}

RecordFailoverRoutingPolicyArrayInput is an input type that accepts RecordFailoverRoutingPolicyArray and RecordFailoverRoutingPolicyArrayOutput values. You can construct a concrete instance of `RecordFailoverRoutingPolicyArrayInput` via: 

RecordFailoverRoutingPolicyArray{ RecordFailoverRoutingPolicyArgs{...} }

type RecordFailoverRoutingPolicyArrayOutput 

type RecordFailoverRoutingPolicyArrayOutput struct{ *pulumi.OutputState }

func (RecordFailoverRoutingPolicyArrayOutput) ElementType 

func (RecordFailoverRoutingPolicyArrayOutput) ElementType() reflect.Type

func (RecordFailoverRoutingPolicyArrayOutput) Index 

func (o RecordFailoverRoutingPolicyArrayOutput) Index(i pulumi.IntInput) RecordFailoverRoutingPolicyOutput

func (RecordFailoverRoutingPolicyArrayOutput) ToRecordFailoverRoutingPolicyArrayOutput 

func (o RecordFailoverRoutingPolicyArrayOutput) ToRecordFailoverRoutingPolicyArrayOutput() RecordFailoverRoutingPolicyArrayOutput

func (RecordFailoverRoutingPolicyArrayOutput) ToRecordFailoverRoutingPolicyArrayOutputWithContext 

func (o RecordFailoverRoutingPolicyArrayOutput) ToRecordFailoverRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordFailoverRoutingPolicyArrayOutput

type RecordFailoverRoutingPolicyInput 

type RecordFailoverRoutingPolicyInput interface {
	pulumi.Input

	ToRecordFailoverRoutingPolicyOutput() RecordFailoverRoutingPolicyOutput
	ToRecordFailoverRoutingPolicyOutputWithContext(context.Context) RecordFailoverRoutingPolicyOutput
}

RecordFailoverRoutingPolicyInput is an input type that accepts RecordFailoverRoutingPolicyArgs and RecordFailoverRoutingPolicyOutput values. You can construct a concrete instance of `RecordFailoverRoutingPolicyInput` via: 

RecordFailoverRoutingPolicyArgs{...}

type RecordFailoverRoutingPolicyOutput 

type RecordFailoverRoutingPolicyOutput struct{ *pulumi.OutputState }

func (RecordFailoverRoutingPolicyOutput) ElementType 

func (RecordFailoverRoutingPolicyOutput) ElementType() reflect.Type

func (RecordFailoverRoutingPolicyOutput) ToRecordFailoverRoutingPolicyOutput 

func (o RecordFailoverRoutingPolicyOutput) ToRecordFailoverRoutingPolicyOutput() RecordFailoverRoutingPolicyOutput

func (RecordFailoverRoutingPolicyOutput) ToRecordFailoverRoutingPolicyOutputWithContext 

func (o RecordFailoverRoutingPolicyOutput) ToRecordFailoverRoutingPolicyOutputWithContext(ctx context.Context) RecordFailoverRoutingPolicyOutput

func (RecordFailoverRoutingPolicyOutput) Type 

func (o RecordFailoverRoutingPolicyOutput) Type() pulumi.StringOutput

`PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets

type RecordGeolocationRoutingPolicy 

type RecordGeolocationRoutingPolicy struct {
	// A two-letter continent code. See http://docs.aws.amazon.com/Route53/latest/APIReference/API_GetGeoLocation.html for code details. Either `continent` or `country` must be specified.
	Continent *string `pulumi:"continent"`
	// A two-character country code or `*` to indicate a default resource record set.
	Country *string `pulumi:"country"`
	// A subdivision code for a country.
	Subdivision *string `pulumi:"subdivision"`
}

type RecordGeolocationRoutingPolicyArgs 

type RecordGeolocationRoutingPolicyArgs struct {
	// A two-letter continent code. See http://docs.aws.amazon.com/Route53/latest/APIReference/API_GetGeoLocation.html for code details. Either `continent` or `country` must be specified.
	Continent pulumi.StringPtrInput `pulumi:"continent"`
	// A two-character country code or `*` to indicate a default resource record set.
	Country pulumi.StringPtrInput `pulumi:"country"`
	// A subdivision code for a country.
	Subdivision pulumi.StringPtrInput `pulumi:"subdivision"`
}

func (RecordGeolocationRoutingPolicyArgs) ElementType 

func (RecordGeolocationRoutingPolicyArgs) ElementType() reflect.Type

func (RecordGeolocationRoutingPolicyArgs) ToRecordGeolocationRoutingPolicyOutput 

func (i RecordGeolocationRoutingPolicyArgs) ToRecordGeolocationRoutingPolicyOutput() RecordGeolocationRoutingPolicyOutput

func (RecordGeolocationRoutingPolicyArgs) ToRecordGeolocationRoutingPolicyOutputWithContext 

func (i RecordGeolocationRoutingPolicyArgs) ToRecordGeolocationRoutingPolicyOutputWithContext(ctx context.Context) RecordGeolocationRoutingPolicyOutput

type RecordGeolocationRoutingPolicyArray 

type RecordGeolocationRoutingPolicyArray []RecordGeolocationRoutingPolicyInput

func (RecordGeolocationRoutingPolicyArray) ElementType 

func (RecordGeolocationRoutingPolicyArray) ElementType() reflect.Type

func (RecordGeolocationRoutingPolicyArray) ToRecordGeolocationRoutingPolicyArrayOutput 

func (i RecordGeolocationRoutingPolicyArray) ToRecordGeolocationRoutingPolicyArrayOutput() RecordGeolocationRoutingPolicyArrayOutput

func (RecordGeolocationRoutingPolicyArray) ToRecordGeolocationRoutingPolicyArrayOutputWithContext 

func (i RecordGeolocationRoutingPolicyArray) ToRecordGeolocationRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordGeolocationRoutingPolicyArrayOutput

type RecordGeolocationRoutingPolicyArrayInput 

type RecordGeolocationRoutingPolicyArrayInput interface {
	pulumi.Input

	ToRecordGeolocationRoutingPolicyArrayOutput() RecordGeolocationRoutingPolicyArrayOutput
	ToRecordGeolocationRoutingPolicyArrayOutputWithContext(context.Context) RecordGeolocationRoutingPolicyArrayOutput
}

RecordGeolocationRoutingPolicyArrayInput is an input type that accepts RecordGeolocationRoutingPolicyArray and RecordGeolocationRoutingPolicyArrayOutput values. You can construct a concrete instance of `RecordGeolocationRoutingPolicyArrayInput` via: 

RecordGeolocationRoutingPolicyArray{ RecordGeolocationRoutingPolicyArgs{...} }

type RecordGeolocationRoutingPolicyArrayOutput 

type RecordGeolocationRoutingPolicyArrayOutput struct{ *pulumi.OutputState }

func (RecordGeolocationRoutingPolicyArrayOutput) ElementType 

func (RecordGeolocationRoutingPolicyArrayOutput) ElementType() reflect.Type

func (RecordGeolocationRoutingPolicyArrayOutput) Index 

func (o RecordGeolocationRoutingPolicyArrayOutput) Index(i pulumi.IntInput) RecordGeolocationRoutingPolicyOutput

func (RecordGeolocationRoutingPolicyArrayOutput) ToRecordGeolocationRoutingPolicyArrayOutput 

func (o RecordGeolocationRoutingPolicyArrayOutput) ToRecordGeolocationRoutingPolicyArrayOutput() RecordGeolocationRoutingPolicyArrayOutput

func (RecordGeolocationRoutingPolicyArrayOutput) ToRecordGeolocationRoutingPolicyArrayOutputWithContext 

func (o RecordGeolocationRoutingPolicyArrayOutput) ToRecordGeolocationRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordGeolocationRoutingPolicyArrayOutput

type RecordGeolocationRoutingPolicyInput 

type RecordGeolocationRoutingPolicyInput interface {
	pulumi.Input

	ToRecordGeolocationRoutingPolicyOutput() RecordGeolocationRoutingPolicyOutput
	ToRecordGeolocationRoutingPolicyOutputWithContext(context.Context) RecordGeolocationRoutingPolicyOutput
}

RecordGeolocationRoutingPolicyInput is an input type that accepts RecordGeolocationRoutingPolicyArgs and RecordGeolocationRoutingPolicyOutput values. You can construct a concrete instance of `RecordGeolocationRoutingPolicyInput` via: 

RecordGeolocationRoutingPolicyArgs{...}

type RecordGeolocationRoutingPolicyOutput 

type RecordGeolocationRoutingPolicyOutput struct{ *pulumi.OutputState }

func (RecordGeolocationRoutingPolicyOutput) Continent 

func (o RecordGeolocationRoutingPolicyOutput) Continent() pulumi.StringPtrOutput

A two-letter continent code. See http://docs.aws.amazon.com/Route53/latest/APIReference/API_GetGeoLocation.html for code details. Either `continent` or `country` must be specified.

func (RecordGeolocationRoutingPolicyOutput) Country 

func (o RecordGeolocationRoutingPolicyOutput) Country() pulumi.StringPtrOutput

A two-character country code or `*` to indicate a default resource record set.

func (RecordGeolocationRoutingPolicyOutput) ElementType 

func (RecordGeolocationRoutingPolicyOutput) ElementType() reflect.Type

func (RecordGeolocationRoutingPolicyOutput) Subdivision 

func (o RecordGeolocationRoutingPolicyOutput) Subdivision() pulumi.StringPtrOutput

A subdivision code for a country.

func (RecordGeolocationRoutingPolicyOutput) ToRecordGeolocationRoutingPolicyOutput 

func (o RecordGeolocationRoutingPolicyOutput) ToRecordGeolocationRoutingPolicyOutput() RecordGeolocationRoutingPolicyOutput

func (RecordGeolocationRoutingPolicyOutput) ToRecordGeolocationRoutingPolicyOutputWithContext 

func (o RecordGeolocationRoutingPolicyOutput) ToRecordGeolocationRoutingPolicyOutputWithContext(ctx context.Context) RecordGeolocationRoutingPolicyOutput

type RecordInput added in v3.13.0 

type RecordInput interface {
	pulumi.Input

	ToRecordOutput() RecordOutput
	ToRecordOutputWithContext(ctx context.Context) RecordOutput
}

type RecordLatencyRoutingPolicy 

type RecordLatencyRoutingPolicy struct {
	// An AWS region from which to measure latency. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-latency
	Region string `pulumi:"region"`
}

type RecordLatencyRoutingPolicyArgs 

type RecordLatencyRoutingPolicyArgs struct {
	// An AWS region from which to measure latency. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-latency
	Region pulumi.StringInput `pulumi:"region"`
}

func (RecordLatencyRoutingPolicyArgs) ElementType 

func (RecordLatencyRoutingPolicyArgs) ElementType() reflect.Type

func (RecordLatencyRoutingPolicyArgs) ToRecordLatencyRoutingPolicyOutput 

func (i RecordLatencyRoutingPolicyArgs) ToRecordLatencyRoutingPolicyOutput() RecordLatencyRoutingPolicyOutput

func (RecordLatencyRoutingPolicyArgs) ToRecordLatencyRoutingPolicyOutputWithContext 

func (i RecordLatencyRoutingPolicyArgs) ToRecordLatencyRoutingPolicyOutputWithContext(ctx context.Context) RecordLatencyRoutingPolicyOutput

type RecordLatencyRoutingPolicyArray 

type RecordLatencyRoutingPolicyArray []RecordLatencyRoutingPolicyInput

func (RecordLatencyRoutingPolicyArray) ElementType 

func (RecordLatencyRoutingPolicyArray) ElementType() reflect.Type

func (RecordLatencyRoutingPolicyArray) ToRecordLatencyRoutingPolicyArrayOutput 

func (i RecordLatencyRoutingPolicyArray) ToRecordLatencyRoutingPolicyArrayOutput() RecordLatencyRoutingPolicyArrayOutput

func (RecordLatencyRoutingPolicyArray) ToRecordLatencyRoutingPolicyArrayOutputWithContext 

func (i RecordLatencyRoutingPolicyArray) ToRecordLatencyRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordLatencyRoutingPolicyArrayOutput

type RecordLatencyRoutingPolicyArrayInput 

type RecordLatencyRoutingPolicyArrayInput interface {
	pulumi.Input

	ToRecordLatencyRoutingPolicyArrayOutput() RecordLatencyRoutingPolicyArrayOutput
	ToRecordLatencyRoutingPolicyArrayOutputWithContext(context.Context) RecordLatencyRoutingPolicyArrayOutput
}

RecordLatencyRoutingPolicyArrayInput is an input type that accepts RecordLatencyRoutingPolicyArray and RecordLatencyRoutingPolicyArrayOutput values. You can construct a concrete instance of `RecordLatencyRoutingPolicyArrayInput` via: 

RecordLatencyRoutingPolicyArray{ RecordLatencyRoutingPolicyArgs{...} }

type RecordLatencyRoutingPolicyArrayOutput 

type RecordLatencyRoutingPolicyArrayOutput struct{ *pulumi.OutputState }

func (RecordLatencyRoutingPolicyArrayOutput) ElementType 

func (RecordLatencyRoutingPolicyArrayOutput) ElementType() reflect.Type

func (RecordLatencyRoutingPolicyArrayOutput) Index 

func (o RecordLatencyRoutingPolicyArrayOutput) Index(i pulumi.IntInput) RecordLatencyRoutingPolicyOutput

func (RecordLatencyRoutingPolicyArrayOutput) ToRecordLatencyRoutingPolicyArrayOutput 

func (o RecordLatencyRoutingPolicyArrayOutput) ToRecordLatencyRoutingPolicyArrayOutput() RecordLatencyRoutingPolicyArrayOutput

func (RecordLatencyRoutingPolicyArrayOutput) ToRecordLatencyRoutingPolicyArrayOutputWithContext 

func (o RecordLatencyRoutingPolicyArrayOutput) ToRecordLatencyRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordLatencyRoutingPolicyArrayOutput

type RecordLatencyRoutingPolicyInput 

type RecordLatencyRoutingPolicyInput interface {
	pulumi.Input

	ToRecordLatencyRoutingPolicyOutput() RecordLatencyRoutingPolicyOutput
	ToRecordLatencyRoutingPolicyOutputWithContext(context.Context) RecordLatencyRoutingPolicyOutput
}

RecordLatencyRoutingPolicyInput is an input type that accepts RecordLatencyRoutingPolicyArgs and RecordLatencyRoutingPolicyOutput values. You can construct a concrete instance of `RecordLatencyRoutingPolicyInput` via: 

RecordLatencyRoutingPolicyArgs{...}

type RecordLatencyRoutingPolicyOutput 

type RecordLatencyRoutingPolicyOutput struct{ *pulumi.OutputState }

func (RecordLatencyRoutingPolicyOutput) ElementType 

func (RecordLatencyRoutingPolicyOutput) ElementType() reflect.Type

func (RecordLatencyRoutingPolicyOutput) Region 

func (o RecordLatencyRoutingPolicyOutput) Region() pulumi.StringOutput

An AWS region from which to measure latency. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-latency

func (RecordLatencyRoutingPolicyOutput) ToRecordLatencyRoutingPolicyOutput 

func (o RecordLatencyRoutingPolicyOutput) ToRecordLatencyRoutingPolicyOutput() RecordLatencyRoutingPolicyOutput

func (RecordLatencyRoutingPolicyOutput) ToRecordLatencyRoutingPolicyOutputWithContext 

func (o RecordLatencyRoutingPolicyOutput) ToRecordLatencyRoutingPolicyOutputWithContext(ctx context.Context) RecordLatencyRoutingPolicyOutput

type RecordOutput added in v3.13.0 

type RecordOutput struct {
	*pulumi.OutputState
}

func (RecordOutput) ElementType added in v3.13.0 

func (RecordOutput) ElementType() reflect.Type

func (RecordOutput) ToRecordOutput added in v3.13.0 

func (o RecordOutput) ToRecordOutput() RecordOutput

func (RecordOutput) ToRecordOutputWithContext added in v3.13.0 

func (o RecordOutput) ToRecordOutputWithContext(ctx context.Context) RecordOutput

type RecordState 

type RecordState struct {
	// An alias block. Conflicts with `ttl` & `records`.
	// Alias record documented below.
	Aliases RecordAliasArrayInput
	// Allow creation of this record to overwrite an existing record, if any. This does not affect the ability to update the record using this provider and does not prevent other resources within this provider or manual Route 53 changes outside this provider from overwriting this record. `false` by default. This configuration is not recommended for most environments.
	AllowOverwrite pulumi.BoolPtrInput
	// A block indicating the routing behavior when associated health check fails. Conflicts with any other routing policy. Documented below.
	FailoverRoutingPolicies RecordFailoverRoutingPolicyArrayInput
	// [FQDN](https://en.wikipedia.org/wiki/Fully_qualified_domain_name) built using the zone domain and `name`.
	Fqdn pulumi.StringPtrInput
	// A block indicating a routing policy based on the geolocation of the requestor. Conflicts with any other routing policy. Documented below.
	GeolocationRoutingPolicies RecordGeolocationRoutingPolicyArrayInput
	// The health check the record should be associated with.
	HealthCheckId pulumi.StringPtrInput
	// A block indicating a routing policy based on the latency between the requestor and an AWS region. Conflicts with any other routing policy. Documented below.
	LatencyRoutingPolicies RecordLatencyRoutingPolicyArrayInput
	// Set to `true` to indicate a multivalue answer routing policy. Conflicts with any other routing policy.
	MultivalueAnswerRoutingPolicy pulumi.BoolPtrInput
	// DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.
	Name pulumi.StringPtrInput
	// A string list of records. To specify a single record value longer than 255 characters such as a TXT record for DKIM, add `\"\"` inside the configuration string (e.g. `"first255characters\"\"morecharacters"`).
	Records pulumi.StringArrayInput
	// Unique identifier to differentiate records with routing policies from one another. Required if using `failover`, `geolocation`, `latency`, or `weighted` routing policies documented below.
	SetIdentifier pulumi.StringPtrInput
	// The TTL of the record.
	Ttl pulumi.IntPtrInput
	// `PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets
	Type pulumi.StringPtrInput
	// A block indicating a weighted routing policy. Conflicts with any other routing policy. Documented below.
	WeightedRoutingPolicies RecordWeightedRoutingPolicyArrayInput
	// Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.
	ZoneId pulumi.StringPtrInput
}

func (RecordState) ElementType 

func (RecordState) ElementType() reflect.Type

type RecordWeightedRoutingPolicy 

type RecordWeightedRoutingPolicy struct {
	// A numeric value indicating the relative weight of the record. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-weighted.
	Weight int `pulumi:"weight"`
}

type RecordWeightedRoutingPolicyArgs 

type RecordWeightedRoutingPolicyArgs struct {
	// A numeric value indicating the relative weight of the record. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-weighted.
	Weight pulumi.IntInput `pulumi:"weight"`
}

func (RecordWeightedRoutingPolicyArgs) ElementType 

func (RecordWeightedRoutingPolicyArgs) ElementType() reflect.Type

func (RecordWeightedRoutingPolicyArgs) ToRecordWeightedRoutingPolicyOutput 

func (i RecordWeightedRoutingPolicyArgs) ToRecordWeightedRoutingPolicyOutput() RecordWeightedRoutingPolicyOutput

func (RecordWeightedRoutingPolicyArgs) ToRecordWeightedRoutingPolicyOutputWithContext 

func (i RecordWeightedRoutingPolicyArgs) ToRecordWeightedRoutingPolicyOutputWithContext(ctx context.Context) RecordWeightedRoutingPolicyOutput

type RecordWeightedRoutingPolicyArray 

type RecordWeightedRoutingPolicyArray []RecordWeightedRoutingPolicyInput

func (RecordWeightedRoutingPolicyArray) ElementType 

func (RecordWeightedRoutingPolicyArray) ElementType() reflect.Type

func (RecordWeightedRoutingPolicyArray) ToRecordWeightedRoutingPolicyArrayOutput 

func (i RecordWeightedRoutingPolicyArray) ToRecordWeightedRoutingPolicyArrayOutput() RecordWeightedRoutingPolicyArrayOutput

func (RecordWeightedRoutingPolicyArray) ToRecordWeightedRoutingPolicyArrayOutputWithContext 

func (i RecordWeightedRoutingPolicyArray) ToRecordWeightedRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordWeightedRoutingPolicyArrayOutput

type RecordWeightedRoutingPolicyArrayInput 

type RecordWeightedRoutingPolicyArrayInput interface {
	pulumi.Input

	ToRecordWeightedRoutingPolicyArrayOutput() RecordWeightedRoutingPolicyArrayOutput
	ToRecordWeightedRoutingPolicyArrayOutputWithContext(context.Context) RecordWeightedRoutingPolicyArrayOutput
}

RecordWeightedRoutingPolicyArrayInput is an input type that accepts RecordWeightedRoutingPolicyArray and RecordWeightedRoutingPolicyArrayOutput values. You can construct a concrete instance of `RecordWeightedRoutingPolicyArrayInput` via: 

RecordWeightedRoutingPolicyArray{ RecordWeightedRoutingPolicyArgs{...} }

type RecordWeightedRoutingPolicyArrayOutput 

type RecordWeightedRoutingPolicyArrayOutput struct{ *pulumi.OutputState }

func (RecordWeightedRoutingPolicyArrayOutput) ElementType 

func (RecordWeightedRoutingPolicyArrayOutput) ElementType() reflect.Type

func (RecordWeightedRoutingPolicyArrayOutput) Index 

func (o RecordWeightedRoutingPolicyArrayOutput) Index(i pulumi.IntInput) RecordWeightedRoutingPolicyOutput

func (RecordWeightedRoutingPolicyArrayOutput) ToRecordWeightedRoutingPolicyArrayOutput 

func (o RecordWeightedRoutingPolicyArrayOutput) ToRecordWeightedRoutingPolicyArrayOutput() RecordWeightedRoutingPolicyArrayOutput

func (RecordWeightedRoutingPolicyArrayOutput) ToRecordWeightedRoutingPolicyArrayOutputWithContext 

func (o RecordWeightedRoutingPolicyArrayOutput) ToRecordWeightedRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordWeightedRoutingPolicyArrayOutput

type RecordWeightedRoutingPolicyInput 

type RecordWeightedRoutingPolicyInput interface {
	pulumi.Input

	ToRecordWeightedRoutingPolicyOutput() RecordWeightedRoutingPolicyOutput
	ToRecordWeightedRoutingPolicyOutputWithContext(context.Context) RecordWeightedRoutingPolicyOutput
}

RecordWeightedRoutingPolicyInput is an input type that accepts RecordWeightedRoutingPolicyArgs and RecordWeightedRoutingPolicyOutput values. You can construct a concrete instance of `RecordWeightedRoutingPolicyInput` via: 

RecordWeightedRoutingPolicyArgs{...}

type RecordWeightedRoutingPolicyOutput 

type RecordWeightedRoutingPolicyOutput struct{ *pulumi.OutputState }

func (RecordWeightedRoutingPolicyOutput) ElementType 

func (RecordWeightedRoutingPolicyOutput) ElementType() reflect.Type

func (RecordWeightedRoutingPolicyOutput) ToRecordWeightedRoutingPolicyOutput 

func (o RecordWeightedRoutingPolicyOutput) ToRecordWeightedRoutingPolicyOutput() RecordWeightedRoutingPolicyOutput

func (RecordWeightedRoutingPolicyOutput) ToRecordWeightedRoutingPolicyOutputWithContext 

func (o RecordWeightedRoutingPolicyOutput) ToRecordWeightedRoutingPolicyOutputWithContext(ctx context.Context) RecordWeightedRoutingPolicyOutput

func (RecordWeightedRoutingPolicyOutput) Weight 

func (o RecordWeightedRoutingPolicyOutput) Weight() pulumi.IntOutput

A numeric value indicating the relative weight of the record. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-weighted.

type ResolverEndpoint 

type ResolverEndpoint struct {
	pulumi.CustomResourceState

	// The ARN of the Route 53 Resolver endpoint.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The direction of DNS queries to or from the Route 53 Resolver endpoint.
	// Valid values are `INBOUND` (resolver forwards DNS queries to the DNS service for a VPC from your network or another VPC)
	// or `OUTBOUND` (resolver forwards DNS queries from the DNS service for a VPC to your network or another VPC).
	Direction pulumi.StringOutput `pulumi:"direction"`
	// The ID of the VPC that you want to create the resolver endpoint in.
	HostVpcId pulumi.StringOutput `pulumi:"hostVpcId"`
	// The subnets and IP addresses in your VPC that you want DNS queries to pass through on the way from your VPCs
	// to your network (for outbound endpoints) or on the way from your network to your VPCs (for inbound endpoints). Described below.
	IpAddresses ResolverEndpointIpAddressArrayOutput `pulumi:"ipAddresses"`
	// The friendly name of the Route 53 Resolver endpoint.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of one or more security groups that you want to use to control access to this VPC.
	SecurityGroupIds pulumi.StringArrayOutput `pulumi:"securityGroupIds"`
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Provides a Route 53 Resolver endpoint resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverEndpoint(ctx, "foo", &route53.ResolverEndpointArgs{
			Direction: pulumi.String("INBOUND"),
			SecurityGroupIds: pulumi.StringArray{
				pulumi.Any(aws_security_group.Sg1.Id),
				pulumi.Any(aws_security_group.Sg2.Id),
			},
			IpAddresses: route53.ResolverEndpointIpAddressArray{
				&route53.ResolverEndpointIpAddressArgs{
					SubnetId: pulumi.Any(aws_subnet.Sn1.Id),
				},
				&route53.ResolverEndpointIpAddressArgs{
					SubnetId: pulumi.Any(aws_subnet.Sn2.Id),
					Ip:       pulumi.String("10.0.64.4"),
				},
			},
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("Prod"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import 

Route 53 Resolver endpoints can be imported using the Route 53 Resolver endpoint ID, e.g.

```sh 

$ pulumi import aws:route53/resolverEndpoint:ResolverEndpoint foo rslvr-in-abcdef01234567890

```

func GetResolverEndpoint 

func GetResolverEndpoint(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverEndpointState, opts ...pulumi.ResourceOption) (*ResolverEndpoint, error)

GetResolverEndpoint gets an existing ResolverEndpoint 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 NewResolverEndpoint 

func NewResolverEndpoint(ctx *pulumi.Context,
	name string, args *ResolverEndpointArgs, opts ...pulumi.ResourceOption) (*ResolverEndpoint, error)

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

func (ResolverEndpoint) ElementType added in v3.13.0 

func (ResolverEndpoint) ElementType() reflect.Type

func (ResolverEndpoint) ToResolverEndpointOutput added in v3.13.0 

func (i ResolverEndpoint) ToResolverEndpointOutput() ResolverEndpointOutput

func (ResolverEndpoint) ToResolverEndpointOutputWithContext added in v3.13.0 

func (i ResolverEndpoint) ToResolverEndpointOutputWithContext(ctx context.Context) ResolverEndpointOutput

type ResolverEndpointArgs 

type ResolverEndpointArgs struct {
	// The direction of DNS queries to or from the Route 53 Resolver endpoint.
	// Valid values are `INBOUND` (resolver forwards DNS queries to the DNS service for a VPC from your network or another VPC)
	// or `OUTBOUND` (resolver forwards DNS queries from the DNS service for a VPC to your network or another VPC).
	Direction pulumi.StringInput
	// The subnets and IP addresses in your VPC that you want DNS queries to pass through on the way from your VPCs
	// to your network (for outbound endpoints) or on the way from your network to your VPCs (for inbound endpoints). Described below.
	IpAddresses ResolverEndpointIpAddressArrayInput
	// The friendly name of the Route 53 Resolver endpoint.
	Name pulumi.StringPtrInput
	// The ID of one or more security groups that you want to use to control access to this VPC.
	SecurityGroupIds pulumi.StringArrayInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a ResolverEndpoint resource.

func (ResolverEndpointArgs) ElementType 

func (ResolverEndpointArgs) ElementType() reflect.Type

type ResolverEndpointInput added in v3.13.0 

type ResolverEndpointInput interface {
	pulumi.Input

	ToResolverEndpointOutput() ResolverEndpointOutput
	ToResolverEndpointOutputWithContext(ctx context.Context) ResolverEndpointOutput
}

type ResolverEndpointIpAddress 

type ResolverEndpointIpAddress struct {
	// The IP address in the subnet that you want to use for DNS queries.
	Ip   *string `pulumi:"ip"`
	IpId *string `pulumi:"ipId"`
	// The ID of the subnet that contains the IP address.
	SubnetId string `pulumi:"subnetId"`
}

type ResolverEndpointIpAddressArgs 

type ResolverEndpointIpAddressArgs struct {
	// The IP address in the subnet that you want to use for DNS queries.
	Ip   pulumi.StringPtrInput `pulumi:"ip"`
	IpId pulumi.StringPtrInput `pulumi:"ipId"`
	// The ID of the subnet that contains the IP address.
	SubnetId pulumi.StringInput `pulumi:"subnetId"`
}

func (ResolverEndpointIpAddressArgs) ElementType 

func (ResolverEndpointIpAddressArgs) ElementType() reflect.Type

func (ResolverEndpointIpAddressArgs) ToResolverEndpointIpAddressOutput 

func (i ResolverEndpointIpAddressArgs) ToResolverEndpointIpAddressOutput() ResolverEndpointIpAddressOutput

func (ResolverEndpointIpAddressArgs) ToResolverEndpointIpAddressOutputWithContext 

func (i ResolverEndpointIpAddressArgs) ToResolverEndpointIpAddressOutputWithContext(ctx context.Context) ResolverEndpointIpAddressOutput

type ResolverEndpointIpAddressArray 

type ResolverEndpointIpAddressArray []ResolverEndpointIpAddressInput

func (ResolverEndpointIpAddressArray) ElementType 

func (ResolverEndpointIpAddressArray) ElementType() reflect.Type

func (ResolverEndpointIpAddressArray) ToResolverEndpointIpAddressArrayOutput 

func (i ResolverEndpointIpAddressArray) ToResolverEndpointIpAddressArrayOutput() ResolverEndpointIpAddressArrayOutput

func (ResolverEndpointIpAddressArray) ToResolverEndpointIpAddressArrayOutputWithContext 

func (i ResolverEndpointIpAddressArray) ToResolverEndpointIpAddressArrayOutputWithContext(ctx context.Context) ResolverEndpointIpAddressArrayOutput

type ResolverEndpointIpAddressArrayInput 

type ResolverEndpointIpAddressArrayInput interface {
	pulumi.Input

	ToResolverEndpointIpAddressArrayOutput() ResolverEndpointIpAddressArrayOutput
	ToResolverEndpointIpAddressArrayOutputWithContext(context.Context) ResolverEndpointIpAddressArrayOutput
}

ResolverEndpointIpAddressArrayInput is an input type that accepts ResolverEndpointIpAddressArray and ResolverEndpointIpAddressArrayOutput values. You can construct a concrete instance of `ResolverEndpointIpAddressArrayInput` via: 

ResolverEndpointIpAddressArray{ ResolverEndpointIpAddressArgs{...} }

type ResolverEndpointIpAddressArrayOutput 

type ResolverEndpointIpAddressArrayOutput struct{ *pulumi.OutputState }

func (ResolverEndpointIpAddressArrayOutput) ElementType 

func (ResolverEndpointIpAddressArrayOutput) ElementType() reflect.Type

func (ResolverEndpointIpAddressArrayOutput) Index 

func (o ResolverEndpointIpAddressArrayOutput) Index(i pulumi.IntInput) ResolverEndpointIpAddressOutput

func (ResolverEndpointIpAddressArrayOutput) ToResolverEndpointIpAddressArrayOutput 

func (o ResolverEndpointIpAddressArrayOutput) ToResolverEndpointIpAddressArrayOutput() ResolverEndpointIpAddressArrayOutput

func (ResolverEndpointIpAddressArrayOutput) ToResolverEndpointIpAddressArrayOutputWithContext 

func (o ResolverEndpointIpAddressArrayOutput) ToResolverEndpointIpAddressArrayOutputWithContext(ctx context.Context) ResolverEndpointIpAddressArrayOutput

type ResolverEndpointIpAddressInput 

type ResolverEndpointIpAddressInput interface {
	pulumi.Input

	ToResolverEndpointIpAddressOutput() ResolverEndpointIpAddressOutput
	ToResolverEndpointIpAddressOutputWithContext(context.Context) ResolverEndpointIpAddressOutput
}

ResolverEndpointIpAddressInput is an input type that accepts ResolverEndpointIpAddressArgs and ResolverEndpointIpAddressOutput values. You can construct a concrete instance of `ResolverEndpointIpAddressInput` via: 

ResolverEndpointIpAddressArgs{...}

type ResolverEndpointIpAddressOutput 

type ResolverEndpointIpAddressOutput struct{ *pulumi.OutputState }

func (ResolverEndpointIpAddressOutput) ElementType 

func (ResolverEndpointIpAddressOutput) ElementType() reflect.Type

func (ResolverEndpointIpAddressOutput) Ip 

func (o ResolverEndpointIpAddressOutput) Ip() pulumi.StringPtrOutput

The IP address in the subnet that you want to use for DNS queries.

func (ResolverEndpointIpAddressOutput) IpId 

func (o ResolverEndpointIpAddressOutput) IpId() pulumi.StringPtrOutput

func (ResolverEndpointIpAddressOutput) SubnetId 

func (o ResolverEndpointIpAddressOutput) SubnetId() pulumi.StringOutput

The ID of the subnet that contains the IP address.

func (ResolverEndpointIpAddressOutput) ToResolverEndpointIpAddressOutput 

func (o ResolverEndpointIpAddressOutput) ToResolverEndpointIpAddressOutput() ResolverEndpointIpAddressOutput

func (ResolverEndpointIpAddressOutput) ToResolverEndpointIpAddressOutputWithContext 

func (o ResolverEndpointIpAddressOutput) ToResolverEndpointIpAddressOutputWithContext(ctx context.Context) ResolverEndpointIpAddressOutput

type ResolverEndpointOutput added in v3.13.0 

type ResolverEndpointOutput struct {
	*pulumi.OutputState
}

func (ResolverEndpointOutput) ElementType added in v3.13.0 

func (ResolverEndpointOutput) ElementType() reflect.Type

func (ResolverEndpointOutput) ToResolverEndpointOutput added in v3.13.0 

func (o ResolverEndpointOutput) ToResolverEndpointOutput() ResolverEndpointOutput

func (ResolverEndpointOutput) ToResolverEndpointOutputWithContext added in v3.13.0 

func (o ResolverEndpointOutput) ToResolverEndpointOutputWithContext(ctx context.Context) ResolverEndpointOutput

type ResolverEndpointState 

type ResolverEndpointState struct {
	// The ARN of the Route 53 Resolver endpoint.
	Arn pulumi.StringPtrInput
	// The direction of DNS queries to or from the Route 53 Resolver endpoint.
	// Valid values are `INBOUND` (resolver forwards DNS queries to the DNS service for a VPC from your network or another VPC)
	// or `OUTBOUND` (resolver forwards DNS queries from the DNS service for a VPC to your network or another VPC).
	Direction pulumi.StringPtrInput
	// The ID of the VPC that you want to create the resolver endpoint in.
	HostVpcId pulumi.StringPtrInput
	// The subnets and IP addresses in your VPC that you want DNS queries to pass through on the way from your VPCs
	// to your network (for outbound endpoints) or on the way from your network to your VPCs (for inbound endpoints). Described below.
	IpAddresses ResolverEndpointIpAddressArrayInput
	// The friendly name of the Route 53 Resolver endpoint.
	Name pulumi.StringPtrInput
	// The ID of one or more security groups that you want to use to control access to this VPC.
	SecurityGroupIds pulumi.StringArrayInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

func (ResolverEndpointState) ElementType 

func (ResolverEndpointState) ElementType() reflect.Type

type ResolverQueryLogConfig added in v3.5.0 

type ResolverQueryLogConfig struct {
	pulumi.CustomResourceState

	// The ARN (Amazon Resource Name) of the Route 53 Resolver query logging configuration.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The ARN of the resource that you want Route 53 Resolver to send query logs.
	// You can send query logs to an S3 bucket, a CloudWatch Logs log group, or a Kinesis Data Firehose delivery stream.
	DestinationArn pulumi.StringOutput `pulumi:"destinationArn"`
	// The name of the Route 53 Resolver query logging configuration.
	Name pulumi.StringOutput `pulumi:"name"`
	// The AWS account ID of the account that created the query logging configuration.
	OwnerId pulumi.StringOutput `pulumi:"ownerId"`
	// An indication of whether the query logging configuration is shared with other AWS accounts, or was shared with the current account by another AWS account.
	// Sharing is configured through AWS Resource Access Manager (AWS RAM).
	// Values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus pulumi.StringOutput `pulumi:"shareStatus"`
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Provides a Route 53 Resolver query logging configuration resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverQueryLogConfig(ctx, "example", &route53.ResolverQueryLogConfigArgs{
			DestinationArn: pulumi.Any(aws_s3_bucket.Example.Arn),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("Prod"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import 

Route 53 Resolver query logging configurations can be imported using the Route 53 Resolver query logging configuration ID, e.g.

```sh 

$ pulumi import aws:route53/resolverQueryLogConfig:ResolverQueryLogConfig example rqlc-92edc3b1838248bf

```

func GetResolverQueryLogConfig added in v3.5.0 

func GetResolverQueryLogConfig(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverQueryLogConfigState, opts ...pulumi.ResourceOption) (*ResolverQueryLogConfig, error)

GetResolverQueryLogConfig gets an existing ResolverQueryLogConfig 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 NewResolverQueryLogConfig added in v3.5.0 

func NewResolverQueryLogConfig(ctx *pulumi.Context,
	name string, args *ResolverQueryLogConfigArgs, opts ...pulumi.ResourceOption) (*ResolverQueryLogConfig, error)

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

func (ResolverQueryLogConfig) ElementType added in v3.13.0 

func (ResolverQueryLogConfig) ElementType() reflect.Type

func (ResolverQueryLogConfig) ToResolverQueryLogConfigOutput added in v3.13.0 

func (i ResolverQueryLogConfig) ToResolverQueryLogConfigOutput() ResolverQueryLogConfigOutput

func (ResolverQueryLogConfig) ToResolverQueryLogConfigOutputWithContext added in v3.13.0 

func (i ResolverQueryLogConfig) ToResolverQueryLogConfigOutputWithContext(ctx context.Context) ResolverQueryLogConfigOutput

type ResolverQueryLogConfigArgs added in v3.5.0 

type ResolverQueryLogConfigArgs struct {
	// The ARN of the resource that you want Route 53 Resolver to send query logs.
	// You can send query logs to an S3 bucket, a CloudWatch Logs log group, or a Kinesis Data Firehose delivery stream.
	DestinationArn pulumi.StringInput
	// The name of the Route 53 Resolver query logging configuration.
	Name pulumi.StringPtrInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a ResolverQueryLogConfig resource.

func (ResolverQueryLogConfigArgs) ElementType added in v3.5.0 

func (ResolverQueryLogConfigArgs) ElementType() reflect.Type

type ResolverQueryLogConfigAssociation added in v3.5.0 

type ResolverQueryLogConfigAssociation struct {
	pulumi.CustomResourceState

	// The ID of the Route 53 Resolver query logging configuration that you want to associate a VPC with.
	ResolverQueryLogConfigId pulumi.StringOutput `pulumi:"resolverQueryLogConfigId"`
	// The ID of a VPC that you want this query logging configuration to log queries for.
	ResourceId pulumi.StringOutput `pulumi:"resourceId"`
}

Provides a Route 53 Resolver query logging configuration association resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverQueryLogConfigAssociation(ctx, "example", &route53.ResolverQueryLogConfigAssociationArgs{
			ResolverQueryLogConfigId: pulumi.Any(aws_route53_resolver_query_log_config.Example.Id),
			ResourceId:               pulumi.Any(aws_vpc.Example.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import 

Route 53 Resolver query logging configuration associations can be imported using the Route 53 Resolver query logging configuration association ID, e.g.

```sh 

$ pulumi import aws:route53/resolverQueryLogConfigAssociation:ResolverQueryLogConfigAssociation example rqlca-b320624fef3c4d70

```

func GetResolverQueryLogConfigAssociation added in v3.5.0 

func GetResolverQueryLogConfigAssociation(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverQueryLogConfigAssociationState, opts ...pulumi.ResourceOption) (*ResolverQueryLogConfigAssociation, error)

GetResolverQueryLogConfigAssociation gets an existing ResolverQueryLogConfigAssociation 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 NewResolverQueryLogConfigAssociation added in v3.5.0 

func NewResolverQueryLogConfigAssociation(ctx *pulumi.Context,
	name string, args *ResolverQueryLogConfigAssociationArgs, opts ...pulumi.ResourceOption) (*ResolverQueryLogConfigAssociation, error)

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

func (ResolverQueryLogConfigAssociation) ElementType added in v3.13.0 

func (ResolverQueryLogConfigAssociation) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationOutput added in v3.13.0 

func (i ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationOutput() ResolverQueryLogConfigAssociationOutput

func (ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationOutputWithContext added in v3.13.0 

func (i ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationOutput

type ResolverQueryLogConfigAssociationArgs added in v3.5.0 

type ResolverQueryLogConfigAssociationArgs struct {
	// The ID of the Route 53 Resolver query logging configuration that you want to associate a VPC with.
	ResolverQueryLogConfigId pulumi.StringInput
	// The ID of a VPC that you want this query logging configuration to log queries for.
	ResourceId pulumi.StringInput
}

The set of arguments for constructing a ResolverQueryLogConfigAssociation resource.

func (ResolverQueryLogConfigAssociationArgs) ElementType added in v3.5.0 

func (ResolverQueryLogConfigAssociationArgs) ElementType() reflect.Type

type ResolverQueryLogConfigAssociationInput added in v3.13.0 

type ResolverQueryLogConfigAssociationInput interface {
	pulumi.Input

	ToResolverQueryLogConfigAssociationOutput() ResolverQueryLogConfigAssociationOutput
	ToResolverQueryLogConfigAssociationOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationOutput
}

type ResolverQueryLogConfigAssociationOutput added in v3.13.0 

type ResolverQueryLogConfigAssociationOutput struct {
	*pulumi.OutputState
}

func (ResolverQueryLogConfigAssociationOutput) ElementType added in v3.13.0 

func (ResolverQueryLogConfigAssociationOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationOutput added in v3.13.0 

func (o ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationOutput() ResolverQueryLogConfigAssociationOutput

func (ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationOutputWithContext added in v3.13.0 

func (o ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationOutput

type ResolverQueryLogConfigAssociationState added in v3.5.0 

type ResolverQueryLogConfigAssociationState struct {
	// The ID of the Route 53 Resolver query logging configuration that you want to associate a VPC with.
	ResolverQueryLogConfigId pulumi.StringPtrInput
	// The ID of a VPC that you want this query logging configuration to log queries for.
	ResourceId pulumi.StringPtrInput
}

func (ResolverQueryLogConfigAssociationState) ElementType added in v3.5.0 

func (ResolverQueryLogConfigAssociationState) ElementType() reflect.Type

type ResolverQueryLogConfigInput added in v3.13.0 

type ResolverQueryLogConfigInput interface {
	pulumi.Input

	ToResolverQueryLogConfigOutput() ResolverQueryLogConfigOutput
	ToResolverQueryLogConfigOutputWithContext(ctx context.Context) ResolverQueryLogConfigOutput
}

type ResolverQueryLogConfigOutput added in v3.13.0 

type ResolverQueryLogConfigOutput struct {
	*pulumi.OutputState
}

func (ResolverQueryLogConfigOutput) ElementType added in v3.13.0 

func (ResolverQueryLogConfigOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigOutput) ToResolverQueryLogConfigOutput added in v3.13.0 

func (o ResolverQueryLogConfigOutput) ToResolverQueryLogConfigOutput() ResolverQueryLogConfigOutput

func (ResolverQueryLogConfigOutput) ToResolverQueryLogConfigOutputWithContext added in v3.13.0 

func (o ResolverQueryLogConfigOutput) ToResolverQueryLogConfigOutputWithContext(ctx context.Context) ResolverQueryLogConfigOutput

type ResolverQueryLogConfigState added in v3.5.0 

type ResolverQueryLogConfigState struct {
	// The ARN (Amazon Resource Name) of the Route 53 Resolver query logging configuration.
	Arn pulumi.StringPtrInput
	// The ARN of the resource that you want Route 53 Resolver to send query logs.
	// You can send query logs to an S3 bucket, a CloudWatch Logs log group, or a Kinesis Data Firehose delivery stream.
	DestinationArn pulumi.StringPtrInput
	// The name of the Route 53 Resolver query logging configuration.
	Name pulumi.StringPtrInput
	// The AWS account ID of the account that created the query logging configuration.
	OwnerId pulumi.StringPtrInput
	// An indication of whether the query logging configuration is shared with other AWS accounts, or was shared with the current account by another AWS account.
	// Sharing is configured through AWS Resource Access Manager (AWS RAM).
	// Values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus pulumi.StringPtrInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

func (ResolverQueryLogConfigState) ElementType added in v3.5.0 

func (ResolverQueryLogConfigState) ElementType() reflect.Type

type ResolverRule 

type ResolverRule struct {
	pulumi.CustomResourceState

	// The ARN (Amazon Resource Name) for the resolver rule.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// DNS queries for this domain name are forwarded to the IP addresses that are specified using `targetIp`.
	DomainName pulumi.StringOutput `pulumi:"domainName"`
	// A friendly name that lets you easily find a rule in the Resolver dashboard in the Route 53 console.
	Name pulumi.StringOutput `pulumi:"name"`
	// When a rule is shared with another AWS account, the account ID of the account that the rule is shared with.
	OwnerId pulumi.StringOutput `pulumi:"ownerId"`
	// The ID of the outbound resolver endpoint that you want to use to route DNS queries to the IP addresses that you specify using `targetIp`.
	// This argument should only be specified for `FORWARD` type rules.
	ResolverEndpointId pulumi.StringPtrOutput `pulumi:"resolverEndpointId"`
	// The rule type. Valid values are `FORWARD`, `SYSTEM` and `RECURSIVE`.
	RuleType pulumi.StringOutput `pulumi:"ruleType"`
	// Whether the rules is shared and, if so, whether the current account is sharing the rule with another account, or another account is sharing the rule with the current account.
	// Values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus pulumi.StringOutput `pulumi:"shareStatus"`
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Configuration block(s) indicating the IPs that you want Resolver to forward DNS queries to (documented below).
	// This argument should only be specified for `FORWARD` type rules.
	TargetIps ResolverRuleTargetIpArrayOutput `pulumi:"targetIps"`
}

Provides a Route53 Resolver rule.

## Example Usage ### System rule

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverRule(ctx, "sys", &route53.ResolverRuleArgs{
			DomainName: pulumi.String("subdomain.example.com"),
			RuleType:   pulumi.String("SYSTEM"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Forward rule

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverRule(ctx, "fwd", &route53.ResolverRuleArgs{
			DomainName:         pulumi.String("example.com"),
			RuleType:           pulumi.String("FORWARD"),
			ResolverEndpointId: pulumi.Any(aws_route53_resolver_endpoint.Foo.Id),
			TargetIps: route53.ResolverRuleTargetIpArray{
				&route53.ResolverRuleTargetIpArgs{
					Ip: pulumi.String("123.45.67.89"),
				},
			},
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("Prod"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Resolver rules can be imported using the `id`, e.g.

```sh 

$ pulumi import aws:route53/resolverRule:ResolverRule sys rslvr-rr-0123456789abcdef0

```

func GetResolverRule 

func GetResolverRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverRuleState, opts ...pulumi.ResourceOption) (*ResolverRule, error)

GetResolverRule gets an existing ResolverRule 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 NewResolverRule 

func NewResolverRule(ctx *pulumi.Context,
	name string, args *ResolverRuleArgs, opts ...pulumi.ResourceOption) (*ResolverRule, error)

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

func (ResolverRule) ElementType added in v3.13.0 

func (ResolverRule) ElementType() reflect.Type

func (ResolverRule) ToResolverRuleOutput added in v3.13.0 

func (i ResolverRule) ToResolverRuleOutput() ResolverRuleOutput

func (ResolverRule) ToResolverRuleOutputWithContext added in v3.13.0 

func (i ResolverRule) ToResolverRuleOutputWithContext(ctx context.Context) ResolverRuleOutput

type ResolverRuleArgs 

type ResolverRuleArgs struct {
	// DNS queries for this domain name are forwarded to the IP addresses that are specified using `targetIp`.
	DomainName pulumi.StringInput
	// A friendly name that lets you easily find a rule in the Resolver dashboard in the Route 53 console.
	Name pulumi.StringPtrInput
	// The ID of the outbound resolver endpoint that you want to use to route DNS queries to the IP addresses that you specify using `targetIp`.
	// This argument should only be specified for `FORWARD` type rules.
	ResolverEndpointId pulumi.StringPtrInput
	// The rule type. Valid values are `FORWARD`, `SYSTEM` and `RECURSIVE`.
	RuleType pulumi.StringInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
	// Configuration block(s) indicating the IPs that you want Resolver to forward DNS queries to (documented below).
	// This argument should only be specified for `FORWARD` type rules.
	TargetIps ResolverRuleTargetIpArrayInput
}

The set of arguments for constructing a ResolverRule resource.

func (ResolverRuleArgs) ElementType 

func (ResolverRuleArgs) ElementType() reflect.Type

type ResolverRuleAssociation 

type ResolverRuleAssociation struct {
	pulumi.CustomResourceState

	// A name for the association that you're creating between a resolver rule and a VPC.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the resolver rule that you want to associate with the VPC.
	ResolverRuleId pulumi.StringOutput `pulumi:"resolverRuleId"`
	// The ID of the VPC that you want to associate the resolver rule with.
	VpcId pulumi.StringOutput `pulumi:"vpcId"`
}

Provides a Route53 Resolver rule association.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverRuleAssociation(ctx, "example", &route53.ResolverRuleAssociationArgs{
			ResolverRuleId: pulumi.Any(aws_route53_resolver_rule.Sys.Id),
			VpcId:          pulumi.Any(aws_vpc.Foo.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Resolver rule associations can be imported using the `id`, e.g.

```sh 

$ pulumi import aws:route53/resolverRuleAssociation:ResolverRuleAssociation example rslvr-rrassoc-97242eaf88example

```

func GetResolverRuleAssociation 

func GetResolverRuleAssociation(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverRuleAssociationState, opts ...pulumi.ResourceOption) (*ResolverRuleAssociation, error)

GetResolverRuleAssociation gets an existing ResolverRuleAssociation 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 NewResolverRuleAssociation 

func NewResolverRuleAssociation(ctx *pulumi.Context,
	name string, args *ResolverRuleAssociationArgs, opts ...pulumi.ResourceOption) (*ResolverRuleAssociation, error)

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

func (ResolverRuleAssociation) ElementType added in v3.13.0 

func (ResolverRuleAssociation) ElementType() reflect.Type

func (ResolverRuleAssociation) ToResolverRuleAssociationOutput added in v3.13.0 

func (i ResolverRuleAssociation) ToResolverRuleAssociationOutput() ResolverRuleAssociationOutput

func (ResolverRuleAssociation) ToResolverRuleAssociationOutputWithContext added in v3.13.0 

func (i ResolverRuleAssociation) ToResolverRuleAssociationOutputWithContext(ctx context.Context) ResolverRuleAssociationOutput

type ResolverRuleAssociationArgs 

type ResolverRuleAssociationArgs struct {
	// A name for the association that you're creating between a resolver rule and a VPC.
	Name pulumi.StringPtrInput
	// The ID of the resolver rule that you want to associate with the VPC.
	ResolverRuleId pulumi.StringInput
	// The ID of the VPC that you want to associate the resolver rule with.
	VpcId pulumi.StringInput
}

The set of arguments for constructing a ResolverRuleAssociation resource.

func (ResolverRuleAssociationArgs) ElementType 

func (ResolverRuleAssociationArgs) ElementType() reflect.Type

type ResolverRuleAssociationInput added in v3.13.0 

type ResolverRuleAssociationInput interface {
	pulumi.Input

	ToResolverRuleAssociationOutput() ResolverRuleAssociationOutput
	ToResolverRuleAssociationOutputWithContext(ctx context.Context) ResolverRuleAssociationOutput
}

type ResolverRuleAssociationOutput added in v3.13.0 

type ResolverRuleAssociationOutput struct {
	*pulumi.OutputState
}

func (ResolverRuleAssociationOutput) ElementType added in v3.13.0 

func (ResolverRuleAssociationOutput) ElementType() reflect.Type

func (ResolverRuleAssociationOutput) ToResolverRuleAssociationOutput added in v3.13.0 

func (o ResolverRuleAssociationOutput) ToResolverRuleAssociationOutput() ResolverRuleAssociationOutput

func (ResolverRuleAssociationOutput) ToResolverRuleAssociationOutputWithContext added in v3.13.0 

func (o ResolverRuleAssociationOutput) ToResolverRuleAssociationOutputWithContext(ctx context.Context) ResolverRuleAssociationOutput

type ResolverRuleAssociationState 

type ResolverRuleAssociationState struct {
	// A name for the association that you're creating between a resolver rule and a VPC.
	Name pulumi.StringPtrInput
	// The ID of the resolver rule that you want to associate with the VPC.
	ResolverRuleId pulumi.StringPtrInput
	// The ID of the VPC that you want to associate the resolver rule with.
	VpcId pulumi.StringPtrInput
}

func (ResolverRuleAssociationState) ElementType 

func (ResolverRuleAssociationState) ElementType() reflect.Type

type ResolverRuleInput added in v3.13.0 

type ResolverRuleInput interface {
	pulumi.Input

	ToResolverRuleOutput() ResolverRuleOutput
	ToResolverRuleOutputWithContext(ctx context.Context) ResolverRuleOutput
}

type ResolverRuleOutput added in v3.13.0 

type ResolverRuleOutput struct {
	*pulumi.OutputState
}

func (ResolverRuleOutput) ElementType added in v3.13.0 

func (ResolverRuleOutput) ElementType() reflect.Type

func (ResolverRuleOutput) ToResolverRuleOutput added in v3.13.0 

func (o ResolverRuleOutput) ToResolverRuleOutput() ResolverRuleOutput

func (ResolverRuleOutput) ToResolverRuleOutputWithContext added in v3.13.0 

func (o ResolverRuleOutput) ToResolverRuleOutputWithContext(ctx context.Context) ResolverRuleOutput

type ResolverRuleState 

type ResolverRuleState struct {
	// The ARN (Amazon Resource Name) for the resolver rule.
	Arn pulumi.StringPtrInput
	// DNS queries for this domain name are forwarded to the IP addresses that are specified using `targetIp`.
	DomainName pulumi.StringPtrInput
	// A friendly name that lets you easily find a rule in the Resolver dashboard in the Route 53 console.
	Name pulumi.StringPtrInput
	// When a rule is shared with another AWS account, the account ID of the account that the rule is shared with.
	OwnerId pulumi.StringPtrInput
	// The ID of the outbound resolver endpoint that you want to use to route DNS queries to the IP addresses that you specify using `targetIp`.
	// This argument should only be specified for `FORWARD` type rules.
	ResolverEndpointId pulumi.StringPtrInput
	// The rule type. Valid values are `FORWARD`, `SYSTEM` and `RECURSIVE`.
	RuleType pulumi.StringPtrInput
	// Whether the rules is shared and, if so, whether the current account is sharing the rule with another account, or another account is sharing the rule with the current account.
	// Values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus pulumi.StringPtrInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
	// Configuration block(s) indicating the IPs that you want Resolver to forward DNS queries to (documented below).
	// This argument should only be specified for `FORWARD` type rules.
	TargetIps ResolverRuleTargetIpArrayInput
}

func (ResolverRuleState) ElementType 

func (ResolverRuleState) ElementType() reflect.Type

type ResolverRuleTargetIp 

type ResolverRuleTargetIp struct {
	// One IP address that you want to forward DNS queries to. You can specify only IPv4 addresses.
	Ip string `pulumi:"ip"`
	// The port at `ip` that you want to forward DNS queries to. Default value is `53`
	Port *int `pulumi:"port"`
}

type ResolverRuleTargetIpArgs 

type ResolverRuleTargetIpArgs struct {
	// One IP address that you want to forward DNS queries to. You can specify only IPv4 addresses.
	Ip pulumi.StringInput `pulumi:"ip"`
	// The port at `ip` that you want to forward DNS queries to. Default value is `53`
	Port pulumi.IntPtrInput `pulumi:"port"`
}

func (ResolverRuleTargetIpArgs) ElementType 

func (ResolverRuleTargetIpArgs) ElementType() reflect.Type

func (ResolverRuleTargetIpArgs) ToResolverRuleTargetIpOutput 

func (i ResolverRuleTargetIpArgs) ToResolverRuleTargetIpOutput() ResolverRuleTargetIpOutput

func (ResolverRuleTargetIpArgs) ToResolverRuleTargetIpOutputWithContext 

func (i ResolverRuleTargetIpArgs) ToResolverRuleTargetIpOutputWithContext(ctx context.Context) ResolverRuleTargetIpOutput

type ResolverRuleTargetIpArray 

type ResolverRuleTargetIpArray []ResolverRuleTargetIpInput

func (ResolverRuleTargetIpArray) ElementType 

func (ResolverRuleTargetIpArray) ElementType() reflect.Type

func (ResolverRuleTargetIpArray) ToResolverRuleTargetIpArrayOutput 

func (i ResolverRuleTargetIpArray) ToResolverRuleTargetIpArrayOutput() ResolverRuleTargetIpArrayOutput

func (ResolverRuleTargetIpArray) ToResolverRuleTargetIpArrayOutputWithContext 

func (i ResolverRuleTargetIpArray) ToResolverRuleTargetIpArrayOutputWithContext(ctx context.Context) ResolverRuleTargetIpArrayOutput

type ResolverRuleTargetIpArrayInput 

type ResolverRuleTargetIpArrayInput interface {
	pulumi.Input

	ToResolverRuleTargetIpArrayOutput() ResolverRuleTargetIpArrayOutput
	ToResolverRuleTargetIpArrayOutputWithContext(context.Context) ResolverRuleTargetIpArrayOutput
}

ResolverRuleTargetIpArrayInput is an input type that accepts ResolverRuleTargetIpArray and ResolverRuleTargetIpArrayOutput values. You can construct a concrete instance of `ResolverRuleTargetIpArrayInput` via: 

ResolverRuleTargetIpArray{ ResolverRuleTargetIpArgs{...} }

type ResolverRuleTargetIpArrayOutput 

type ResolverRuleTargetIpArrayOutput struct{ *pulumi.OutputState }

func (ResolverRuleTargetIpArrayOutput) ElementType 

func (ResolverRuleTargetIpArrayOutput) ElementType() reflect.Type

func (ResolverRuleTargetIpArrayOutput) Index 

func (o ResolverRuleTargetIpArrayOutput) Index(i pulumi.IntInput) ResolverRuleTargetIpOutput

func (ResolverRuleTargetIpArrayOutput) ToResolverRuleTargetIpArrayOutput 

func (o ResolverRuleTargetIpArrayOutput) ToResolverRuleTargetIpArrayOutput() ResolverRuleTargetIpArrayOutput

func (ResolverRuleTargetIpArrayOutput) ToResolverRuleTargetIpArrayOutputWithContext 

func (o ResolverRuleTargetIpArrayOutput) ToResolverRuleTargetIpArrayOutputWithContext(ctx context.Context) ResolverRuleTargetIpArrayOutput

type ResolverRuleTargetIpInput 

type ResolverRuleTargetIpInput interface {
	pulumi.Input

	ToResolverRuleTargetIpOutput() ResolverRuleTargetIpOutput
	ToResolverRuleTargetIpOutputWithContext(context.Context) ResolverRuleTargetIpOutput
}

ResolverRuleTargetIpInput is an input type that accepts ResolverRuleTargetIpArgs and ResolverRuleTargetIpOutput values. You can construct a concrete instance of `ResolverRuleTargetIpInput` via: 

ResolverRuleTargetIpArgs{...}

type ResolverRuleTargetIpOutput 

type ResolverRuleTargetIpOutput struct{ *pulumi.OutputState }

func (ResolverRuleTargetIpOutput) ElementType 

func (ResolverRuleTargetIpOutput) ElementType() reflect.Type

func (ResolverRuleTargetIpOutput) Ip 

func (o ResolverRuleTargetIpOutput) Ip() pulumi.StringOutput

One IP address that you want to forward DNS queries to. You can specify only IPv4 addresses.

func (ResolverRuleTargetIpOutput) Port 

func (o ResolverRuleTargetIpOutput) Port() pulumi.IntPtrOutput

The port at `ip` that you want to forward DNS queries to. Default value is `53`

func (ResolverRuleTargetIpOutput) ToResolverRuleTargetIpOutput 

func (o ResolverRuleTargetIpOutput) ToResolverRuleTargetIpOutput() ResolverRuleTargetIpOutput

func (ResolverRuleTargetIpOutput) ToResolverRuleTargetIpOutputWithContext 

func (o ResolverRuleTargetIpOutput) ToResolverRuleTargetIpOutputWithContext(ctx context.Context) ResolverRuleTargetIpOutput

type VpcAssociationAuthorization added in v3.1.0 

type VpcAssociationAuthorization struct {
	pulumi.CustomResourceState

	// The VPC to authorize for association with the private hosted zone.
	VpcId pulumi.StringOutput `pulumi:"vpcId"`
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringOutput `pulumi:"vpcRegion"`
	// The ID of the private hosted zone that you want to authorize associating a VPC with.
	ZoneId pulumi.StringOutput `pulumi:"zoneId"`
}

Authorizes a VPC in a peer account to be associated with a local Route53 Hosted Zone.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/providers"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := providers.Newaws(ctx, "alternate", nil)
		if err != nil {
			return err
		}
		exampleVpc, err := ec2.NewVpc(ctx, "exampleVpc", &ec2.VpcArgs{
			CidrBlock:          pulumi.String("10.6.0.0/16"),
			EnableDnsHostnames: pulumi.Bool(true),
			EnableDnsSupport:   pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		exampleZone, err := route53.NewZone(ctx, "exampleZone", &route53.ZoneArgs{
			Vpcs: route53.ZoneVpcArray{
				&route53.ZoneVpcArgs{
					VpcId: exampleVpc.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		alternateVpc, err := ec2.NewVpc(ctx, "alternateVpc", &ec2.VpcArgs{
			CidrBlock:          pulumi.String("10.7.0.0/16"),
			EnableDnsHostnames: pulumi.Bool(true),
			EnableDnsSupport:   pulumi.Bool(true),
		}, pulumi.Provider("aws.alternate"))
		if err != nil {
			return err
		}
		exampleVpcAssociationAuthorization, err := route53.NewVpcAssociationAuthorization(ctx, "exampleVpcAssociationAuthorization", &route53.VpcAssociationAuthorizationArgs{
			VpcId:  alternateVpc.ID(),
			ZoneId: exampleZone.ID(),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewZoneAssociation(ctx, "exampleZoneAssociation", &route53.ZoneAssociationArgs{
			VpcId:  exampleVpcAssociationAuthorization.VpcId,
			ZoneId: exampleVpcAssociationAuthorization.ZoneId,
		}, pulumi.Provider("aws.alternate"))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route 53 VPC Association Authorizations can be imported via the Hosted Zone ID and VPC ID, separated by a colon (`:`), e.g.

```sh 

$ pulumi import aws:route53/vpcAssociationAuthorization:VpcAssociationAuthorization example Z123456ABCDEFG:vpc-12345678

```

func GetVpcAssociationAuthorization added in v3.1.0 

func GetVpcAssociationAuthorization(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *VpcAssociationAuthorizationState, opts ...pulumi.ResourceOption) (*VpcAssociationAuthorization, error)

GetVpcAssociationAuthorization gets an existing VpcAssociationAuthorization 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 NewVpcAssociationAuthorization added in v3.1.0 

func NewVpcAssociationAuthorization(ctx *pulumi.Context,
	name string, args *VpcAssociationAuthorizationArgs, opts ...pulumi.ResourceOption) (*VpcAssociationAuthorization, error)

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

func (VpcAssociationAuthorization) ElementType added in v3.13.0 

func (VpcAssociationAuthorization) ElementType() reflect.Type

func (VpcAssociationAuthorization) ToVpcAssociationAuthorizationOutput added in v3.13.0 

func (i VpcAssociationAuthorization) ToVpcAssociationAuthorizationOutput() VpcAssociationAuthorizationOutput

func (VpcAssociationAuthorization) ToVpcAssociationAuthorizationOutputWithContext added in v3.13.0 

func (i VpcAssociationAuthorization) ToVpcAssociationAuthorizationOutputWithContext(ctx context.Context) VpcAssociationAuthorizationOutput

type VpcAssociationAuthorizationArgs added in v3.1.0 

type VpcAssociationAuthorizationArgs struct {
	// The VPC to authorize for association with the private hosted zone.
	VpcId pulumi.StringInput
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringPtrInput
	// The ID of the private hosted zone that you want to authorize associating a VPC with.
	ZoneId pulumi.StringInput
}

The set of arguments for constructing a VpcAssociationAuthorization resource.

func (VpcAssociationAuthorizationArgs) ElementType added in v3.1.0 

func (VpcAssociationAuthorizationArgs) ElementType() reflect.Type

type VpcAssociationAuthorizationInput added in v3.13.0 

type VpcAssociationAuthorizationInput interface {
	pulumi.Input

	ToVpcAssociationAuthorizationOutput() VpcAssociationAuthorizationOutput
	ToVpcAssociationAuthorizationOutputWithContext(ctx context.Context) VpcAssociationAuthorizationOutput
}

type VpcAssociationAuthorizationOutput added in v3.13.0 

type VpcAssociationAuthorizationOutput struct {
	*pulumi.OutputState
}

func (VpcAssociationAuthorizationOutput) ElementType added in v3.13.0 

func (VpcAssociationAuthorizationOutput) ElementType() reflect.Type

func (VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationOutput added in v3.13.0 

func (o VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationOutput() VpcAssociationAuthorizationOutput

func (VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationOutputWithContext added in v3.13.0 

func (o VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationOutputWithContext(ctx context.Context) VpcAssociationAuthorizationOutput

type VpcAssociationAuthorizationState added in v3.1.0 

type VpcAssociationAuthorizationState struct {
	// The VPC to authorize for association with the private hosted zone.
	VpcId pulumi.StringPtrInput
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringPtrInput
	// The ID of the private hosted zone that you want to authorize associating a VPC with.
	ZoneId pulumi.StringPtrInput
}

func (VpcAssociationAuthorizationState) ElementType added in v3.1.0 

func (VpcAssociationAuthorizationState) ElementType() reflect.Type

type Zone 

type Zone struct {
	pulumi.CustomResourceState

	// A comment for the hosted zone. Defaults to 'Managed by Pulumi'.
	Comment pulumi.StringOutput `pulumi:"comment"`
	// The ID of the reusable delegation set whose NS records you want to assign to the hosted zone. Conflicts with `vpc` as delegation sets can only be used for public zones.
	DelegationSetId pulumi.StringPtrOutput `pulumi:"delegationSetId"`
	// Whether to destroy all records (possibly managed outside of this provider) in the zone when destroying the zone.
	ForceDestroy pulumi.BoolPtrOutput `pulumi:"forceDestroy"`
	// This is the name of the hosted zone.
	Name pulumi.StringOutput `pulumi:"name"`
	// A list of name servers in associated (or default) delegation set.
	// Find more about delegation sets in [AWS docs](https://docs.aws.amazon.com/Route53/latest/APIReference/actions-on-reusable-delegation-sets.html).
	NameServers pulumi.StringArrayOutput `pulumi:"nameServers"`
	// A mapping of tags to assign to the zone.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Configuration block(s) specifying VPC(s) to associate with a private hosted zone. Conflicts with the `delegationSetId` argument in this resource and any `route53.ZoneAssociation` resource specifying the same zone ID. Detailed below.
	Vpcs ZoneVpcArrayOutput `pulumi:"vpcs"`
	// The Hosted Zone ID. This can be referenced by zone records.
	ZoneId pulumi.StringOutput `pulumi:"zoneId"`
}

Manages a Route53 Hosted Zone.

## Example Usage ### Public Zone

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewZone(ctx, "primary", nil)
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Public Subdomain Zone

For use in subdomains, note that you need to create a `route53.Record` of type `NS` as well as the subdomain zone.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := route53.NewZone(ctx, "main", nil)
		if err != nil {
			return err
		}
		dev, err := route53.NewZone(ctx, "dev", &route53.ZoneArgs{
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("dev"),
			},
		})
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "dev_ns", &route53.RecordArgs{
			ZoneId:  main.ZoneId,
			Name:    pulumi.String("dev.example.com"),
			Type:    pulumi.String("NS"),
			Ttl:     pulumi.Int(30),
			Records: dev.NameServers,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Private Zone

> **NOTE:** This provider provides both exclusive VPC associations defined in-line in this resource via `vpc` configuration blocks and a separate ` Zone VPC Association resource. At this time, you cannot use in-line VPC associations in conjunction with any `route53.ZoneAssociation` resources with the same zone ID otherwise it will cause a perpetual difference in plan output. You can optionally use [ `ignoreChanges` ](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) to manage additional associations via the `route53.ZoneAssociation` resource.

> **NOTE:** Private zones require at least one VPC association at all times.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewZone(ctx, "private", &route53.ZoneArgs{
			Vpcs: route53.ZoneVpcArray{
				&route53.ZoneVpcArgs{
					VpcId: pulumi.Any(aws_vpc.Example.Id),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Zones can be imported using the `zone id`, e.g.

```sh 

$ pulumi import aws:route53/zone:Zone myzone Z1D633PJN98FT9

```

func GetZone 

func GetZone(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ZoneState, opts ...pulumi.ResourceOption) (*Zone, error)

GetZone gets an existing Zone 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 NewZone 

func NewZone(ctx *pulumi.Context,
	name string, args *ZoneArgs, opts ...pulumi.ResourceOption) (*Zone, error)

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

func (Zone) ElementType added in v3.13.0 

func (Zone) ElementType() reflect.Type

func (Zone) ToZoneOutput added in v3.13.0 

func (i Zone) ToZoneOutput() ZoneOutput

func (Zone) ToZoneOutputWithContext added in v3.13.0 

func (i Zone) ToZoneOutputWithContext(ctx context.Context) ZoneOutput

type ZoneArgs 

type ZoneArgs struct {
	// A comment for the hosted zone. Defaults to 'Managed by Pulumi'.
	Comment pulumi.StringPtrInput
	// The ID of the reusable delegation set whose NS records you want to assign to the hosted zone. Conflicts with `vpc` as delegation sets can only be used for public zones.
	DelegationSetId pulumi.StringPtrInput
	// Whether to destroy all records (possibly managed outside of this provider) in the zone when destroying the zone.
	ForceDestroy pulumi.BoolPtrInput
	// This is the name of the hosted zone.
	Name pulumi.StringPtrInput
	// A mapping of tags to assign to the zone.
	Tags pulumi.StringMapInput
	// Configuration block(s) specifying VPC(s) to associate with a private hosted zone. Conflicts with the `delegationSetId` argument in this resource and any `route53.ZoneAssociation` resource specifying the same zone ID. Detailed below.
	Vpcs ZoneVpcArrayInput
}

The set of arguments for constructing a Zone resource.

func (ZoneArgs) ElementType 

func (ZoneArgs) ElementType() reflect.Type

type ZoneAssociation 

type ZoneAssociation struct {
	pulumi.CustomResourceState

	// The account ID of the account that created the hosted zone.
	OwningAccount pulumi.StringOutput `pulumi:"owningAccount"`
	// The VPC to associate with the private hosted zone.
	VpcId pulumi.StringOutput `pulumi:"vpcId"`
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringOutput `pulumi:"vpcRegion"`
	// The private hosted zone to associate.
	ZoneId pulumi.StringOutput `pulumi:"zoneId"`
}

Manages a Route53 Hosted Zone VPC association. VPC associations can only be made on private zones. See the `route53.VpcAssociationAuthorization` resource for setting up cross-account associations.

> **NOTE:** Unless explicit association ordering is required (e.g. a separate cross-account association authorization), usage of this resource is not recommended. Use the `vpc` configuration blocks available within the `route53.Zone` resource instead.

> **NOTE:** This provider provides both this standalone Zone VPC Association resource and exclusive VPC associations defined in-line in the `route53.Zone` resource via `vpc` configuration blocks. At this time, you cannot use those in-line VPC associations in conjunction with this resource and the same zone ID otherwise it will cause a perpetual difference in plan output. You can optionally use [`ignoreChanges`](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) in the `route53.Zone` resource to manage additional associations via this resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		primary, err := ec2.NewVpc(ctx, "primary", &ec2.VpcArgs{
			CidrBlock:          pulumi.String("10.6.0.0/16"),
			EnableDnsHostnames: pulumi.Bool(true),
			EnableDnsSupport:   pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		secondaryVpc, err := ec2.NewVpc(ctx, "secondaryVpc", &ec2.VpcArgs{
			CidrBlock:          pulumi.String("10.7.0.0/16"),
			EnableDnsHostnames: pulumi.Bool(true),
			EnableDnsSupport:   pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		example, err := route53.NewZone(ctx, "example", &route53.ZoneArgs{
			Vpcs: route53.ZoneVpcArray{
				&route53.ZoneVpcArgs{
					VpcId: primary.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = route53.NewZoneAssociation(ctx, "secondaryZoneAssociation", &route53.ZoneAssociationArgs{
			ZoneId: example.ZoneId,
			VpcId:  secondaryVpc.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route 53 Hosted Zone Associations can be imported via the Hosted Zone ID and VPC ID, separated by a colon (`:`), e.g.

```sh 

$ pulumi import aws:route53/zoneAssociation:ZoneAssociation example Z123456ABCDEFG:vpc-12345678

``` 

If the VPC is in a different region than the Terraform AWS Provider region configuration, the VPC Region can be added to the end. e.g.

```sh 

$ pulumi import aws:route53/zoneAssociation:ZoneAssociation example Z123456ABCDEFG:vpc-12345678:us-east-2

```

func GetZoneAssociation 

func GetZoneAssociation(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ZoneAssociationState, opts ...pulumi.ResourceOption) (*ZoneAssociation, error)

GetZoneAssociation gets an existing ZoneAssociation 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 NewZoneAssociation 

func NewZoneAssociation(ctx *pulumi.Context,
	name string, args *ZoneAssociationArgs, opts ...pulumi.ResourceOption) (*ZoneAssociation, error)

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

func (ZoneAssociation) ElementType added in v3.13.0 

func (ZoneAssociation) ElementType() reflect.Type

func (ZoneAssociation) ToZoneAssociationOutput added in v3.13.0 

func (i ZoneAssociation) ToZoneAssociationOutput() ZoneAssociationOutput

func (ZoneAssociation) ToZoneAssociationOutputWithContext added in v3.13.0 

func (i ZoneAssociation) ToZoneAssociationOutputWithContext(ctx context.Context) ZoneAssociationOutput

type ZoneAssociationArgs 

type ZoneAssociationArgs struct {
	// The VPC to associate with the private hosted zone.
	VpcId pulumi.StringInput
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringPtrInput
	// The private hosted zone to associate.
	ZoneId pulumi.StringInput
}

The set of arguments for constructing a ZoneAssociation resource.

func (ZoneAssociationArgs) ElementType 

func (ZoneAssociationArgs) ElementType() reflect.Type

type ZoneAssociationInput added in v3.13.0 

type ZoneAssociationInput interface {
	pulumi.Input

	ToZoneAssociationOutput() ZoneAssociationOutput
	ToZoneAssociationOutputWithContext(ctx context.Context) ZoneAssociationOutput
}

type ZoneAssociationOutput added in v3.13.0 

type ZoneAssociationOutput struct {
	*pulumi.OutputState
}

func (ZoneAssociationOutput) ElementType added in v3.13.0 

func (ZoneAssociationOutput) ElementType() reflect.Type

func (ZoneAssociationOutput) ToZoneAssociationOutput added in v3.13.0 

func (o ZoneAssociationOutput) ToZoneAssociationOutput() ZoneAssociationOutput

func (ZoneAssociationOutput) ToZoneAssociationOutputWithContext added in v3.13.0 

func (o ZoneAssociationOutput) ToZoneAssociationOutputWithContext(ctx context.Context) ZoneAssociationOutput

type ZoneAssociationState 

type ZoneAssociationState struct {
	// The account ID of the account that created the hosted zone.
	OwningAccount pulumi.StringPtrInput
	// The VPC to associate with the private hosted zone.
	VpcId pulumi.StringPtrInput
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringPtrInput
	// The private hosted zone to associate.
	ZoneId pulumi.StringPtrInput
}

func (ZoneAssociationState) ElementType 

func (ZoneAssociationState) ElementType() reflect.Type

type ZoneInput added in v3.13.0 

type ZoneInput interface {
	pulumi.Input

	ToZoneOutput() ZoneOutput
	ToZoneOutputWithContext(ctx context.Context) ZoneOutput
}

type ZoneOutput added in v3.13.0 

type ZoneOutput struct {
	*pulumi.OutputState
}

func (ZoneOutput) ElementType added in v3.13.0 

func (ZoneOutput) ElementType() reflect.Type

func (ZoneOutput) ToZoneOutput added in v3.13.0 

func (o ZoneOutput) ToZoneOutput() ZoneOutput

func (ZoneOutput) ToZoneOutputWithContext added in v3.13.0 

func (o ZoneOutput) ToZoneOutputWithContext(ctx context.Context) ZoneOutput

type ZoneState 

type ZoneState struct {
	// A comment for the hosted zone. Defaults to 'Managed by Pulumi'.
	Comment pulumi.StringPtrInput
	// The ID of the reusable delegation set whose NS records you want to assign to the hosted zone. Conflicts with `vpc` as delegation sets can only be used for public zones.
	DelegationSetId pulumi.StringPtrInput
	// Whether to destroy all records (possibly managed outside of this provider) in the zone when destroying the zone.
	ForceDestroy pulumi.BoolPtrInput
	// This is the name of the hosted zone.
	Name pulumi.StringPtrInput
	// A list of name servers in associated (or default) delegation set.
	// Find more about delegation sets in [AWS docs](https://docs.aws.amazon.com/Route53/latest/APIReference/actions-on-reusable-delegation-sets.html).
	NameServers pulumi.StringArrayInput
	// A mapping of tags to assign to the zone.
	Tags pulumi.StringMapInput
	// Configuration block(s) specifying VPC(s) to associate with a private hosted zone. Conflicts with the `delegationSetId` argument in this resource and any `route53.ZoneAssociation` resource specifying the same zone ID. Detailed below.
	Vpcs ZoneVpcArrayInput
	// The Hosted Zone ID. This can be referenced by zone records.
	ZoneId pulumi.StringPtrInput
}

func (ZoneState) ElementType 

func (ZoneState) ElementType() reflect.Type

type ZoneVpc 

type ZoneVpc struct {
	// ID of the VPC to associate.
	VpcId string `pulumi:"vpcId"`
	// Region of the VPC to associate. Defaults to AWS provider region.
	VpcRegion *string `pulumi:"vpcRegion"`
}

type ZoneVpcArgs 

type ZoneVpcArgs struct {
	// ID of the VPC to associate.
	VpcId pulumi.StringInput `pulumi:"vpcId"`
	// Region of the VPC to associate. Defaults to AWS provider region.
	VpcRegion pulumi.StringPtrInput `pulumi:"vpcRegion"`
}

func (ZoneVpcArgs) ElementType 

func (ZoneVpcArgs) ElementType() reflect.Type

func (ZoneVpcArgs) ToZoneVpcOutput 

func (i ZoneVpcArgs) ToZoneVpcOutput() ZoneVpcOutput

func (ZoneVpcArgs) ToZoneVpcOutputWithContext 

func (i ZoneVpcArgs) ToZoneVpcOutputWithContext(ctx context.Context) ZoneVpcOutput

type ZoneVpcArray 

type ZoneVpcArray []ZoneVpcInput

func (ZoneVpcArray) ElementType 

func (ZoneVpcArray) ElementType() reflect.Type

func (ZoneVpcArray) ToZoneVpcArrayOutput 

func (i ZoneVpcArray) ToZoneVpcArrayOutput() ZoneVpcArrayOutput

func (ZoneVpcArray) ToZoneVpcArrayOutputWithContext 

func (i ZoneVpcArray) ToZoneVpcArrayOutputWithContext(ctx context.Context) ZoneVpcArrayOutput

type ZoneVpcArrayInput 

type ZoneVpcArrayInput interface {
	pulumi.Input

	ToZoneVpcArrayOutput() ZoneVpcArrayOutput
	ToZoneVpcArrayOutputWithContext(context.Context) ZoneVpcArrayOutput
}

ZoneVpcArrayInput is an input type that accepts ZoneVpcArray and ZoneVpcArrayOutput values. You can construct a concrete instance of `ZoneVpcArrayInput` via: 

ZoneVpcArray{ ZoneVpcArgs{...} }

type ZoneVpcArrayOutput 

type ZoneVpcArrayOutput struct{ *pulumi.OutputState }

func (ZoneVpcArrayOutput) ElementType 

func (ZoneVpcArrayOutput) ElementType() reflect.Type

func (ZoneVpcArrayOutput) Index 

func (o ZoneVpcArrayOutput) Index(i pulumi.IntInput) ZoneVpcOutput

func (ZoneVpcArrayOutput) ToZoneVpcArrayOutput 

func (o ZoneVpcArrayOutput) ToZoneVpcArrayOutput() ZoneVpcArrayOutput

func (ZoneVpcArrayOutput) ToZoneVpcArrayOutputWithContext 

func (o ZoneVpcArrayOutput) ToZoneVpcArrayOutputWithContext(ctx context.Context) ZoneVpcArrayOutput

type ZoneVpcInput 

type ZoneVpcInput interface {
	pulumi.Input

	ToZoneVpcOutput() ZoneVpcOutput
	ToZoneVpcOutputWithContext(context.Context) ZoneVpcOutput
}

ZoneVpcInput is an input type that accepts ZoneVpcArgs and ZoneVpcOutput values. You can construct a concrete instance of `ZoneVpcInput` via: 

ZoneVpcArgs{...}

type ZoneVpcOutput 

type ZoneVpcOutput struct{ *pulumi.OutputState }

func (ZoneVpcOutput) ElementType 

func (ZoneVpcOutput) ElementType() reflect.Type

func (ZoneVpcOutput) ToZoneVpcOutput 

func (o ZoneVpcOutput) ToZoneVpcOutput() ZoneVpcOutput

func (ZoneVpcOutput) ToZoneVpcOutputWithContext 

func (o ZoneVpcOutput) ToZoneVpcOutputWithContext(ctx context.Context) ZoneVpcOutput

func (ZoneVpcOutput) VpcId 

func (o ZoneVpcOutput) VpcId() pulumi.StringOutput

ID of the VPC to associate.

func (ZoneVpcOutput) VpcRegion 

func (o ZoneVpcOutput) VpcRegion() pulumi.StringPtrOutput

Region of the VPC to associate. Defaults to AWS provider region.

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.