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

Domain

class Domain : KotlinCustomResource

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

//

Properties

Link copied to clipboard
val accessPolicies: Output<String>

IAM policy document specifying the access policies for the domain.

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

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<DomainAdvancedSecurityOptions>

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

Link copied to clipboard
val arn: Output<String>

ARN of the domain.

Link copied to clipboard
val autoTuneOptions: Output<DomainAutoTuneOptions>

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

Link copied to clipboard
val clusterConfig: Output<DomainClusterConfig>

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

Link copied to clipboard
val cognitoOptions: Output<DomainCognitoOptions>?

Configuration block for authenticating Kibana with Cognito. Detailed below.

Link copied to clipboard
val domainEndpointOptions: Output<DomainDomainEndpointOptions>

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

Link copied to clipboard
val domainId: Output<String>

Unique identifier for the domain.

Link copied to clipboard
val domainName: Output<String>

Name of the domain. The following arguments are optional:

Link copied to clipboard
val ebsOptions: Output<DomainEbsOptions>

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

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

Version of Elasticsearch to deploy. Defaults to 1.5.

Link copied to clipboard
val encryptAtRest: Output<DomainEncryptAtRest>

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

Link copied to clipboard
val endpoint: Output<String>

Domain-specific endpoint used to submit index, search, and data upload requests.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val kibanaEndpoint: Output<String>

Domain-specific endpoint for kibana without https scheme.

Link copied to clipboard
val logPublishingOptions: Output<List<DomainLogPublishingOption>>?

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<DomainNodeToNodeEncryption>

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

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val snapshotOptions: Output<DomainSnapshotOptions>?

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>>?

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 tagsAll: Output<Map<String, String>>

Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val vpcOptions: Output<DomainVpcOptions>?

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