getOrganization function

Future<GetOrganizationResult> getOrganization(
  1. GetOrganizationArgs args, {
  2. InvokeOptions? options,
})

Get information about the organization that the users account belongs to.

Example Usage

Basic Usage

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

const example = aws.organizations.getOrganization({});
export const accountIds = example.then(example => example.accounts.map(__item => __item.id));
import pulumi
import pulumi_aws as aws

example = aws.organizations.get_organization()
pulumi.export("accountIds", [__item.id for __item in example.accounts])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = Aws.Organizations.GetOrganization.Invoke();

    return new Dictionary<string, object?>
    {
        ["accountIds"] = example.Apply(getOrganizationResult => getOrganizationResult.Accounts).Select(__item => __item.Id).ToList(),
    };
});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/organizations"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
example, err := organizations.LookupOrganization(ctx, &organizations.LookupOrganizationArgs{
}, nil);
if err != nil {
return err
}
ctx.Export("accountIds", pulumi.StringArray(%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:3,11-33)))
return nil
})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_organizations_getorganization" "example" {
}

output "accountIds" {
  value = data.aws_organizations_getorganization.example.accounts[*].id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.organizations.OrganizationsFunctions;
import com.pulumi.aws.organizations.inputs.GetOrganizationArgs;
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) {
        final var example = OrganizationsFunctions.getOrganization(GetOrganizationArgs.builder()
            .build());

        ctx.export("accountIds", example.accounts().stream().map(element -> element.id()).collect(toList()));
    }
}

Limit SNS Topic Access to an Organization

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

const example = aws.organizations.getOrganization({});
const snsTopic = new aws.sns.Topic("sns_topic", {name: "my-sns-topic"});
const snsTopicPolicy = aws.iam.getPolicyDocumentOutput({
    statements: [{
        conditions: [{
            test: "StringEquals",
            variable: "aws:PrincipalOrgID",
            values: [example.then(example => example.id)],
        }],
        principals: [{
            type: "AWS",
            identifiers: ["*"],
        }],
        effect: "Allow",
        actions: [
            "SNS:Subscribe",
            "SNS:Publish",
        ],
        resources: [snsTopic.arn],
    }],
});
const snsTopicPolicyTopicPolicy = new aws.sns.TopicPolicy("sns_topic_policy", {
    arn: snsTopic.arn,
    policy: snsTopicPolicy.json,
});
import pulumi
import pulumi_aws as aws

