ResolverEndpoint class

Provides a Route 53 Resolver endpoint resource.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const foo = new aws.route53.ResolverEndpoint("foo", {
    ipAddresses: [
        {
            subnetId: sn1.id,
        },
        {
            subnetId: sn2.id,
            ip: "10.0.64.4",
        },
    ],
    name: "foo",
    direction: "INBOUND",
    resolverEndpointType: "IPV4",
    securityGroupIds: [
        sg1.id,
        sg2.id,
    ],
    protocols: [
        "Do53",
        "DoH",
    ],
    tags: {
        Environment: "Prod",
    },
});
import pulumi
import pulumi_aws as aws

foo = aws.route53.ResolverEndpoint("foo",
    ip_addresses=[
        {
            "subnet_id": sn1["id"],
        },
        {
            "subnet_id": sn2["id"],
            "ip": "10.0.64.4",
        },
    ],
    name="foo",
    direction="INBOUND",
    resolver_endpoint_type="IPV4",
    security_group_ids=[
        sg1["id"],
        sg2["id"],
    ],
    protocols=[
        "Do53",
        "DoH",
    ],
    tags={
        "Environment": "Prod",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var foo = new Aws.Route53.ResolverEndpoint("foo", new()
    {
        IpAddresses = new[]
        {
            new Aws.Route53.Inputs.ResolverEndpointIpAddressArgs
            {
                SubnetId = sn1.Id,
            },
            new Aws.Route53.Inputs.ResolverEndpointIpAddressArgs
            {
                SubnetId = sn2.Id,
                Ip = "10.0.64.4",
            },
        },
        Name = "foo",
        Direction = "INBOUND",
        ResolverEndpointType = "IPV4",
        SecurityGroupIds = new[]
        {
            sg1.Id,
            sg2.Id,
        },
        Protocols = new[]
        {
            "Do53",
            "DoH",
        },
        Tags =
        {
            { "Environment", "Prod" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/route53"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverEndpoint(ctx, "foo", &route53.ResolverEndpointArgs{
			IpAddresses: route53.ResolverEndpointIpAddressArray{
				&route53.ResolverEndpointIpAddressArgs{
					SubnetId: pulumi.Any(sn1.Id),
				},
				&route53.ResolverEndpointIpAddressArgs{
					SubnetId: pulumi.Any(sn2.Id),
					Ip:       pulumi.String("10.0.64.4"),
				},
			},
			Name:                 pulumi.String("foo"),
			Direction:            pulumi.String("INBOUND"),
			ResolverEndpointType: pulumi.String("IPV4"),
			SecurityGroupIds: pulumi.StringArray{
				sg1.Id,
				sg2.Id,
			},
			Protocols: pulumi.StringArray{
				pulumi.String("Do53"),
				pulumi.String("DoH"),
			},
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("Prod"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_route53_resolverendpoint" "foo" {
  ip_addresses {
    subnet_id = sn1.id
  }
  ip_addresses {
    subnet_id = sn2.id
    ip        = "10.0.64.4"
  }
  name                   = "foo"
  direction              = "INBOUND"
  resolver_endpoint_type = "IPV4"
  security_group_ids     = [sg1.id, sg2.id]
  protocols              = ["Do53", "DoH"]
  tags = {
    "Environment" = "Prod"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.route53.ResolverEndpoint;
import com.pulumi.aws.route53.ResolverEndpointArgs;
import com.pulumi.aws.route53.inputs.ResolverEndpointIpAddressArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var foo = new ResolverEndpoint("foo", ResolverEndpointArgs.builder()
            .ipAddresses(
                ResolverEndpointIpAddressArgs.builder()
                    .subnetId(sn1.id())
                    .build(),
                ResolverEndpointIpAddressArgs.builder()
                    .subnetId(sn2.id())
                    .ip("10.0.64.4")
                    .build())
            .name("foo")
            .direction("INBOUND")
            .resolverEndpointType("IPV4")
            .securityGroupIds(
                sg1.id(),
                sg2.id())
            .protocols(
                "Do53",
                "DoH")
            .tags(Map.of("Environment", "Prod"))
            .build());

    }
}
resources:
  foo:
    type: aws:route53:ResolverEndpoint
    properties:
      ipAddresses:
        - subnetId: ${sn1.id}
        - subnetId: ${sn2.id}
          ip: 10.0.64.4
      name: foo
      direction: INBOUND
      resolverEndpointType: IPV4
      securityGroupIds:
        - ${sg1.id}
        - ${sg2.id}
      protocols:
        - Do53
        - DoH
      tags:
        Environment: Prod

Import

Using pulumi import, import Route 53 Resolver endpoints using the Route 53 Resolver endpoint ID. For example:

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

Constructors

ResolverEndpoint(String name, {ResolverEndpointArgs? args, CustomResourceOptions? options})
Creates a new ResolverEndpoint. name The Pulumi resource name. args Arguments used to configure this ResolverEndpoint. The set of arguments for ResolverEndpoint. options Resource options controlling this resource's behavior.
ResolverEndpoint.reference(String urn)
Creates a typed reference to an existing ResolverEndpoint resource.

Properties

arn ↔ Output<String>
ARN of the Route 53 Resolver endpoint.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
direction ↔ Output<String>
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), OUTBOUND (resolver forwards DNS queries from the DNS service for a VPC to your network or another VPC) or INBOUND_DELEGATION (resolver delegates queries to Route 53 private hosted zones from your network).
latefinal
hashCode → int
The hash code for this object.
no setterinherited
hostVpcId ↔ Output<String>
ID of the VPC that you want to create the resolver endpoint in.
latefinal
id ↔ Output<String>
getter/setter pairinherited
ipAddresses ↔ Output<List<ResolverEndpointIpAddress>>
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.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
name ↔ Output<String>
Friendly name of the Route 53 Resolver endpoint.
latefinal
protocols ↔ Output<List<String>>
Protocols you want to use for the Route 53 Resolver endpoint. Valid values are DoH, Do53, or DoH-FIPS.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resolverEndpointType ↔ Output<String>
Endpoint IP type. This endpoint type is applied to all IP addresses. Valid values are IPV6,IPV4 or DUALSTACK (both IPv4 and IPv6).
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
rniEnhancedMetricsEnabled ↔ Output<bool>
Boolean indicating whether RNI enhanced metrics are enabled for the Resolver endpoint. Defaults to false. Once set, changing the value back to false requires explicitly specifying false rather than removing the argument.
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
securityGroupIds ↔ Output<List<String>>
ID of one or more security groups that you want to use to control access to this VPC.
latefinal
tags ↔ Output<Map<String, String>?>
Map of tags to assign to the resource. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
targetNameServerMetricsEnabled ↔ Output<bool>
Boolean indicating whether target name server metrics are enabled for the outbound Resolver endpoints. Defaults to false. This argument is supported only for outbound endpoints. Once set, changing the value back to false requires explicitly specifying false rather than removing the argument.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {ResolverEndpointState? state, CustomResourceOptions? options}) → ResolverEndpoint
Gets an existing ResolverEndpoint resource's state with the given name and id.