pulumi-aws-kotlin/com.pulumi.aws.route53.kotlin/ResolverEndpoint

ResolverEndpoint

class ResolverEndpoint : KotlinCustomResource

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", {
    name: "foo",
    direction: "INBOUND",
    resolverEndpointType: "IPV4",
    securityGroupIds: [
        sg1.id,
        sg2.id,
    ],
    ipAddresses: [
        {
            subnetId: sn1.id,
        },
        {
            subnetId: sn2.id,
            ip: "10.0.64.4",
        },
    ],
    protocols: [
        "Do53",
        "DoH",
    ],
    tags: {
        Environment: "Prod",
    },
});

import pulumi
import pulumi_aws as aws
foo = aws.route53.ResolverEndpoint("foo",
    name="foo",
    direction="INBOUND",
    resolver_endpoint_type="IPV4",
    security_group_ids=[
        sg1["id"],
        sg2["id"],
    ],
    ip_addresses=[
        {
            "subnet_id": sn1["id"],
        },
        {
            "subnet_id": sn2["id"],
            "ip": "10.0.64.4",
        },
    ],
    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()
    {
        Name = "foo",
        Direction = "INBOUND",
        ResolverEndpointType = "IPV4",
        SecurityGroupIds = new[]
        {
            sg1.Id,
            sg2.Id,
        },
        IpAddresses = new[]
        {
            new Aws.Route53.Inputs.ResolverEndpointIpAddressArgs
            {
                SubnetId = sn1.Id,
            },
            new Aws.Route53.Inputs.ResolverEndpointIpAddressArgs
            {
                SubnetId = sn2.Id,
                Ip = "10.0.64.4",
            },
        },
        Protocols = new[]
        {
            "Do53",
            "DoH",
        },
        Tags =
        {
            { "Environment", "Prod" },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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{
			Name:                 pulumi.String("foo"),
			Direction:            pulumi.String("INBOUND"),
			ResolverEndpointType: pulumi.String("IPV4"),
			SecurityGroupIds: pulumi.StringArray{
				sg1.Id,
				sg2.Id,
			},
			IpAddresses: route53.ResolverEndpointIpAddressArray{
				&route53.ResolverEndpointIpAddressArgs{
					SubnetId: pulumi.Any(sn1.Id),
				},
				&route53.ResolverEndpointIpAddressArgs{
					SubnetId: pulumi.Any(sn2.Id),
					Ip:       pulumi.String("10.0.64.4"),
				},
			},
			Protocols: pulumi.StringArray{
				pulumi.String("Do53"),
				pulumi.String("DoH"),
			},
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("Prod"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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.List;
import java.util.ArrayList;
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()
            .name("foo")
            .direction("INBOUND")
            .resolverEndpointType("IPV4")
            .securityGroupIds(
                sg1.id(),
                sg2.id())
            .ipAddresses(
                ResolverEndpointIpAddressArgs.builder()
                    .subnetId(sn1.id())
                    .build(),
                ResolverEndpointIpAddressArgs.builder()
                    .subnetId(sn2.id())
                    .ip("10.0.64.4")
                    .build())
            .protocols(
                "Do53",
                "DoH")
            .tags(Map.of("Environment", "Prod"))
            .build());
    }
}

resources:
  foo:
    type: aws:route53:ResolverEndpoint
    properties:
      name: foo
      direction: INBOUND
      resolverEndpointType: IPV4
      securityGroupIds:
        - ${sg1.id}
        - ${sg2.id}
      ipAddresses:
        - subnetId: ${sn1.id}
        - subnetId: ${sn2.id}
          ip: 10.0.64.4
      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

Properties

arn

val arn: Output<String>

ARN of the Route 53 Resolver endpoint.

direction

val 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) or OUTBOUND (resolver forwards DNS queries from the DNS service for a VPC to your network or another VPC).

hostVpcId

val hostVpcId: Output<String>

ID of the VPC that you want to create the resolver endpoint in.

val id: Output<String>

ipAddresses

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

name

val name: Output<String>

Friendly name of the Route 53 Resolver endpoint.

protocols