example = aws.organizations.get_organization()
sns_topic = aws.sns.Topic("sns_topic", name="my-sns-topic")
sns_topic_policy = aws.iam.get_policy_document_output(statements=[{
    "conditions": [{
        "test": "StringEquals",
        "variable": "aws:PrincipalOrgID",
        "values": [example.id],
    }],
    "principals": [{
        "type": "AWS",
        "identifiers": ["*"],
    }],
    "effect": "Allow",
    "actions": [
        "SNS:Subscribe",
        "SNS:Publish",
    ],
    "resources": [sns_topic.arn],
}])
sns_topic_policy_topic_policy = aws.sns.TopicPolicy("sns_topic_policy",
    arn=sns_topic.arn,
    policy=sns_topic_policy.json)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = Aws.Organizations.GetOrganization.Invoke();

    var snsTopic = new Aws.Sns.Topic("sns_topic", new()
    {
        Name = "my-sns-topic",
    });

    var snsTopicPolicy = Aws.Iam.GetPolicyDocument.Invoke(new()
    {
        Statements = new[]
        {
            new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
            {
                Conditions = new[]
                {
                    new Aws.Iam.Inputs.GetPolicyDocumentStatementConditionInputArgs
                    {
                        Test = "StringEquals",
                        Variable = "aws:PrincipalOrgID",
                        Values = new[]
                        {
                            example.Apply(getOrganizationResult => getOrganizationResult.Id),
                        },
                    },
                },
                Principals = new[]
                {
                    new Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalInputArgs
                    {
                        Type = "AWS",
                        Identifiers = new[]
                        {
                            "*",
                        },
                    },
                },
                Effect = "Allow",
                Actions = new[]
                {
                    "SNS:Subscribe",
                    "SNS:Publish",
                },
                Resources = new[]
                {
                    snsTopic.Arn,
                },
            },
        },
    });

    var snsTopicPolicyTopicPolicy = new Aws.Sns.TopicPolicy("sns_topic_policy", new()
    {
        Arn = snsTopic.Arn,
        Policy = snsTopicPolicy.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/organizations"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sns"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := organizations.LookupOrganization(ctx, &organizations.LookupOrganizationArgs{}, nil)
		if err != nil {
			return err
		}
		snsTopic, err := sns.NewTopic(ctx, "sns_topic", &sns.TopicArgs{
			Name: pulumi.String("my-sns-topic"),
		})
		if err != nil {
			return err
		}
		snsTopicPolicy := iam.GetPolicyDocumentOutput(ctx, iam.GetPolicyDocumentOutputArgs{
			Statements: iam.GetPolicyDocumentStatementArray{
				&iam.GetPolicyDocumentStatementArgs{
					Conditions: iam.GetPolicyDocumentStatementConditionArray{
						&iam.GetPolicyDocumentStatementConditionArgs{
							Test:     pulumi.String("StringEquals"),
							Variable: pulumi.String("aws:PrincipalOrgID"),
							Values: pulumi.StringArray{
								pulumi.String(example.Id),
							},
						},
					},
					Principals: iam.GetPolicyDocumentStatementPrincipalArray{
						&iam.GetPolicyDocumentStatementPrincipalArgs{
							Type: pulumi.String("AWS"),
							Identifiers: pulumi.StringArray{
								pulumi.String("*"),
							},
						},
					},
					Effect: pulumi.String("Allow"),
					Actions: pulumi.StringArray{
						pulumi.String("SNS:Subscribe"),
						pulumi.String("SNS:Publish"),
					},
					Resources: pulumi.StringArray{
						snsTopic.Arn,
					},
				},
			},
		}, nil)
		_, err = sns.NewTopicPolicy(ctx, "sns_topic_policy", &sns.TopicPolicyArgs{
			Arn:    snsTopic.Arn,
			Policy: snsTopicPolicy.Json(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_organizations_getorganization" "example" {
}
data "aws_iam_getpolicydocument" "snsTopicPolicy" {
  statements {
    conditions {
      test     = "StringEquals"
      variable = "aws:PrincipalOrgID"
      values   = [data.aws_organizations_getorganization.example.id]
    }
    principals {
      type        = "AWS"
      identifiers = ["*"]
    }
    effect    = "Allow"
    actions   = ["SNS:Subscribe", "SNS:Publish"]
    resources = [aws_sns_topic.sns_topic.arn]
  }
}

resource "aws_sns_topic" "sns_topic" {
  name = "my-sns-topic"
}
resource "aws_sns_topicpolicy" "sns_topic_policy" {
  arn    = aws_sns_topic.sns_topic.arn
  policy = data.aws_iam_getpolicydocument.snsTopicPolicy.json
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.organizations.OrganizationsFunctions;
import com.pulumi.aws.organizations.inputs.GetOrganizationArgs;
import com.pulumi.aws.sns.Topic;
import com.pulumi.aws.sns.TopicArgs;
import com.pulumi.aws.iam.IamFunctions;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentStatementArgs;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentStatementConditionArgs;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentStatementPrincipalArgs;
import com.pulumi.aws.sns.TopicPolicy;
import com.pulumi.aws.sns.TopicPolicyArgs;
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) {
        final var example = OrganizationsFunctions.getOrganization(GetOrganizationArgs.builder()
            .build());

        var snsTopic = new Topic("snsTopic", TopicArgs.builder()
            .name("my-sns-topic")
            .build());

        final var snsTopicPolicy = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
            .statements(GetPolicyDocumentStatementArgs.builder()
                .conditions(GetPolicyDocumentStatementConditionArgs.builder()
                    .test("StringEquals")
                    .variable("aws:PrincipalOrgID")
                    .values(example.id())
                    .build())
                .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                    .type("AWS")
                    .identifiers("*")
                    .build())
                .effect("Allow")
                .actions(
                    "SNS:Subscribe",
                    "SNS:Publish")
                .resources(snsTopic.arn())
                .build())
            .build());

        var snsTopicPolicyTopicPolicy = new TopicPolicy("snsTopicPolicyTopicPolicy", TopicPolicyArgs.builder()
            .arn(snsTopic.arn())
            .policy(snsTopicPolicy.applyValue(_snsTopicPolicy -> _snsTopicPolicy.json()))
            .build());

    }
}
resources:
  snsTopic:
    type: aws:sns:Topic
    name: sns_topic
    properties:
      name: my-sns-topic
  snsTopicPolicyTopicPolicy:
    type: aws:sns:TopicPolicy
    name: sns_topic_policy
    properties:
      arn: ${snsTopic.arn}
      policy: ${snsTopicPolicy.json}
variables:
  example:
    fn::invoke:
      function: aws:organizations:getOrganization
      arguments: {}
  snsTopicPolicy:
    fn::invoke:
      function: aws:iam:getPolicyDocument
      arguments:
        statements:
          - conditions:
              - test: StringEquals
                variable: aws:PrincipalOrgID
                values:
                  - ${example.id}
            principals:
              - type: AWS
                identifiers:
                  - '*'
            effect: Allow
            actions:
              - SNS:Subscribe
              - SNS:Publish
            resources:
              - ${snsTopic.arn}

args Arguments passed to this invoke. Arguments for getOrganization. options Invoke options controlling this call.

Implementation

Future<GetOrganizationResult> getOrganization(
  GetOrganizationArgs args, {
  pulumi.InvokeOptions? options,
}) async {
  final deployment = pulumi.Deployment.instance;
  final result = await deployment.invoke<Map<String, dynamic>>(
    'aws:organizations/getOrganization:getOrganization',
    args.toMap(),
    options: pulumi.toDeploymentInvokeOptions(options),
  );
  return GetOrganizationResult.fromMap(result);
}