Application class

Provides an AWS OpenSearch Application resource. OpenSearch Applications provide a user interface for interacting with OpenSearch data and managing OpenSearch resources.

Example Usage

Basic Usage

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

const example = new aws.opensearch.Application("example", {name: "my-opensearch-app"});
import pulumi
import pulumi_aws as aws

example = aws.opensearch.Application("example", name="my-opensearch-app")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.OpenSearch.Application("example", new()
    {
        Name = "my-opensearch-app",
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opensearch.NewApplication(ctx, "example", &opensearch.ApplicationArgs{
			Name: pulumi.String("my-opensearch-app"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_opensearch_application" "example" {
  name = "my-opensearch-app"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.opensearch.Application;
import com.pulumi.aws.opensearch.ApplicationArgs;
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 example = new Application("example", ApplicationArgs.builder()
            .name("my-opensearch-app")
            .build());

    }
}
resources:
  example:
    type: aws:opensearch:Application
    properties:
      name: my-opensearch-app

Application with Configuration

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

const example = new aws.opensearch.Application("example", {
    appConfigs: [
        {
            key: "opensearchDashboards.dashboardAdmin.users",
            value: "admin-user",
        },
        {
            key: "opensearchDashboards.dashboardAdmin.groups",
            value: "admin-group",
        },
    ],
    name: "my-opensearch-app",
    tags: {
        Environment: "production",
        Team: "data-platform",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.opensearch.Application("example",
    app_configs=[
        {
            "key": "opensearchDashboards.dashboardAdmin.users",
            "value": "admin-user",
        },
        {
            "key": "opensearchDashboards.dashboardAdmin.groups",
            "value": "admin-group",
        },
    ],
    name="my-opensearch-app",
    tags={
        "Environment": "production",
        "Team": "data-platform",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.OpenSearch.Application("example", new()
    {
        AppConfigs = new[]
        {
            new Aws.OpenSearch.Inputs.ApplicationAppConfigArgs
            {
                Key = "opensearchDashboards.dashboardAdmin.users",
                Value = "admin-user",
            },
            new Aws.OpenSearch.Inputs.ApplicationAppConfigArgs
            {
                Key = "opensearchDashboards.dashboardAdmin.groups",
                Value = "admin-group",
            },
        },
        Name = "my-opensearch-app",
        Tags =
        {
            { "Environment", "production" },
            { "Team", "data-platform" },
        },
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opensearch.NewApplication(ctx, "example", &opensearch.ApplicationArgs{
			AppConfigs: opensearch.ApplicationAppConfigArray{
				&opensearch.ApplicationAppConfigArgs{
					Key:   pulumi.String("opensearchDashboards.dashboardAdmin.users"),
					Value: pulumi.String("admin-user"),
				},
				&opensearch.ApplicationAppConfigArgs{
					Key:   pulumi.String("opensearchDashboards.dashboardAdmin.groups"),
					Value: pulumi.String("admin-group"),
				},
			},
			Name: pulumi.String("my-opensearch-app"),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("production"),
				"Team":        pulumi.String("data-platform"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_opensearch_application" "example" {
  app_configs {
    key   = "opensearchDashboards.dashboardAdmin.users"
    value = "admin-user"
  }
  app_configs {
    key   = "opensearchDashboards.dashboardAdmin.groups"
    value = "admin-group"
  }
  name = "my-opensearch-app"
  tags = {
    "Environment" = "production"
    "Team"        = "data-platform"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.opensearch.Application;
import com.pulumi.aws.opensearch.ApplicationArgs;
import com.pulumi.aws.opensearch.inputs.ApplicationAppConfigArgs;
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 example = new Application("example", ApplicationArgs.builder()
            .appConfigs(
                ApplicationAppConfigArgs.builder()
                    .key("opensearchDashboards.dashboardAdmin.users")
                    .value("admin-user")
                    .build(),
                ApplicationAppConfigArgs.builder()
                    .key("opensearchDashboards.dashboardAdmin.groups")
                    .value("admin-group")
                    .build())
            .name("my-opensearch-app")
            .tags(Map.ofEntries(
                Map.entry("Environment", "production"),
                Map.entry("Team", "data-platform")
            ))
            .build());

    }
}
resources:
  example:
    type: aws:opensearch:Application
    properties:
      appConfigs:
        - key: opensearchDashboards.dashboardAdmin.users
          value: admin-user
        - key: opensearchDashboards.dashboardAdmin.groups
          value: admin-group
      name: my-opensearch-app
      tags:
        Environment: production
        Team: data-platform

Application with Data Sources

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

const example = new aws.opensearch.Domain("example", {
    clusterConfig: {
        instanceType: "t3.small.search",
    },
    ebsOptions: {
        ebsEnabled: true,
        volumeSize: 20,
    },
    domainName: "example-domain",
    engineVersion: "OpenSearch_2.3",
});
const exampleApplication = new aws.opensearch.Application("example", {
    dataSources: [{
        dataSourceArn: example.arn,
        dataSourceDescription: "Primary OpenSearch domain for analytics",
    }],
    name: "my-opensearch-app",
    tags: {
        Environment: "production",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.opensearch.Domain("example",
    cluster_config={
        "instance_type": "t3.small.search",
    },
    ebs_options={
        "ebs_enabled": True,
        "volume_size": 20,
    },
    domain_name="example-domain",
    engine_version="OpenSearch_2.3")
example_application = aws.opensearch.Application("example",
    data_sources=[{
        "data_source_arn": example.arn,
        "data_source_description": "Primary OpenSearch domain for analytics",
    }],
    name="my-opensearch-app",
    tags={
        "Environment": "production",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.OpenSearch.Domain("example", new()
    {
        ClusterConfig = new Aws.OpenSearch.Inputs.DomainClusterConfigArgs
        {
            InstanceType = "t3.small.search",
        },
        EbsOptions = new Aws.OpenSearch.Inputs.DomainEbsOptionsArgs
        {
            EbsEnabled = true,
            VolumeSize = 20,
        },
        DomainName = "example-domain",
        EngineVersion = "OpenSearch_2.3",
    });

    var exampleApplication = new Aws.OpenSearch.Application("example", new()
    {
        DataSources = new[]
        {
            new Aws.OpenSearch.Inputs.ApplicationDataSourceArgs
            {
                DataSourceArn = example.Arn,
                DataSourceDescription = "Primary OpenSearch domain for analytics",
            },
        },
        Name = "my-opensearch-app",
        Tags =
        {
            { "Environment", "production" },
        },
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := opensearch.NewDomain(ctx, "example", &opensearch.DomainArgs{
			ClusterConfig: &opensearch.DomainClusterConfigArgs{
				InstanceType: pulumi.String("t3.small.search"),
			},
			EbsOptions: &opensearch.DomainEbsOptionsArgs{
				EbsEnabled: pulumi.Bool(true),
				VolumeSize: pulumi.Int(20),
			},
			DomainName:    pulumi.String("example-domain"),
			EngineVersion: pulumi.String("OpenSearch_2.3"),
		})
		if err != nil {
			return err
		}
		_, err = opensearch.NewApplication(ctx, "example", &opensearch.ApplicationArgs{
			DataSources: opensearch.ApplicationDataSourceArray{
				&opensearch.ApplicationDataSourceArgs{
					DataSourceArn:         example.Arn,
					DataSourceDescription: pulumi.String("Primary OpenSearch domain for analytics"),
				},
			},
			Name: pulumi.String("my-opensearch-app"),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("production"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_opensearch_domain" "example" {
  cluster_config = {
    instance_type = "t3.small.search"
  }
  ebs_options = {
    ebs_enabled = true
    volume_size = 20
  }
  domain_name    = "example-domain"
  engine_version = "OpenSearch_2.3"
}
resource "aws_opensearch_application" "example" {
  data_sources {
    data_source_arn         = aws_opensearch_domain.example.arn
    data_source_description = "Primary OpenSearch domain for analytics"
  }
  name = "my-opensearch-app"
  tags = {
    "Environment" = "production"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.opensearch.Domain;
import com.pulumi.aws.opensearch.DomainArgs;
import com.pulumi.aws.opensearch.inputs.DomainClusterConfigArgs;
import com.pulumi.aws.opensearch.inputs.DomainEbsOptionsArgs;
import com.pulumi.aws.opensearch.Application;
import com.pulumi.aws.opensearch.ApplicationArgs;
import com.pulumi.aws.opensearch.inputs.ApplicationDataSourceArgs;
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 example = new Domain("example", DomainArgs.builder()
            .clusterConfig(DomainClusterConfigArgs.builder()
                .instanceType("t3.small.search")
                .build())
            .ebsOptions(DomainEbsOptionsArgs.builder()
                .ebsEnabled(true)
                .volumeSize(20)
                .build())
            .domainName("example-domain")
            .engineVersion("OpenSearch_2.3")
            .build());

        var exampleApplication = new Application("exampleApplication", ApplicationArgs.builder()
            .dataSources(ApplicationDataSourceArgs.builder()
                .dataSourceArn(example.arn())
                .dataSourceDescription("Primary OpenSearch domain for analytics")
                .build())
            .name("my-opensearch-app")
            .tags(Map.of("Environment", "production"))
            .build());

    }
}
resources:
  example:
    type: aws:opensearch:Domain
    properties:
      clusterConfig:
        instanceType: t3.small.search
      ebsOptions:
        ebsEnabled: true
        volumeSize: 20
      domainName: example-domain
      engineVersion: OpenSearch_2.3
  exampleApplication:
    type: aws:opensearch:Application
    name: example
    properties:
      dataSources:
        - dataSourceArn: ${example.arn}
          dataSourceDescription: Primary OpenSearch domain for analytics
      name: my-opensearch-app
      tags:
        Environment: production

Application with IAM Identity Center Integration

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

// Data sources for account and region information
const example = aws.ssoadmin.getInstances({});
const current = aws.getCallerIdentity({});
const currentGetRegion = aws.getRegion({});
// IAM Policy for OpenSearch Application Identity Center Integration
const opensearchIdentityCenter = new aws.iam.Policy("opensearch_identity_center", {
    name: "opensearch-identity-center-policy",
    description: "Policy for OpenSearch Application Identity Center integration",
    policy: JSON.stringify({
        Version: "2012-10-17",
        Statement: [
            {
                Sid: "IdentityStoreOpenSearchDomainConnectivity",
                Effect: "Allow",
                Action: [
                    "identitystore:DescribeUser",
                    "identitystore:ListGroupMembershipsForMember",
                    "identitystore:DescribeGroup",
                ],
                Resource: "*",
                Condition: {
                    "ForAnyValue:StringEquals": {
                        "aws:CalledViaLast": "es.amazonaws.com",
                    },
                },
            },
            {
                Sid: "OpenSearchDomain",
                Effect: "Allow",
                Action: ["es:ESHttp*"],
                Resource: "*",
            },
            {
                Sid: "OpenSearchServerless",
                Effect: "Allow",
                Action: ["aoss:APIAccessAll"],
                Resource: "*",
            },
        ],
    }),
});
// IAM Role for OpenSearch Application
const opensearchApplication = new aws.iam.Role("opensearch_application", {
    name: "opensearch-application-role",
    assumeRolePolicy: JSON.stringify({
        Version: "2012-10-17",
        Statement: [
            {
                Effect: "Allow",
                Principal: {
                    Service: "application.opensearchservice.amazonaws.com",
                },
                Action: "sts:AssumeRole",
            },
            {
                Effect: "Allow",
                Principal: {
                    Service: "application.opensearchservice.amazonaws.com",
                },
                Action: "sts:SetContext",
                Condition: {
                    "ForAllValues:ArnEquals": {
                        "sts:RequestContextProviders": Promise.all([current, currentGetRegion]).then(([current, currentGetRegion]) => `arn:aws:iam::${current.accountId}:oidc-provider/portal.sso.${currentGetRegion.id}.amazonaws.com/apl/*`),
                    },
                },
            },
        ],
    }),
});
// Attach policy to role
const opensearchIdentityCenterRolePolicyAttachment = new aws.iam.RolePolicyAttachment("opensearch_identity_center", {
    role: opensearchApplication.name,
    policyArn: opensearchIdentityCenter.arn,
});
const exampleApplication = new aws.opensearch.Application("example", {
    iamIdentityCenterOptions: {
        enabled: true,
        iamIdentityCenterInstanceArn: example.then(example => example.arns?.[0]),
        iamRoleForIdentityCenterApplicationArn: opensearchApplication.arn,
    },
    name: "my-opensearch-app",
    tags: {
        Environment: "production",
    },
});
import pulumi
import json
import pulumi_aws as aws

# Data sources for account and region information
example = aws.ssoadmin.get_instances()
current = aws.get_caller_identity()
current_get_region = aws.get_region()
# IAM Policy for OpenSearch Application Identity Center Integration
opensearch_identity_center = aws.iam.Policy("opensearch_identity_center",
    name="opensearch-identity-center-policy",
    description="Policy for OpenSearch Application Identity Center integration",
    policy=json.dumps({
        "Version": "2012-10-17",
        "Statement": [
            {
                "Sid": "IdentityStoreOpenSearchDomainConnectivity",
                "Effect": "Allow",
                "Action": [
                    "identitystore:DescribeUser",
                    "identitystore:ListGroupMembershipsForMember",
                    "identitystore:DescribeGroup",
                ],
                "Resource": "*",
                "Condition": {
                    "ForAnyValue:StringEquals": {
                        "aws:CalledViaLast": "es.amazonaws.com",
                    },
                },
            },
            {
                "Sid": "OpenSearchDomain",
                "Effect": "Allow",
                "Action": ["es:ESHttp*"],
                "Resource": "*",
            },
            {
                "Sid": "OpenSearchServerless",
                "Effect": "Allow",
                "Action": ["aoss:APIAccessAll"],
                "Resource": "*",
            },
        ],
    }))
# IAM Role for OpenSearch Application
opensearch_application = aws.iam.Role("opensearch_application",
    name="opensearch-application-role",
    assume_role_policy=json.dumps({
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Principal": {
                    "Service": "application.opensearchservice.amazonaws.com",
                },
                "Action": "sts:AssumeRole",
            },
            {
                "Effect": "Allow",
                "Principal": {
                    "Service": "application.opensearchservice.amazonaws.com",
                },
                "Action": "sts:SetContext",
                "Condition": {
                    "ForAllValues:ArnEquals": {
                        "sts:RequestContextProviders": f"arn:aws:iam::{current.account_id}:oidc-provider/portal.sso.{current_get_region.id}.amazonaws.com/apl/*",
                    },
                },
            },
        ],
    }))
# Attach policy to role
opensearch_identity_center_role_policy_attachment = aws.iam.RolePolicyAttachment("opensearch_identity_center",
    role=opensearch_application.name,
    policy_arn=opensearch_identity_center.arn)
example_application = aws.opensearch.Application("example",
    iam_identity_center_options={
        "enabled": True,
        "iam_identity_center_instance_arn": example.arns[0],
        "iam_role_for_identity_center_application_arn": opensearch_application.arn,
    },
    name="my-opensearch-app",
    tags={
        "Environment": "production",
    })
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    // Data sources for account and region information
    var example = Aws.SsoAdmin.GetInstances.Invoke();

    var current = Aws.GetCallerIdentity.Invoke();

    var currentGetRegion = Aws.GetRegion.Invoke();

    // IAM Policy for OpenSearch Application Identity Center Integration
    var opensearchIdentityCenter = new Aws.Iam.Policy("opensearch_identity_center", new()
    {
        Name = "opensearch-identity-center-policy",
        Description = "Policy for OpenSearch Application Identity Center integration",
        PolicyDocument = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Version"] = "2012-10-17",
            ["Statement"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Sid"] = "IdentityStoreOpenSearchDomainConnectivity",
                    ["Effect"] = "Allow",
                    ["Action"] = new[]
                    {
                        "identitystore:DescribeUser",
                        "identitystore:ListGroupMembershipsForMember",
                        "identitystore:DescribeGroup",
                    },
                    ["Resource"] = "*",
                    ["Condition"] = new Dictionary<string, object?>
                    {
                        ["ForAnyValue:StringEquals"] = new Dictionary<string, object?>
                        {
                            ["aws:CalledViaLast"] = "es.amazonaws.com",
                        },
                    },
                },
                new Dictionary<string, object?>
                {
                    ["Sid"] = "OpenSearchDomain",
                    ["Effect"] = "Allow",
                    ["Action"] = new[]
                    {
                        "es:ESHttp*",
                    },
                    ["Resource"] = "*",
                },
                new Dictionary<string, object?>
                {
                    ["Sid"] = "OpenSearchServerless",
                    ["Effect"] = "Allow",
                    ["Action"] = new[]
                    {
                        "aoss:APIAccessAll",
                    },
                    ["Resource"] = "*",
                },
            },
        }),
    });

    // IAM Role for OpenSearch Application
    var opensearchApplication = new Aws.Iam.Role("opensearch_application", new()
    {
        Name = "opensearch-application-role",
        AssumeRolePolicy = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Version"] = "2012-10-17",
            ["Statement"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Effect"] = "Allow",
                    ["Principal"] = new Dictionary<string, object?>
                    {
                        ["Service"] = "application.opensearchservice.amazonaws.com",
                    },
                    ["Action"] = "sts:AssumeRole",
                },
                new Dictionary<string, object?>
                {
                    ["Effect"] = "Allow",
                    ["Principal"] = new Dictionary<string, object?>
                    {
                        ["Service"] = "application.opensearchservice.amazonaws.com",
                    },
                    ["Action"] = "sts:SetContext",
                    ["Condition"] = new Dictionary<string, object?>
                    {
                        ["ForAllValues:ArnEquals"] = new Dictionary<string, object?>
                        {
                            ["sts:RequestContextProviders"] = Output.Tuple(current, currentGetRegion).Apply(values =>
                            {
                                var current = values.Item1;
                                var currentGetRegion = values.Item2;
                                return $"arn:aws:iam::{current.Apply(getCallerIdentityResult => getCallerIdentityResult.AccountId)}:oidc-provider/portal.sso.{currentGetRegion.Apply(getRegionResult => getRegionResult.Id)}.amazonaws.com/apl/*";
                            }),
                        },
                    },
                },
            },
        }),
    });

    // Attach policy to role
    var opensearchIdentityCenterRolePolicyAttachment = new Aws.Iam.RolePolicyAttachment("opensearch_identity_center", new()
    {
        Role = opensearchApplication.Name,
        PolicyArn = opensearchIdentityCenter.Arn,
    });

    var exampleApplication = new Aws.OpenSearch.Application("example", new()
    {
        IamIdentityCenterOptions = new Aws.OpenSearch.Inputs.ApplicationIamIdentityCenterOptionsArgs
        {
            Enabled = true,
            IamIdentityCenterInstanceArn = example.Apply(getInstancesResult => getInstancesResult.Arns[0]),
            IamRoleForIdentityCenterApplicationArn = opensearchApplication.Arn,
        },
        Name = "my-opensearch-app",
        Tags =
        {
            { "Environment", "production" },
        },
    });

});
package main

import (
	"encoding/json"
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/opensearch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ssoadmin"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Data sources for account and region information
		example, err := ssoadmin.GetInstances(ctx, &ssoadmin.GetInstancesArgs{}, nil)
		if err != nil {
			return err
		}
		current, err := aws.GetCallerIdentity(ctx, &aws.GetCallerIdentityArgs{}, nil)
		if err != nil {
			return err
		}
		currentGetRegion, err := aws.GetRegion(ctx, &aws.GetRegionArgs{}, nil)
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []interface{}{
				map[string]interface{}{
					"Sid":    "IdentityStoreOpenSearchDomainConnectivity",
					"Effect": "Allow",
					"Action": []string{
						"identitystore:DescribeUser",
						"identitystore:ListGroupMembershipsForMember",
						"identitystore:DescribeGroup",
					},
					"Resource": "*",
					"Condition": map[string]map[string]string{
						"ForAnyValue:StringEquals": map[string]string{
							"aws:CalledViaLast": "es.amazonaws.com",
						},
					},
				},
				map[string]interface{}{
					"Sid":    "OpenSearchDomain",
					"Effect": "Allow",
					"Action": []string{
						"es:ESHttp*",
					},
					"Resource": "*",
				},
				map[string]interface{}{
					"Sid":    "OpenSearchServerless",
					"Effect": "Allow",
					"Action": []string{
						"aoss:APIAccessAll",
					},
					"Resource": "*",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		// IAM Policy for OpenSearch Application Identity Center Integration
		opensearchIdentityCenter, err := iam.NewPolicy(ctx, "opensearch_identity_center", &iam.PolicyArgs{
			Name:        pulumi.String("opensearch-identity-center-policy"),
			Description: pulumi.String("Policy for OpenSearch Application Identity Center integration"),
			Policy:      pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Effect": "Allow",
					"Principal": map[string]string{
						"Service": "application.opensearchservice.amazonaws.com",
					},
					"Action": "sts:AssumeRole",
				},
				map[string]interface{}{
					"Effect": "Allow",
					"Principal": map[string]string{
						"Service": "application.opensearchservice.amazonaws.com",
					},
					"Action": "sts:SetContext",
					"Condition": map[string]map[string]string{
						"ForAllValues:ArnEquals": map[string]string{
							"sts:RequestContextProviders": fmt.Sprintf("arn:aws:iam::%v:oidc-provider/portal.sso.%v.amazonaws.com/apl/*", current.AccountId, currentGetRegion.Id),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		// IAM Role for OpenSearch Application
		opensearchApplication, err := iam.NewRole(ctx, "opensearch_application", &iam.RoleArgs{
			Name:             pulumi.String("opensearch-application-role"),
			AssumeRolePolicy: json1,
		})
		if err != nil {
			return err
		}
		// Attach policy to role
		_, err = iam.NewRolePolicyAttachment(ctx, "opensearch_identity_center", &iam.RolePolicyAttachmentArgs{
			Role:      opensearchApplication.Name,
			PolicyArn: opensearchIdentityCenter.Arn,
		})
		if err != nil {
			return err
		}
		_, err = opensearch.NewApplication(ctx, "example", &opensearch.ApplicationArgs{
			IamIdentityCenterOptions: &opensearch.ApplicationIamIdentityCenterOptionsArgs{
				Enabled:                                pulumi.Bool(true),
				IamIdentityCenterInstanceArn:           pulumi.String(example.Arns[0]),
				IamRoleForIdentityCenterApplicationArn: opensearchApplication.Arn,
			},
			Name: pulumi.String("my-opensearch-app"),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("production"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_ssoadmin_getinstances" "example" {
}
data "aws_getcalleridentity" "current" {
}
data "aws_getregion" "currentGetRegion" {
}

# IAM Policy for OpenSearch Application Identity Center Integration
resource "aws_iam_policy" "opensearch_identity_center" {
  name        = "opensearch-identity-center-policy"
  description = "Policy for OpenSearch Application Identity Center integration"
  policy = jsonencode({
    "Version" = "2012-10-17"
    "Statement" = [{
      "Sid"      = "IdentityStoreOpenSearchDomainConnectivity"
      "Effect"   = "Allow"
      "Action"   = ["identitystore:DescribeUser", "identitystore:ListGroupMembershipsForMember", "identitystore:DescribeGroup"]
      "Resource" = "*"
      "Condition" = {
        "ForAnyValue:StringEquals" = {
          "aws:CalledViaLast" = "es.amazonaws.com"
        }
      }
      }, {
      "Sid"      = "OpenSearchDomain"
      "Effect"   = "Allow"
      "Action"   = ["es:ESHttp*"]
      "Resource" = "*"
      }, {
      "Sid"      = "OpenSearchServerless"
      "Effect"   = "Allow"
      "Action"   = ["aoss:APIAccessAll"]
      "Resource" = "*"
    }]
  })
}
# IAM Role for OpenSearch Application
resource "aws_iam_role" "opensearch_application" {
  name = "opensearch-application-role"
  assume_role_policy = jsonencode({
    "Version" = "2012-10-17"
    "Statement" = [{
      "Effect" = "Allow"
      "Principal" = {
        "Service" = "application.opensearchservice.amazonaws.com"
      }
      "Action" = "sts:AssumeRole"
      }, {
      "Effect" = "Allow"
      "Principal" = {
        "Service" = "application.opensearchservice.amazonaws.com"
      }
      "Action" = "sts:SetContext"
      "Condition" = {
        "ForAllValues:ArnEquals" = {
          "sts:RequestContextProviders" ="arn:aws:iam::${data.aws_getcalleridentity.current.account_id}:oidc-provider/portal.sso.${data.aws_getregion.currentGetRegion.id}.amazonaws.com/apl/*"
        }
      }
    }]
  })
}
# Attach policy to role
resource "aws_iam_rolepolicyattachment" "opensearch_identity_center" {
  role       = aws_iam_role.opensearch_application.name
  policy_arn = aws_iam_policy.opensearch_identity_center.arn
}
resource "aws_opensearch_application" "example" {
  iam_identity_center_options = {
    enabled                                      = true
    iam_identity_center_instance_arn             = data.aws_ssoadmin_getinstances.example.arns[0]
    iam_role_for_identity_center_application_arn = aws_iam_role.opensearch_application.arn
  }
  name = "my-opensearch-app"
  tags = {
    "Environment" = "production"
  }
}
# Data sources for account and region information
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ssoadmin.SsoadminFunctions;
import com.pulumi.aws.ssoadmin.inputs.GetInstancesArgs;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetCallerIdentityArgs;
import com.pulumi.aws.inputs.GetRegionArgs;
import com.pulumi.aws.iam.Policy;
import com.pulumi.aws.iam.PolicyArgs;
import com.pulumi.aws.iam.Role;
import com.pulumi.aws.iam.RoleArgs;
import com.pulumi.aws.iam.RolePolicyAttachment;
import com.pulumi.aws.iam.RolePolicyAttachmentArgs;
import com.pulumi.aws.opensearch.Application;
import com.pulumi.aws.opensearch.ApplicationArgs;
import com.pulumi.aws.opensearch.inputs.ApplicationIamIdentityCenterOptionsArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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) {
        // Data sources for account and region information
        final var example = SsoadminFunctions.getInstances(GetInstancesArgs.builder()
            .build());

        final var current = AwsFunctions.getCallerIdentity(GetCallerIdentityArgs.builder()
            .build());

        final var currentGetRegion = AwsFunctions.getRegion(GetRegionArgs.builder()
            .build());

        // IAM Policy for OpenSearch Application Identity Center Integration
        var opensearchIdentityCenter = new Policy("opensearchIdentityCenter", PolicyArgs.builder()
            .name("opensearch-identity-center-policy")
            .description("Policy for OpenSearch Application Identity Center integration")
            .policy(serializeJson(
                jsonObject(
                    jsonProperty("Version", "2012-10-17"),
                    jsonProperty("Statement", jsonArray(
                        jsonObject(
                            jsonProperty("Sid", "IdentityStoreOpenSearchDomainConnectivity"),
                            jsonProperty("Effect", "Allow"),
                            jsonProperty("Action", jsonArray(
                                "identitystore:DescribeUser",
                                "identitystore:ListGroupMembershipsForMember",
                                "identitystore:DescribeGroup"
                            )),
                            jsonProperty("Resource", "*"),
                            jsonProperty("Condition", jsonObject(
                                jsonProperty("ForAnyValue:StringEquals", jsonObject(
                                    jsonProperty("aws:CalledViaLast", "es.amazonaws.com")
                                ))
                            ))
                        ),
                        jsonObject(
                            jsonProperty("Sid", "OpenSearchDomain"),
                            jsonProperty("Effect", "Allow"),
                            jsonProperty("Action", jsonArray("es:ESHttp*")),
                            jsonProperty("Resource", "*")
                        ),
                        jsonObject(
                            jsonProperty("Sid", "OpenSearchServerless"),
                            jsonProperty("Effect", "Allow"),
                            jsonProperty("Action", jsonArray("aoss:APIAccessAll")),
                            jsonProperty("Resource", "*")
                        )
                    ))
                )))
            .build());

        // IAM Role for OpenSearch Application
        var opensearchApplication = new Role("opensearchApplication", RoleArgs.builder()
            .name("opensearch-application-role")
            .assumeRolePolicy(serializeJson(
                jsonObject(
                    jsonProperty("Version", "2012-10-17"),
                    jsonProperty("Statement", jsonArray(
                        jsonObject(
                            jsonProperty("Effect", "Allow"),
                            jsonProperty("Principal", jsonObject(
                                jsonProperty("Service", "application.opensearchservice.amazonaws.com")
                            )),
                            jsonProperty("Action", "sts:AssumeRole")
                        ),
                        jsonObject(
                            jsonProperty("Effect", "Allow"),
                            jsonProperty("Principal", jsonObject(
                                jsonProperty("Service", "application.opensearchservice.amazonaws.com")
                            )),
                            jsonProperty("Action", "sts:SetContext"),
                            jsonProperty("Condition", jsonObject(
                                jsonProperty("ForAllValues:ArnEquals", jsonObject(
                                    jsonProperty("sts:RequestContextProviders", String.format("arn:aws:iam::%s:oidc-provider/portal.sso.%s.amazonaws.com/apl/*", current.accountId(),currentGetRegion.id()))
                                ))
                            ))
                        )
                    ))
                )))
            .build());

        // Attach policy to role
        var opensearchIdentityCenterRolePolicyAttachment = new RolePolicyAttachment("opensearchIdentityCenterRolePolicyAttachment", RolePolicyAttachmentArgs.builder()
            .role(opensearchApplication.name())
            .policyArn(opensearchIdentityCenter.arn())
            .build());

        var exampleApplication = new Application("exampleApplication", ApplicationArgs.builder()
            .iamIdentityCenterOptions(ApplicationIamIdentityCenterOptionsArgs.builder()
                .enabled(true)
                .iamIdentityCenterInstanceArn(example.arns()[0])
                .iamRoleForIdentityCenterApplicationArn(opensearchApplication.arn())
                .build())
            .name("my-opensearch-app")
            .tags(Map.of("Environment", "production"))
            .build());

    }
}
resources:
  # IAM Policy for OpenSearch Application Identity Center Integration
  opensearchIdentityCenter:
    type: aws:iam:Policy
    name: opensearch_identity_center
    properties:
      name: opensearch-identity-center-policy
      description: Policy for OpenSearch Application Identity Center integration
      policy:
        fn::toJSON:
          Version: 2012-10-17
          Statement:
            - Sid: IdentityStoreOpenSearchDomainConnectivity
              Effect: Allow
              Action:
                - identitystore:DescribeUser
                - identitystore:ListGroupMembershipsForMember
                - identitystore:DescribeGroup
              Resource: '*'
              Condition:
                ForAnyValue:StringEquals:
                  aws:CalledViaLast: es.amazonaws.com
            - Sid: OpenSearchDomain
              Effect: Allow
              Action:
                - es:ESHttp*
              Resource: '*'
            - Sid: OpenSearchServerless
              Effect: Allow
              Action:
                - aoss:APIAccessAll
              Resource: '*'
  # IAM Role for OpenSearch Application
  opensearchApplication:
    type: aws:iam:Role
    name: opensearch_application
    properties:
      name: opensearch-application-role
      assumeRolePolicy:
        fn::toJSON:
          Version: 2012-10-17
          Statement:
            - Effect: Allow
              Principal:
                Service: application.opensearchservice.amazonaws.com
              Action: sts:AssumeRole
            - Effect: Allow
              Principal:
                Service: application.opensearchservice.amazonaws.com
              Action: sts:SetContext
              Condition:
                ForAllValues:ArnEquals:
                  sts:RequestContextProviders: arn:aws:iam::${current.accountId}:oidc-provider/portal.sso.${currentGetRegion.id}.amazonaws.com/apl/*
  # Attach policy to role
  opensearchIdentityCenterRolePolicyAttachment:
    type: aws:iam:RolePolicyAttachment
    name: opensearch_identity_center
    properties:
      role: ${opensearchApplication.name}
      policyArn: ${opensearchIdentityCenter.arn}
  exampleApplication:
    type: aws:opensearch:Application
    name: example
    properties:
      iamIdentityCenterOptions:
        enabled: true
        iamIdentityCenterInstanceArn: ${example.arns[0]}
        iamRoleForIdentityCenterApplicationArn: ${opensearchApplication.arn}
      name: my-opensearch-app
      tags:
        Environment: production
variables:
  # Data sources for account and region information
  example:
    fn::invoke:
      function: aws:ssoadmin:getInstances
      arguments: {}
  current:
    fn::invoke:
      function: aws:getCallerIdentity
      arguments: {}
  currentGetRegion:
    fn::invoke:
      function: aws:getRegion
      arguments: {}

Import

Using pulumi import, import OpenSearch applications using the id. For example:

$ pulumi import aws:opensearch/application:Application example app-1234567890abcdef0

Constructors

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

Properties

appConfigs ↔ Output<List<ApplicationAppConfig>?>
Configuration block(s) for OpenSearch application settings. See App Config below.
latefinal
arn ↔ Output<String>
ARN of the OpenSearch application.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
dataSources ↔ Output<List<ApplicationDataSource>?>
Configuration block(s) for data sources to link to the OpenSearch application. See Data Source below.
latefinal
endpoint ↔ Output<String>
Endpoint URL of the OpenSearch application.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
iamIdentityCenterOptions ↔ Output<ApplicationIamIdentityCenterOptions?>
Configuration block for integrating AWS IAM Identity Center with the OpenSearch application. See IAM Identity Center Options below.
latefinal
id ↔ Output<String>
getter/setter pairinherited
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
kmsKeyArn ↔ Output<String?>
ARN of the KMS key used to encrypt the application's data at rest.
latefinal
name ↔ Output<String>
The unique name of the OpenSearch application. Names must be unique within an AWS Region for each account. Must be between 3 and 30 characters, start with a lowercase letter, and contain only lowercase letters, numbers, and hyphens.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
tags ↔ Output<Map<String, String>?>
A 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>>
A map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
timeouts ↔ Output<ApplicationTimeouts?>
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, {ApplicationState? state, CustomResourceOptions? options}) → Application
Gets an existing Application resource's state with the given name and id.