pulumi-aws-kotlin/com.pulumi.aws.elasticsearch.kotlin/DomainArgs

DomainArgs

data class DomainArgs(val accessPolicies: Output<String>? = null, val advancedOptions: Output<Map<String, String>>? = null, val advancedSecurityOptions: Output<DomainAdvancedSecurityOptionsArgs>? = null, val autoTuneOptions: Output<DomainAutoTuneOptionsArgs>? = null, val clusterConfig: Output<DomainClusterConfigArgs>? = null, val cognitoOptions: Output<DomainCognitoOptionsArgs>? = null, val domainEndpointOptions: Output<DomainDomainEndpointOptionsArgs>? = null, val domainName: Output<String>? = null, val ebsOptions: Output<DomainEbsOptionsArgs>? = null, val elasticsearchVersion: Output<String>? = null, val encryptAtRest: Output<DomainEncryptAtRestArgs>? = null, val logPublishingOptions: Output<List<DomainLogPublishingOptionArgs>>? = null, val nodeToNodeEncryption: Output<DomainNodeToNodeEncryptionArgs>? = null, val snapshotOptions: Output<DomainSnapshotOptionsArgs>? = null, val tags: Output<Map<String, String>>? = null, val vpcOptions: Output<DomainVpcOptionsArgs>? = null) : ConvertibleToJava<DomainArgs>

Manages an AWS Elasticsearch Domain.

Example Usage

Basic Usage

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.elasticsearch.Domain;
import com.pulumi.aws.elasticsearch.DomainArgs;
import com.pulumi.aws.elasticsearch.inputs.DomainClusterConfigArgs;
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 example = new Domain("example", DomainArgs.builder()
            .clusterConfig(DomainClusterConfigArgs.builder()
                .instanceType("r4.large.elasticsearch")
                .build())
            .elasticsearchVersion("7.10")
            .tags(Map.of("Domain", "TestDomain"))
            .build());
    }
}
Content copied to clipboard

Access Policy

