EnvironmentBlueprintConfiguration class

Resource for managing an AWS DataZone Environment Blueprint Configuration.

Example Usage

Basic Usage

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

const example = new aws.datazone.Domain("example", {
    name: "example_domain",
    domainExecutionRole: domainExecutionRole.arn,
});
const defaultDataLake = aws.datazone.getEnvironmentBlueprintOutput({
    domainId: example.id,
    name: "DefaultDataLake",
    managed: true,
});
const exampleEnvironmentBlueprintConfiguration = new aws.datazone.EnvironmentBlueprintConfiguration("example", {
    domainId: example.id,
    environmentBlueprintId: defaultDataLake.id,
    enabledRegions: ["us-east-1"],
    regionalParameters: {
        "us-east-1": {
            s3Location: "s3://my-amazon-datazone-bucket",
        },
    },
});
import pulumi
import pulumi_aws as aws

example = aws.datazone.Domain("example",
    name="example_domain",
    domain_execution_role=domain_execution_role["arn"])
default_data_lake = aws.datazone.get_environment_blueprint_output(domain_id=example.id,
    name="DefaultDataLake",
    managed=True)
example_environment_blueprint_configuration = aws.datazone.EnvironmentBlueprintConfiguration("example",
    domain_id=example.id,
    environment_blueprint_id=default_data_lake.id,
    enabled_regions=["us-east-1"],
    regional_parameters={
        "us-east-1": {
            "s3Location": "s3://my-amazon-datazone-bucket",
        },
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.DataZone.Domain("example", new()
    {
        Name = "example_domain",
        DomainExecutionRole = domainExecutionRole.Arn,
    });

    var defaultDataLake = Aws.DataZone.GetEnvironmentBlueprint.Invoke(new()
    {
        DomainId = example.Id,
        Name = "DefaultDataLake",
        Managed = true,
    });

    var exampleEnvironmentBlueprintConfiguration = new Aws.DataZone.EnvironmentBlueprintConfiguration("example", new()
    {
        DomainId = example.Id,
        EnvironmentBlueprintId = defaultDataLake.Apply(getEnvironmentBlueprintResult => getEnvironmentBlueprintResult.Id),
        EnabledRegions = new[]
        {
            "us-east-1",
        },
        RegionalParameters =
        {
            { "us-east-1", new InputMap<string>
            {
                { "s3Location", "s3://my-amazon-datazone-bucket" },
            } },
        },
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := datazone.NewDomain(ctx, "example", &datazone.DomainArgs{
			Name:                pulumi.String("example_domain"),
			DomainExecutionRole: pulumi.Any(domainExecutionRole.Arn),
		})
		if err != nil {
			return err
		}
		defaultDataLake := datazone.GetEnvironmentBlueprintOutput(ctx, datazone.GetEnvironmentBlueprintOutputArgs{
			DomainId: example.ID().ToIDOutput().ToStringOutput(),
			Name:     pulumi.String("DefaultDataLake"),
			Managed:  pulumi.Bool(true),
		}, nil)
		_, err = datazone.NewEnvironmentBlueprintConfiguration(ctx, "example", &datazone.EnvironmentBlueprintConfigurationArgs{
			DomainId:               example.ID().ToIDOutput().ToStringOutput(),
			EnvironmentBlueprintId: defaultDataLake.Id(),
			EnabledRegions: pulumi.StringArray{
				pulumi.String("us-east-1"),
			},
			RegionalParameters: pulumi.StringMapMap{
				"us-east-1": pulumi.StringMap{
					"s3Location": pulumi.String("s3://my-amazon-datazone-bucket"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_datazone_getenvironmentblueprint" "defaultDataLake" {
  domain_id = aws_datazone_domain.example.id
  name      = "DefaultDataLake"
  managed   = true
}

resource "aws_datazone_domain" "example" {
  name                  = "example_domain"
  domain_execution_role = domainExecutionRole.arn
}
resource "aws_datazone_environmentblueprintconfiguration" "example" {
  domain_id                = aws_datazone_domain.example.id
  environment_blueprint_id = data.aws_datazone_getenvironmentblueprint.defaultDataLake.id
  enabled_regions          = ["us-east-1"]
  regional_parameters = {
    "us-east-1" = {
      "s3Location" = "s3://my-amazon-datazone-bucket"
    }
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.datazone.Domain;
import com.pulumi.aws.datazone.DomainArgs;
import com.pulumi.aws.datazone.DatazoneFunctions;
import com.pulumi.aws.datazone.inputs.GetEnvironmentBlueprintArgs;
import com.pulumi.aws.datazone.EnvironmentBlueprintConfiguration;
import com.pulumi.aws.datazone.EnvironmentBlueprintConfigurationArgs;
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()
            .name("example_domain")
            .domainExecutionRole(domainExecutionRole.arn())
            .build());

        final var defaultDataLake = DatazoneFunctions.getEnvironmentBlueprint(GetEnvironmentBlueprintArgs.builder()
            .domainId(example.id())
            .name("DefaultDataLake")
            .managed(true)
            .build());

        var exampleEnvironmentBlueprintConfiguration = new EnvironmentBlueprintConfiguration("exampleEnvironmentBlueprintConfiguration", EnvironmentBlueprintConfigurationArgs.builder()
            .domainId(example.id())
            .environmentBlueprintId(defaultDataLake.applyValue(_defaultDataLake -> _defaultDataLake.id()))
            .enabledRegions("us-east-1")
            .regionalParameters(Map.of("us-east-1", Map.of("s3Location", "s3://my-amazon-datazone-bucket")))
            .build());

    }
}
resources:
  example:
    type: aws:datazone:Domain
    properties:
      name: example_domain
      domainExecutionRole: ${domainExecutionRole.arn}
  exampleEnvironmentBlueprintConfiguration:
    type: aws:datazone:EnvironmentBlueprintConfiguration
    name: example
    properties:
      domainId: ${example.id}
      environmentBlueprintId: ${defaultDataLake.id}
      enabledRegions:
        - us-east-1
      regionalParameters:
        us-east-1:
          s3Location: s3://my-amazon-datazone-bucket
variables:
  defaultDataLake:
    fn::invoke:
      function: aws:datazone:getEnvironmentBlueprint
      arguments:
        domainId: ${example.id}
        name: DefaultDataLake
        managed: true

Import

Identity Schema

Required

  • domainId - (String) ID of the DataZone domain.
  • environmentBlueprintId - (String) ID of the environment blueprint.

Optional

  • accountId (String) AWS Account where this resource is managed.
  • region (String) Region where this resource is managed.

Using pulumi import, import DataZone Environment Blueprint Configuration using the domainId and environmentBlueprintId, separated by a /. For example:

$ pulumi import aws:datazone/environmentBlueprintConfiguration:EnvironmentBlueprintConfiguration example domain-id-12345/environment-blueprint-id-54321

Constructors

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

Properties

childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
domainId ↔ Output<String>
ID of the Domain.
latefinal
enabledRegions ↔ Output<List<String>>
Regions in which the blueprint is enabled
latefinal
environmentBlueprintId ↔ Output<String>
ID of the Environment Blueprint
latefinal
globalParameters ↔ Output<Map<String, String>?>
A map of global parameters to configure for the blueprint across all regions.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
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
manageAccessRoleArn ↔ Output<String?>
ARN of the manage access role with which this blueprint is created.
latefinal
provisioningRoleArn ↔ Output<String?>
ARN of the provisioning role with which this blueprint is created.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
regionalParameters ↔ Output<Map<String, Map<String, String>>?>
Parameters for each region in which the blueprint is enabled
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
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, {EnvironmentBlueprintConfigurationState? state, CustomResourceOptions? options}) → EnvironmentBlueprintConfiguration
Gets an existing EnvironmentBlueprintConfiguration resource's state with the given name and id.