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

ResolverEndpointArgs

data class ResolverEndpointArgs(val direction: Output<String>? = null, val ipAddresses: Output<List<ResolverEndpointIpAddressArgs>>? = null, val name: Output<String>? = null, val protocols: Output<List<String>>? = null, val resolverEndpointType: Output<String>? = null, val securityGroupIds: Output<List<String>>? = null, val tags: Output<Map<String, String>>? = null) : ConvertibleToJava<ResolverEndpointArgs>

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",
    },
});
Content copied to clipboard
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",
    })
Content copied to clipboard
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" },
        },
    });
});
Content copied to clipboard
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
	})
}
Content copied to clipboard
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());
    }
}
Content copied to clipboard
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
Content copied to clipboard

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
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(direction: Output<String>? = null, ipAddresses: Output<List<ResolverEndpointIpAddressArgs>>? = null, name: Output<String>? = null, protocols: Output<List<String>>? = null, resolverEndpointType: Output<String>? = null, securityGroupIds: Output<List<String>>? = null, tags: Output<Map<String, String>>? = null)

Properties

Link copied to clipboard
val direction: Output<String>? = null

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

Link copied to clipboard
val ipAddresses: Output<List<ResolverEndpointIpAddressArgs>>? = null

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.

Link copied to clipboard
val name: Output<String>? = null

Friendly name of the Route 53 Resolver endpoint.

Link copied to clipboard
val protocols: Output<List<String>>? = null

Protocols you want to use for the Route 53 Resolver endpoint. Valid values are DoH, Do53, or DoH-FIPS.

Link copied to clipboard
val resolverEndpointType: Output<String>? = null

Endpoint IP type. This endpoint type is applied to all IP addresses. Valid values are IPV6,IPV4 or DUALSTACK (both IPv4 and IPv6).

Link copied to clipboard
val securityGroupIds: Output<List<String>>? = null

ID of one or more security groups that you want to use to control access to this VPC.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

Map of tags to assign to the resource. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Functions

Link copied to clipboard
open override fun toJava(): ResolverEndpointArgs