See also: aws.elasticsearch.DomainPolicy resource

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetRegionArgs;
import com.pulumi.aws.elasticsearch.Domain;
import com.pulumi.aws.elasticsearch.DomainArgs;
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) {
        final var config = ctx.config();
        final var domain = config.get("domain").orElse("tf-test");
        final var currentRegion = AwsFunctions.getRegion();
        final var currentCallerIdentity = AwsFunctions.getCallerIdentity();
        var example = new Domain("example", DomainArgs.builder()
            .accessPolicies("""
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": "es:*",
      "Principal": "*",
      "Effect": "Allow",
      "Resource": "arn:aws:es:%s:%s:domain/%s/*",
      "Condition": {
        "IpAddress": {"aws:SourceIp": ["66.193.100.22/32"]}
      }
    }
  ]
}
", currentRegion.applyValue(getRegionResult -> getRegionResult.name()),currentCallerIdentity.applyValue(getCallerIdentityResult -> getCallerIdentityResult.accountId()),domain))
            .build());
    }
}
Content copied to clipboard

Log Publishing to CloudWatch Logs

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloudwatch.LogGroup;
import com.pulumi.aws.iam.IamFunctions;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
import com.pulumi.aws.cloudwatch.LogResourcePolicy;
import com.pulumi.aws.cloudwatch.LogResourcePolicyArgs;
import com.pulumi.aws.elasticsearch.Domain;
import com.pulumi.aws.elasticsearch.DomainArgs;
import com.pulumi.aws.elasticsearch.inputs.DomainLogPublishingOptionArgs;
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 exampleLogGroup = new LogGroup("exampleLogGroup");
        final var examplePolicyDocument = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
            .statements(GetPolicyDocumentStatementArgs.builder()
                .effect("Allow")
                .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                    .type("Service")
                    .identifiers("es.amazonaws.com")
                    .build())
                .actions(
                    "logs:PutLogEvents",
                    "logs:PutLogEventsBatch",
                    "logs:CreateLogStream")
                .resources("arn:aws:logs:*")
                .build())
            .build());
        var exampleLogResourcePolicy = new LogResourcePolicy("exampleLogResourcePolicy", LogResourcePolicyArgs.builder()
            .policyName("example")
            .policyDocument(examplePolicyDocument.applyValue(getPolicyDocumentResult -> getPolicyDocumentResult.json()))
            .build());
        var exampleDomain = new Domain("exampleDomain", DomainArgs.builder()
            .logPublishingOptions(DomainLogPublishingOptionArgs.builder()
                .cloudwatchLogGroupArn(exampleLogGroup.arn())
                .logType("INDEX_SLOW_LOGS")
                .build())
            .build());
    }
}
Content copied to clipboard

VPC based ES

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Ec2Functions;
import com.pulumi.aws.ec2.inputs.GetVpcArgs;
import com.pulumi.aws.ec2.inputs.GetSubnetIdsArgs;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetRegionArgs;
import com.pulumi.aws.ec2.SecurityGroup;
import com.pulumi.aws.ec2.SecurityGroupArgs;
import com.pulumi.aws.ec2.inputs.SecurityGroupIngressArgs;
import com.pulumi.aws.iam.ServiceLinkedRole;
import com.pulumi.aws.iam.ServiceLinkedRoleArgs;
import com.pulumi.aws.elasticsearch.Domain;
import com.pulumi.aws.elasticsearch.DomainArgs;
import com.pulumi.aws.elasticsearch.inputs.DomainClusterConfigArgs;
import com.pulumi.aws.elasticsearch.inputs.DomainVpcOptionsArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        final var config = ctx.config();
        final var vpc = config.get("vpc");
        final var domain = config.get("domain").orElse("tf-test");
        final var selectedVpc = Ec2Functions.getVpc(GetVpcArgs.builder()
            .tags(Map.of("Name", vpc))
            .build());
        final var selectedSubnetIds = Ec2Functions.getSubnetIds(GetSubnetIdsArgs.builder()
            .vpcId(selectedVpc.applyValue(getVpcResult -> getVpcResult.id()))
            .tags(Map.of("Tier", "private"))
            .build());
        final var currentRegion = AwsFunctions.getRegion();
        final var currentCallerIdentity = AwsFunctions.getCallerIdentity();
        var esSecurityGroup = new SecurityGroup("esSecurityGroup", SecurityGroupArgs.builder()
            .description("Managed by Pulumi")
            .vpcId(selectedVpc.applyValue(getVpcResult -> getVpcResult.id()))
            .ingress(SecurityGroupIngressArgs.builder()
                .fromPort(443)
                .toPort(443)
                .protocol("tcp")
                .cidrBlocks(selectedVpc.applyValue(getVpcResult -> getVpcResult.cidrBlock()))
                .build())
            .build());
        var esServiceLinkedRole = new ServiceLinkedRole("esServiceLinkedRole", ServiceLinkedRoleArgs.builder()
            .awsServiceName("opensearchservice.amazonaws.com")
            .build());
        var esDomain = new Domain("esDomain", DomainArgs.builder()
            .elasticsearchVersion("6.3")
            .clusterConfig(DomainClusterConfigArgs.builder()
                .instanceType("m4.large.elasticsearch")
                .zoneAwarenessEnabled(true)
                .build())
            .vpcOptions(DomainVpcOptionsArgs.builder()
                .subnetIds(
                    selectedSubnetIds.applyValue(getSubnetIdsResult -> getSubnetIdsResult.ids()[0]),
                    selectedSubnetIds.applyValue(getSubnetIdsResult -> getSubnetIdsResult.ids()[1]))
                .securityGroupIds(esSecurityGroup.id())
                .build())
            .advancedOptions(Map.of("rest.action.multi.allow_explicit_index", "true"))
            .accessPolicies("""
{
	"Version": "2012-10-17",
	"Statement": [
		{
			"Action": "es:*",
			"Principal": "*",
			"Effect": "Allow",
			"Resource": "arn:aws:es:%s:%s:domain/%s/*"
		}
	]
}
", currentRegion.applyValue(getRegionResult -> getRegionResult.name()),currentCallerIdentity.applyValue(getCallerIdentityResult -> getCallerIdentityResult.accountId()),domain))
            .tags(Map.of("Domain", "TestDomain"))
            .build(), CustomResourceOptions.builder()
                .dependsOn(esServiceLinkedRole)
                .build());
    }
}
Content copied to clipboard

Import

Elasticsearch domains can be imported using the domain_name, e.g.,

$ pulumi import aws:elasticsearch/domain:Domain example domain_name
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(accessPolicies: Output<String>? = null, advancedOptions: Output<Map<String, String>>? = null, advancedSecurityOptions: Output<DomainAdvancedSecurityOptionsArgs>? = null, autoTuneOptions: Output<DomainAutoTuneOptionsArgs>? = null, clusterConfig: Output<DomainClusterConfigArgs>? = null, cognitoOptions: Output<DomainCognitoOptionsArgs>? = null, domainEndpointOptions: Output<DomainDomainEndpointOptionsArgs>? = null, domainName: Output<String>? = null, ebsOptions: Output<DomainEbsOptionsArgs>? = null, elasticsearchVersion: Output<String>? = null, encryptAtRest: Output<DomainEncryptAtRestArgs>? = null, logPublishingOptions: Output<List<DomainLogPublishingOptionArgs>>? = null, nodeToNodeEncryption: Output<DomainNodeToNodeEncryptionArgs>? = null, snapshotOptions: Output<DomainSnapshotOptionsArgs>? = null, tags: Output<Map<String, String>>? = null, vpcOptions: Output<DomainVpcOptionsArgs>? = null)

Properties

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

IAM policy document specifying the access policies for the domain.

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

Key-value string pairs to specify advanced configuration options. Note that the values for these configuration options must be strings (wrapped in quotes) or they may be wrong and cause a perpetual diff, causing the provider to want to recreate your Elasticsearch domain on every apply.

Link copied to clipboard
val advancedSecurityOptions: Output<DomainAdvancedSecurityOptionsArgs>? = null

Configuration block for fine-grained access control. Detailed below.

Link copied to clipboard
val autoTuneOptions: Output<DomainAutoTuneOptionsArgs>? = null

Configuration block for the Auto-Tune options of the domain. Detailed below.

Link copied to clipboard
val clusterConfig: Output<DomainClusterConfigArgs>? = null

Configuration block for the cluster of the domain. Detailed below.

Link copied to clipboard
val cognitoOptions: Output<DomainCognitoOptionsArgs>? = null

Configuration block for authenticating Kibana with Cognito. Detailed below.

Link copied to clipboard
val domainEndpointOptions: Output<DomainDomainEndpointOptionsArgs>? = null

Configuration block for domain endpoint HTTP(S) related options. Detailed below.

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

Name of the domain. The following arguments are optional:

Link copied to clipboard
val ebsOptions: Output<DomainEbsOptionsArgs>? = null

Configuration block for EBS related options, may be required based on chosen instance size. Detailed below.

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

Version of Elasticsearch to deploy. Defaults to 1.5.

Link copied to clipboard
val encryptAtRest: Output<DomainEncryptAtRestArgs>? = null

Configuration block for encrypt at rest options. Only available for certain instance types. Detailed below.

Link copied to clipboard
val logPublishingOptions: Output<List<DomainLogPublishingOptionArgs>>? = null

Configuration block for publishing slow and application logs to CloudWatch Logs. This block can be declared multiple times, for each log_type, within the same resource. Detailed below.

Link copied to clipboard
val nodeToNodeEncryption: Output<DomainNodeToNodeEncryptionArgs>? = null

Configuration block for node-to-node encryption options. Detailed below.

Link copied to clipboard
val snapshotOptions: Output<DomainSnapshotOptionsArgs>? = null

Configuration block for snapshot related options. Detailed below. DEPRECATED. For domains running Elasticsearch 5.3 and later, Amazon ES takes hourly automated snapshots, making this setting irrelevant. For domains running earlier versions of Elasticsearch, Amazon ES takes daily automated snapshots.

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.

Link copied to clipboard
val vpcOptions: Output<DomainVpcOptionsArgs>? = null

Configuration block for VPC related options. Adding or removing this configuration forces a new resource (documentation). Detailed below. //

Functions

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