emr

package
v3.35.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 30, 2021 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Cluster 

type Cluster struct {
	pulumi.CustomResourceState

	// A JSON string for selecting additional features such as adding proxy information. Note: Currently there is no API to retrieve the value of this argument after EMR cluster creation from provider, therefore this provider cannot detect drift from the actual EMR cluster if its value is changed outside this provider.
	AdditionalInfo pulumi.StringPtrOutput `pulumi:"additionalInfo"`
	// A list of applications for the cluster. Valid values are: `Flink`, `Hadoop`, `Hive`, `Mahout`, `Pig`, `Spark`, and `JupyterHub` (as of EMR 5.14.0). Case insensitive
	Applications pulumi.StringArrayOutput `pulumi:"applications"`
	Arn          pulumi.StringOutput      `pulumi:"arn"`
	// An IAM role for automatic scaling policies. The IAM role provides permissions that the automatic scaling feature requires to launch and terminate EC2 instances in an instance group.
	AutoscalingRole pulumi.StringPtrOutput `pulumi:"autoscalingRole"`
	// Ordered list of bootstrap actions that will be run before Hadoop is started on the cluster nodes. Defined below.
	BootstrapActions ClusterBootstrapActionArrayOutput `pulumi:"bootstrapActions"`
	ClusterState     pulumi.StringOutput               `pulumi:"clusterState"`
	// A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.
	Configurations pulumi.StringPtrOutput `pulumi:"configurations"`
	// A JSON string for supplying list of configurations for the EMR cluster.
	ConfigurationsJson pulumi.StringPtrOutput `pulumi:"configurationsJson"`
	// Configuration block to use an [Instance Fleet](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-fleet.html) for the core node type. Cannot be specified if any `coreInstanceGroup` configuration blocks are set. Detailed below.
	CoreInstanceFleet ClusterCoreInstanceFleetOutput `pulumi:"coreInstanceFleet"`
	// Configuration block to use an [Instance Group](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-group-configuration.html#emr-plan-instance-groups) for the [core node type](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html#emr-plan-core).
	CoreInstanceGroup ClusterCoreInstanceGroupOutput `pulumi:"coreInstanceGroup"`
	// A custom Amazon Linux AMI for the cluster (instead of an EMR-owned AMI). Available in Amazon EMR version 5.7.0 and later.
	CustomAmiId pulumi.StringPtrOutput `pulumi:"customAmiId"`
	// Size in GiB of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Available in Amazon EMR version 4.x and later.
	EbsRootVolumeSize pulumi.IntPtrOutput `pulumi:"ebsRootVolumeSize"`
	// Attributes for the EC2 instances running the job flow. Defined below
	Ec2Attributes ClusterEc2AttributesPtrOutput `pulumi:"ec2Attributes"`
	// Switch on/off run cluster with no steps or when all steps are complete (default is on)
	KeepJobFlowAliveWhenNoSteps pulumi.BoolOutput `pulumi:"keepJobFlowAliveWhenNoSteps"`
	// Kerberos configuration for the cluster. Defined below
	KerberosAttributes ClusterKerberosAttributesPtrOutput `pulumi:"kerberosAttributes"`
	// S3 bucket to write the log files of the job flow. If a value is not provided, logs are not created
	LogUri pulumi.StringPtrOutput `pulumi:"logUri"`
	// Configuration block to use an [Instance Fleet](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-fleet.html) for the master node type. Cannot be specified if any `masterInstanceGroup` configuration blocks are set. Detailed below.
	MasterInstanceFleet ClusterMasterInstanceFleetOutput `pulumi:"masterInstanceFleet"`
	// Configuration block to use an [Instance Group](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-group-configuration.html#emr-plan-instance-groups) for the [master node type](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html#emr-plan-master).
	MasterInstanceGroup ClusterMasterInstanceGroupOutput `pulumi:"masterInstanceGroup"`
	// The public DNS name of the master EC2 instance.
	// * `core_instance_group.0.id` - Core node type Instance Group ID, if using Instance Group for this node type.
	MasterPublicDns pulumi.StringOutput `pulumi:"masterPublicDns"`
	// Friendly name given to the instance fleet.
	Name pulumi.StringOutput `pulumi:"name"`
	// The release label for the Amazon EMR release
	ReleaseLabel pulumi.StringOutput `pulumi:"releaseLabel"`
	// The way that individual Amazon EC2 instances terminate when an automatic scale-in activity occurs or an `instance group` is resized.
	ScaleDownBehavior pulumi.StringOutput `pulumi:"scaleDownBehavior"`
	// The security configuration name to attach to the EMR cluster. Only valid for EMR clusters with `releaseLabel` 4.8.0 or greater
	SecurityConfiguration pulumi.StringPtrOutput `pulumi:"securityConfiguration"`
	// IAM role that will be assumed by the Amazon EMR service to access AWS resources
	ServiceRole pulumi.StringOutput `pulumi:"serviceRole"`
	// The number of steps that can be executed concurrently. You can specify a maximum of 256 steps. Only valid for EMR clusters with `releaseLabel` 5.28.0 or greater. (default is 1)
	StepConcurrencyLevel pulumi.IntPtrOutput `pulumi:"stepConcurrencyLevel"`
	// List of steps to run when creating the cluster. Defined below. It is highly recommended to utilize [`ignoreChanges`](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) if other steps are being managed outside of this provider.
	Steps ClusterStepArrayOutput `pulumi:"steps"`
	// list of tags to apply to the EMR Cluster
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Switch on/off termination protection (default is `false`, except when using multiple master nodes). Before attempting to destroy the resource when termination protection is enabled, this configuration must be applied with its value set to `false`.
	TerminationProtection pulumi.BoolOutput `pulumi:"terminationProtection"`
	// Whether the job flow is visible to all IAM users of the AWS account associated with the job flow. Default `true`
	VisibleToAllUsers pulumi.BoolPtrOutput `pulumi:"visibleToAllUsers"`
}

Provides an Elastic MapReduce Cluster, a web service that makes it easy to process large amounts of data efficiently. See [Amazon Elastic MapReduce Documentation](https://aws.amazon.com/documentation/elastic-mapreduce/) for more information.

To configure [Instance Groups](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-group-configuration.html#emr-plan-instance-groups) for [task nodes](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html#emr-plan-task), see the `emr.InstanceGroup` resource.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/emr"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := emr.NewCluster(ctx, "cluster", &emr.ClusterArgs{
			ReleaseLabel: pulumi.String("emr-4.6.0"),
			Applications: pulumi.StringArray{
				pulumi.String("Spark"),
			},
			AdditionalInfo:              pulumi.String(fmt.Sprintf("%v%v%v%v%v%v", "{\n", "  \"instanceAwsClientConfiguration\": {\n", "    \"proxyPort\": 8099,\n", "    \"proxyHost\": \"myproxy.example.com\"\n", "  }\n", "}\n")),
			TerminationProtection:       pulumi.Bool(false),
			KeepJobFlowAliveWhenNoSteps: pulumi.Bool(true),
			Ec2Attributes: &emr.ClusterEc2AttributesArgs{
				SubnetId:                      pulumi.Any(aws_subnet.Main.Id),
				EmrManagedMasterSecurityGroup: pulumi.Any(aws_security_group.Sg.Id),
				EmrManagedSlaveSecurityGroup:  pulumi.Any(aws_security_group.Sg.Id),
				InstanceProfile:               pulumi.Any(aws_iam_instance_profile.Emr_profile.Arn),
			},
			MasterInstanceGroup: &emr.ClusterMasterInstanceGroupArgs{
				InstanceType: pulumi.String("m4.large"),
			},
			CoreInstanceGroup: &emr.ClusterCoreInstanceGroupArgs{
				InstanceType:  pulumi.String("c4.large"),
				InstanceCount: pulumi.Int(1),
				EbsConfigs: emr.ClusterCoreInstanceGroupEbsConfigArray{
					&emr.ClusterCoreInstanceGroupEbsConfigArgs{
						Size:               pulumi.Int(40),
						Type:               pulumi.String("gp2"),
						VolumesPerInstance: pulumi.Int(1),
					},
				},
				BidPrice:          pulumi.String("0.30"),
				AutoscalingPolicy: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "\"Constraints\": {\n", "  \"MinCapacity\": 1,\n", "  \"MaxCapacity\": 2\n", "},\n", "\"Rules\": [\n", "  {\n", "    \"Name\": \"ScaleOutMemoryPercentage\",\n", "    \"Description\": \"Scale out if YARNMemoryAvailablePercentage is less than 15\",\n", "    \"Action\": {\n", "      \"SimpleScalingPolicyConfiguration\": {\n", "        \"AdjustmentType\": \"CHANGE_IN_CAPACITY\",\n", "        \"ScalingAdjustment\": 1,\n", "        \"CoolDown\": 300\n", "      }\n", "    },\n", "    \"Trigger\": {\n", "      \"CloudWatchAlarmDefinition\": {\n", "        \"ComparisonOperator\": \"LESS_THAN\",\n", "        \"EvaluationPeriods\": 1,\n", "        \"MetricName\": \"YARNMemoryAvailablePercentage\",\n", "        \"Namespace\": \"AWS/ElasticMapReduce\",\n", "        \"Period\": 300,\n", "        \"Statistic\": \"AVERAGE\",\n", "        \"Threshold\": 15.0,\n", "        \"Unit\": \"PERCENT\"\n", "      }\n", "    }\n", "  }\n", "]\n", "}\n")),
			},
			EbsRootVolumeSize: pulumi.Int(100),
			Tags: pulumi.StringMap{
				"role": pulumi.String("rolename"),
				"env":  pulumi.String("env"),
			},
			BootstrapActions: emr.ClusterBootstrapActionArray{
				&emr.ClusterBootstrapActionArgs{
					Path: pulumi.String("s3://elasticmapreduce/bootstrap-actions/run-if"),
					Name: pulumi.String("runif"),
					Args: pulumi.StringArray{
						pulumi.String("instance.isMaster=true"),
						pulumi.String("echo running on master node"),
					},
				},
			},
			ConfigurationsJson: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v", "  [\n", "    {\n", "      \"Classification\": \"hadoop-env\",\n", "      \"Configurations\": [\n", "        {\n", "          \"Classification\": \"export\",\n", "          \"Properties\": {\n", "            \"JAVA_HOME\": \"/usr/lib/jvm/java-1.8.0\"\n", "          }\n", "        }\n", "      ],\n", "      \"Properties\": {}\n", "    },\n", "    {\n", "      \"Classification\": \"spark-env\",\n", "      \"Configurations\": [\n", "        {\n", "          \"Classification\": \"export\",\n", "          \"Properties\": {\n", "            \"JAVA_HOME\": \"/usr/lib/jvm/java-1.8.0\"\n", "          }\n", "        }\n", "      ],\n", "      \"Properties\": {}\n", "    }\n", "  ]\n")),
			ServiceRole:        pulumi.Any(aws_iam_role.Iam_emr_service_role.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

The `emr.Cluster` resource typically requires two IAM roles, one for the EMR Cluster to use as a service, and another to place on your Cluster Instances to interact with AWS from those instances. The suggested role policy template for the EMR service is `AmazonElasticMapReduceRole`, and `AmazonElasticMapReduceforEC2Role` for the EC2 profile. See the [Getting Started](https://docs.aws.amazon.com/ElasticMapReduce/latest/ManagementGuide/emr-gs-launch-sample-cluster.html) guide for more information on these IAM roles. There is also a fully-bootable example this provider configuration at the bottom of this page. ## Instance Fleet

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/emr"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := emr.NewCluster(ctx, "example", &emr.ClusterArgs{
			MasterInstanceFleet: &emr.ClusterMasterInstanceFleetArgs{
				InstanceTypeConfigs: emr.ClusterMasterInstanceFleetInstanceTypeConfigArray{
					&emr.ClusterMasterInstanceFleetInstanceTypeConfigArgs{
						InstanceType: pulumi.String("m4.xlarge"),
					},
				},
				TargetOnDemandCapacity: pulumi.Int(1),
			},
			CoreInstanceFleet: &emr.ClusterCoreInstanceFleetArgs{
				InstanceTypeConfigs: emr.ClusterCoreInstanceFleetInstanceTypeConfigArray{
					&emr.ClusterCoreInstanceFleetInstanceTypeConfigArgs{
						BidPriceAsPercentageOfOnDemandPrice: pulumi.Float64(80),
						EbsConfigs: emr.ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray{
							&emr.ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs{
								Size:               pulumi.Int(100),
								Type:               pulumi.String("gp2"),
								VolumesPerInstance: pulumi.Int(1),
							},
						},
						InstanceType:     pulumi.String("m3.xlarge"),
						WeightedCapacity: pulumi.Int(1),
					},
					&emr.ClusterCoreInstanceFleetInstanceTypeConfigArgs{
						BidPriceAsPercentageOfOnDemandPrice: pulumi.Float64(100),
						EbsConfigs: emr.ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray{
							&emr.ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs{
								Size:               pulumi.Int(100),
								Type:               pulumi.String("gp2"),
								VolumesPerInstance: pulumi.Int(1),
							},
						},
						InstanceType:     pulumi.String("m4.xlarge"),
						WeightedCapacity: pulumi.Int(1),
					},
					&emr.ClusterCoreInstanceFleetInstanceTypeConfigArgs{
						BidPriceAsPercentageOfOnDemandPrice: pulumi.Float64(100),
						EbsConfigs: emr.ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray{
							&emr.ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs{
								Size:               pulumi.Int(100),
								Type:               pulumi.String("gp2"),
								VolumesPerInstance: pulumi.Int(1),
							},
						},
						InstanceType:     pulumi.String("m4.2xlarge"),
						WeightedCapacity: pulumi.Int(2),
					},
				},
				LaunchSpecifications: &emr.ClusterCoreInstanceFleetLaunchSpecificationsArgs{
					SpotSpecifications: emr.ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArray{
						&emr.ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs{
							AllocationStrategy:     pulumi.String("capacity-optimized"),
							BlockDurationMinutes:   pulumi.Int(0),
							TimeoutAction:          pulumi.String("SWITCH_TO_ON_DEMAND"),
							TimeoutDurationMinutes: pulumi.Int(10),
						},
					},
				},
				Name:                   pulumi.String("core fleet"),
				TargetOnDemandCapacity: pulumi.Int(2),
				TargetSpotCapacity:     pulumi.Int(2),
			},
		})
		if err != nil {
			return err
		}
		_, err = emr.NewInstanceFleet(ctx, "task", &emr.InstanceFleetArgs{
			ClusterId: example.ID(),
			InstanceTypeConfigs: emr.InstanceFleetInstanceTypeConfigArray{
				&emr.InstanceFleetInstanceTypeConfigArgs{
					BidPriceAsPercentageOfOnDemandPrice: pulumi.Float64(100),
					EbsConfigs: emr.InstanceFleetInstanceTypeConfigEbsConfigArray{
						&emr.InstanceFleetInstanceTypeConfigEbsConfigArgs{
							Size:               pulumi.Int(100),
							Type:               pulumi.String("gp2"),
							VolumesPerInstance: pulumi.Int(1),
						},
					},
					InstanceType:     pulumi.String("m4.xlarge"),
					WeightedCapacity: pulumi.Int(1),
				},
				&emr.InstanceFleetInstanceTypeConfigArgs{
					BidPriceAsPercentageOfOnDemandPrice: pulumi.Float64(100),
					EbsConfigs: emr.InstanceFleetInstanceTypeConfigEbsConfigArray{
						&emr.InstanceFleetInstanceTypeConfigEbsConfigArgs{
							Size:               pulumi.Int(100),
							Type:               pulumi.String("gp2"),
							VolumesPerInstance: pulumi.Int(1),
						},
					},
					InstanceType:     pulumi.String("m4.2xlarge"),
					WeightedCapacity: pulumi.Int(2),
				},
			},
			LaunchSpecifications: &emr.InstanceFleetLaunchSpecificationsArgs{
				SpotSpecifications: emr.InstanceFleetLaunchSpecificationsSpotSpecificationArray{
					&emr.InstanceFleetLaunchSpecificationsSpotSpecificationArgs{
						AllocationStrategy:     pulumi.String("capacity-optimized"),
						BlockDurationMinutes:   pulumi.Int(0),
						TimeoutAction:          pulumi.String("TERMINATE_CLUSTER"),
						TimeoutDurationMinutes: pulumi.Int(10),
					},
				},
			},
			TargetOnDemandCapacity: pulumi.Int(1),
			TargetSpotCapacity:     pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

### Enable Debug Logging

[Debug logging in EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-debugging.html) is implemented as a step. It is highly recommended to utilize [`ignoreChanges`](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) if other steps are being managed outside of this provider.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/emr"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := emr.NewCluster(ctx, "example", &emr.ClusterArgs{
			Steps: emr.ClusterStepArray{
				&emr.ClusterStepArgs{
					ActionOnFailure: pulumi.String("TERMINATE_CLUSTER"),
					Name:            pulumi.String("Setup Hadoop Debugging"),
					HadoopJarStep: &emr.ClusterStepHadoopJarStepArgs{
						Jar: pulumi.String("command-runner.jar"),
						Args: pulumi.StringArray{
							pulumi.String("state-pusher-script"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

### Multiple Node Master Instance Group

Available in EMR version 5.23.0 and later, an EMR Cluster can be launched with three master nodes for high availability. Additional information about this functionality and its requirements can be found in the [EMR Management Guide](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-ha.html).

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/emr"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleSubnet, err := ec2.NewSubnet(ctx, "exampleSubnet", &ec2.SubnetArgs{
			MapPublicIpOnLaunch: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = emr.NewCluster(ctx, "exampleCluster", &emr.ClusterArgs{
			ReleaseLabel:          pulumi.String("emr-5.24.1"),
			TerminationProtection: pulumi.Bool(true),
			Ec2Attributes: &emr.ClusterEc2AttributesArgs{
				SubnetId: exampleSubnet.ID(),
			},
			MasterInstanceGroup: &emr.ClusterMasterInstanceGroupArgs{
				InstanceCount: pulumi.Int(3),
			},
			CoreInstanceGroup: nil,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Example bootable config

**NOTE:** This configuration demonstrates a minimal configuration needed to boot an example EMR Cluster. It is not meant to display best practices. Please use at your own risk.

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/emr"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		mainVpc, err := ec2.NewVpc(ctx, "mainVpc", &ec2.VpcArgs{
			CidrBlock:          pulumi.String("168.31.0.0/16"),
			EnableDnsHostnames: pulumi.Bool(true),
			Tags: pulumi.StringMap{
				"name": pulumi.String("emr_test"),
			},
		})
		if err != nil {
			return err
		}
		mainSubnet, err := ec2.NewSubnet(ctx, "mainSubnet", &ec2.SubnetArgs{
			VpcId:     mainVpc.ID(),
			CidrBlock: pulumi.String("168.31.0.0/20"),
			Tags: pulumi.StringMap{
				"name": pulumi.String("emr_test"),
			},
		})
		if err != nil {
			return err
		}
		iamEmrServiceRole, err := iam.NewRole(ctx, "iamEmrServiceRole", &iam.RoleArgs{
			AssumeRolePolicy: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Version\": \"2008-10-17\",\n", "  \"Statement\": [\n", "    {\n", "      \"Sid\": \"\",\n", "      \"Effect\": \"Allow\",\n", "      \"Principal\": {\n", "        \"Service\": \"elasticmapreduce.amazonaws.com\"\n", "      },\n", "      \"Action\": \"sts:AssumeRole\"\n", "    }\n", "  ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		iamEmrProfileRole, err := iam.NewRole(ctx, "iamEmrProfileRole", &iam.RoleArgs{
			AssumeRolePolicy: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Version\": \"2008-10-17\",\n", "  \"Statement\": [\n", "    {\n", "      \"Sid\": \"\",\n", "      \"Effect\": \"Allow\",\n", "      \"Principal\": {\n", "        \"Service\": \"ec2.amazonaws.com\"\n", "      },\n", "      \"Action\": \"sts:AssumeRole\"\n", "    }\n", "  ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		emrProfile, err := iam.NewInstanceProfile(ctx, "emrProfile", &iam.InstanceProfileArgs{
			Role: iamEmrProfileRole.Name,
		})
		if err != nil {
			return err
		}
		_, err = emr.NewCluster(ctx, "cluster", &emr.ClusterArgs{
			ReleaseLabel: pulumi.String("emr-4.6.0"),
			Applications: pulumi.StringArray{
				pulumi.String("Spark"),
			},
			Ec2Attributes: &emr.ClusterEc2AttributesArgs{
				SubnetId:                      mainSubnet.ID(),
				EmrManagedMasterSecurityGroup: pulumi.Any(aws_security_group.Allow_all.Id),
				EmrManagedSlaveSecurityGroup:  pulumi.Any(aws_security_group.Allow_all.Id),
				InstanceProfile:               emrProfile.Arn,
			},
			MasterInstanceGroup: &emr.ClusterMasterInstanceGroupArgs{
				InstanceType: pulumi.String("m5.xlarge"),
			},
			CoreInstanceGroup: &emr.ClusterCoreInstanceGroupArgs{
				InstanceCount: pulumi.Int(1),
				InstanceType:  pulumi.String("m5.xlarge"),
			},
			Tags: pulumi.StringMap{
				"role":     pulumi.String("rolename"),
				"dns_zone": pulumi.String("env_zone"),
				"env":      pulumi.String("env"),
				"name":     pulumi.String("name-env"),
			},
			BootstrapActions: emr.ClusterBootstrapActionArray{
				&emr.ClusterBootstrapActionArgs{
					Path: pulumi.String("s3://elasticmapreduce/bootstrap-actions/run-if"),
					Name: pulumi.String("runif"),
					Args: pulumi.StringArray{
						pulumi.String("instance.isMaster=true"),
						pulumi.String("echo running on master node"),
					},
				},
			},
			ConfigurationsJson: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v", "  [\n", "    {\n", "      \"Classification\": \"hadoop-env\",\n", "      \"Configurations\": [\n", "        {\n", "          \"Classification\": \"export\",\n", "          \"Properties\": {\n", "            \"JAVA_HOME\": \"/usr/lib/jvm/java-1.8.0\"\n", "          }\n", "        }\n", "      ],\n", "      \"Properties\": {}\n", "    },\n", "    {\n", "      \"Classification\": \"spark-env\",\n", "      \"Configurations\": [\n", "        {\n", "          \"Classification\": \"export\",\n", "          \"Properties\": {\n", "            \"JAVA_HOME\": \"/usr/lib/jvm/java-1.8.0\"\n", "          }\n", "        }\n", "      ],\n", "      \"Properties\": {}\n", "    }\n", "  ]\n")),
			ServiceRole:        iamEmrServiceRole.Arn,
		})
		if err != nil {
			return err
		}
		_, err = ec2.NewSecurityGroup(ctx, "allowAccess", &ec2.SecurityGroupArgs{
			Description: pulumi.String("Allow inbound traffic"),
			VpcId:       mainVpc.ID(),
			Ingress: ec2.SecurityGroupIngressArray{
				&ec2.SecurityGroupIngressArgs{
					FromPort:   pulumi.Int(0),
					ToPort:     pulumi.Int(0),
					Protocol:   pulumi.String("-1"),
					CidrBlocks: mainVpc.CidrBlock,
				},
			},
			Egress: ec2.SecurityGroupEgressArray{
				&ec2.SecurityGroupEgressArgs{
					FromPort: pulumi.Int(0),
					ToPort:   pulumi.Int(0),
					Protocol: pulumi.String("-1"),
					CidrBlocks: pulumi.StringArray{
						pulumi.String("0.0.0.0/0"),
					},
				},
			},
			Tags: pulumi.StringMap{
				"name": pulumi.String("emr_test"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			mainSubnet,
		}))
		if err != nil {
			return err
		}
		gw, err := ec2.NewInternetGateway(ctx, "gw", &ec2.InternetGatewayArgs{
			VpcId: mainVpc.ID(),
		})
		if err != nil {
			return err
		}
		routeTable, err := ec2.NewRouteTable(ctx, "routeTable", &ec2.RouteTableArgs{
			VpcId: mainVpc.ID(),
			Routes: ec2.RouteTableRouteArray{
				&ec2.RouteTableRouteArgs{
					CidrBlock: pulumi.String("0.0.0.0/0"),
					GatewayId: gw.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = ec2.NewMainRouteTableAssociation(ctx, "mainRouteTableAssociation", &ec2.MainRouteTableAssociationArgs{
			VpcId:        mainVpc.ID(),
			RouteTableId: routeTable.ID(),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewRolePolicy(ctx, "iamEmrServicePolicy", &iam.RolePolicyArgs{
			Role:   iamEmrServiceRole.ID(),
			Policy: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "    \"Version\": \"2012-10-17\",\n", "    \"Statement\": [{\n", "        \"Effect\": \"Allow\",\n", "        \"Resource\": \"*\",\n", "        \"Action\": [\n", "            \"ec2:AuthorizeSecurityGroupEgress\",\n", "            \"ec2:AuthorizeSecurityGroupIngress\",\n", "            \"ec2:CancelSpotInstanceRequests\",\n", "            \"ec2:CreateNetworkInterface\",\n", "            \"ec2:CreateSecurityGroup\",\n", "            \"ec2:CreateTags\",\n", "            \"ec2:DeleteNetworkInterface\",\n", "            \"ec2:DeleteSecurityGroup\",\n", "            \"ec2:DeleteTags\",\n", "            \"ec2:DescribeAvailabilityZones\",\n", "            \"ec2:DescribeAccountAttributes\",\n", "            \"ec2:DescribeDhcpOptions\",\n", "            \"ec2:DescribeInstanceStatus\",\n", "            \"ec2:DescribeInstances\",\n", "            \"ec2:DescribeKeyPairs\",\n", "            \"ec2:DescribeNetworkAcls\",\n", "            \"ec2:DescribeNetworkInterfaces\",\n", "            \"ec2:DescribePrefixLists\",\n", "            \"ec2:DescribeRouteTables\",\n", "            \"ec2:DescribeSecurityGroups\",\n", "            \"ec2:DescribeSpotInstanceRequests\",\n", "            \"ec2:DescribeSpotPriceHistory\",\n", "            \"ec2:DescribeSubnets\",\n", "            \"ec2:DescribeVpcAttribute\",\n", "            \"ec2:DescribeVpcEndpoints\",\n", "            \"ec2:DescribeVpcEndpointServices\",\n", "            \"ec2:DescribeVpcs\",\n", "            \"ec2:DetachNetworkInterface\",\n", "            \"ec2:ModifyImageAttribute\",\n", "            \"ec2:ModifyInstanceAttribute\",\n", "            \"ec2:RequestSpotInstances\",\n", "            \"ec2:RevokeSecurityGroupEgress\",\n", "            \"ec2:RunInstances\",\n", "            \"ec2:TerminateInstances\",\n", "            \"ec2:DeleteVolume\",\n", "            \"ec2:DescribeVolumeStatus\",\n", "            \"ec2:DescribeVolumes\",\n", "            \"ec2:DetachVolume\",\n", "            \"iam:GetRole\",\n", "            \"iam:GetRolePolicy\",\n", "            \"iam:ListInstanceProfiles\",\n", "            \"iam:ListRolePolicies\",\n", "            \"iam:PassRole\",\n", "            \"s3:CreateBucket\",\n", "            \"s3:Get*\",\n", "            \"s3:List*\",\n", "            \"sdb:BatchPutAttributes\",\n", "            \"sdb:Select\",\n", "            \"sqs:CreateQueue\",\n", "            \"sqs:Delete*\",\n", "            \"sqs:GetQueue*\",\n", "            \"sqs:PurgeQueue\",\n", "            \"sqs:ReceiveMessage\"\n", "        ]\n", "    }]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewRolePolicy(ctx, "iamEmrProfilePolicy", &iam.RolePolicyArgs{
			Role:   iamEmrProfileRole.ID(),
			Policy: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "    \"Version\": \"2012-10-17\",\n", "    \"Statement\": [{\n", "        \"Effect\": \"Allow\",\n", "        \"Resource\": \"*\",\n", "        \"Action\": [\n", "            \"cloudwatch:*\",\n", "            \"dynamodb:*\",\n", "            \"ec2:Describe*\",\n", "            \"elasticmapreduce:Describe*\",\n", "            \"elasticmapreduce:ListBootstrapActions\",\n", "            \"elasticmapreduce:ListClusters\",\n", "            \"elasticmapreduce:ListInstanceGroups\",\n", "            \"elasticmapreduce:ListInstances\",\n", "            \"elasticmapreduce:ListSteps\",\n", "            \"kinesis:CreateStream\",\n", "            \"kinesis:DeleteStream\",\n", "            \"kinesis:DescribeStream\",\n", "            \"kinesis:GetRecords\",\n", "            \"kinesis:GetShardIterator\",\n", "            \"kinesis:MergeShards\",\n", "            \"kinesis:PutRecord\",\n", "            \"kinesis:SplitShard\",\n", "            \"rds:Describe*\",\n", "            \"s3:*\",\n", "            \"sdb:*\",\n", "            \"sns:*\",\n", "            \"sqs:*\"\n", "        ]\n", "    }]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

EMR clusters can be imported using the `id`, e.g.

```sh 

$ pulumi import aws:emr/cluster:Cluster cluster j-123456ABCDEF

``` 

Since the API does not return the actual values for Kerberos configurations, environments with those this provider configurations will need to use the [`ignoreChanges`](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) available to all this provider resources to prevent perpetual differences, e.g. terraform resource "aws_emr_cluster" "example" {

... other configuration ... 

lifecycle {

ignore_changes = [kerberos_attributes]

} }

func GetCluster 

func GetCluster(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ClusterState, opts ...pulumi.ResourceOption) (*Cluster, error)

GetCluster gets an existing Cluster resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewCluster 

func NewCluster(ctx *pulumi.Context,
	name string, args *ClusterArgs, opts ...pulumi.ResourceOption) (*Cluster, error)

NewCluster registers a new resource with the given unique name, arguments, and options.

func (*Cluster) ElementType added in v3.13.0 

func (*Cluster) ElementType() reflect.Type

func (*Cluster) ToClusterOutput added in v3.13.0 

func (i *Cluster) ToClusterOutput() ClusterOutput

func (*Cluster) ToClusterOutputWithContext added in v3.13.0 

func (i *Cluster) ToClusterOutputWithContext(ctx context.Context) ClusterOutput

func (*Cluster) ToClusterPtrOutput added in v3.25.0 

func (i *Cluster) ToClusterPtrOutput() ClusterPtrOutput

func (*Cluster) ToClusterPtrOutputWithContext added in v3.25.0 

func (i *Cluster) ToClusterPtrOutputWithContext(ctx context.Context) ClusterPtrOutput

type ClusterArgs 

type ClusterArgs struct {
	// A JSON string for selecting additional features such as adding proxy information. Note: Currently there is no API to retrieve the value of this argument after EMR cluster creation from provider, therefore this provider cannot detect drift from the actual EMR cluster if its value is changed outside this provider.
	AdditionalInfo pulumi.StringPtrInput
	// A list of applications for the cluster. Valid values are: `Flink`, `Hadoop`, `Hive`, `Mahout`, `Pig`, `Spark`, and `JupyterHub` (as of EMR 5.14.0). Case insensitive
	Applications pulumi.StringArrayInput
	// An IAM role for automatic scaling policies. The IAM role provides permissions that the automatic scaling feature requires to launch and terminate EC2 instances in an instance group.
	AutoscalingRole pulumi.StringPtrInput
	// Ordered list of bootstrap actions that will be run before Hadoop is started on the cluster nodes. Defined below.
	BootstrapActions ClusterBootstrapActionArrayInput
	// A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.
	Configurations pulumi.StringPtrInput
	// A JSON string for supplying list of configurations for the EMR cluster.
	ConfigurationsJson pulumi.StringPtrInput
	// Configuration block to use an [Instance Fleet](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-fleet.html) for the core node type. Cannot be specified if any `coreInstanceGroup` configuration blocks are set. Detailed below.
	CoreInstanceFleet ClusterCoreInstanceFleetPtrInput
	// Configuration block to use an [Instance Group](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-group-configuration.html#emr-plan-instance-groups) for the [core node type](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html#emr-plan-core).
	CoreInstanceGroup ClusterCoreInstanceGroupPtrInput
	// A custom Amazon Linux AMI for the cluster (instead of an EMR-owned AMI). Available in Amazon EMR version 5.7.0 and later.
	CustomAmiId pulumi.StringPtrInput
	// Size in GiB of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Available in Amazon EMR version 4.x and later.
	EbsRootVolumeSize pulumi.IntPtrInput
	// Attributes for the EC2 instances running the job flow. Defined below
	Ec2Attributes ClusterEc2AttributesPtrInput
	// Switch on/off run cluster with no steps or when all steps are complete (default is on)
	KeepJobFlowAliveWhenNoSteps pulumi.BoolPtrInput
	// Kerberos configuration for the cluster. Defined below
	KerberosAttributes ClusterKerberosAttributesPtrInput
	// S3 bucket to write the log files of the job flow. If a value is not provided, logs are not created
	LogUri pulumi.StringPtrInput
	// Configuration block to use an [Instance Fleet](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-fleet.html) for the master node type. Cannot be specified if any `masterInstanceGroup` configuration blocks are set. Detailed below.
	MasterInstanceFleet ClusterMasterInstanceFleetPtrInput
	// Configuration block to use an [Instance Group](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-group-configuration.html#emr-plan-instance-groups) for the [master node type](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html#emr-plan-master).
	MasterInstanceGroup ClusterMasterInstanceGroupPtrInput
	// Friendly name given to the instance fleet.
	Name pulumi.StringPtrInput
	// The release label for the Amazon EMR release
	ReleaseLabel pulumi.StringInput
	// The way that individual Amazon EC2 instances terminate when an automatic scale-in activity occurs or an `instance group` is resized.
	ScaleDownBehavior pulumi.StringPtrInput
	// The security configuration name to attach to the EMR cluster. Only valid for EMR clusters with `releaseLabel` 4.8.0 or greater
	SecurityConfiguration pulumi.StringPtrInput
	// IAM role that will be assumed by the Amazon EMR service to access AWS resources
	ServiceRole pulumi.StringInput
	// The number of steps that can be executed concurrently. You can specify a maximum of 256 steps. Only valid for EMR clusters with `releaseLabel` 5.28.0 or greater. (default is 1)
	StepConcurrencyLevel pulumi.IntPtrInput
	// List of steps to run when creating the cluster. Defined below. It is highly recommended to utilize [`ignoreChanges`](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) if other steps are being managed outside of this provider.
	Steps ClusterStepArrayInput
	// list of tags to apply to the EMR Cluster
	Tags pulumi.StringMapInput
	// Switch on/off termination protection (default is `false`, except when using multiple master nodes). Before attempting to destroy the resource when termination protection is enabled, this configuration must be applied with its value set to `false`.
	TerminationProtection pulumi.BoolPtrInput
	// Whether the job flow is visible to all IAM users of the AWS account associated with the job flow. Default `true`
	VisibleToAllUsers pulumi.BoolPtrInput
}

The set of arguments for constructing a Cluster resource.

func (ClusterArgs) ElementType 

func (ClusterArgs) ElementType() reflect.Type

type ClusterArray added in v3.25.0 

type ClusterArray []ClusterInput

func (ClusterArray) ElementType added in v3.25.0 

func (ClusterArray) ElementType() reflect.Type

func (ClusterArray) ToClusterArrayOutput added in v3.25.0 

func (i ClusterArray) ToClusterArrayOutput() ClusterArrayOutput

func (ClusterArray) ToClusterArrayOutputWithContext added in v3.25.0 

func (i ClusterArray) ToClusterArrayOutputWithContext(ctx context.Context) ClusterArrayOutput

type ClusterArrayInput added in v3.25.0 

type ClusterArrayInput interface {
	pulumi.Input

	ToClusterArrayOutput() ClusterArrayOutput
	ToClusterArrayOutputWithContext(context.Context) ClusterArrayOutput
}

ClusterArrayInput is an input type that accepts ClusterArray and ClusterArrayOutput values. You can construct a concrete instance of `ClusterArrayInput` via: 

ClusterArray{ ClusterArgs{...} }

type ClusterArrayOutput added in v3.25.0 

type ClusterArrayOutput struct{ *pulumi.OutputState }

func (ClusterArrayOutput) ElementType added in v3.25.0 

func (ClusterArrayOutput) ElementType() reflect.Type

func (ClusterArrayOutput) Index added in v3.25.0 

func (o ClusterArrayOutput) Index(i pulumi.IntInput) ClusterOutput

func (ClusterArrayOutput) ToClusterArrayOutput added in v3.25.0 

func (o ClusterArrayOutput) ToClusterArrayOutput() ClusterArrayOutput

func (ClusterArrayOutput) ToClusterArrayOutputWithContext added in v3.25.0 

func (o ClusterArrayOutput) ToClusterArrayOutputWithContext(ctx context.Context) ClusterArrayOutput

type ClusterBootstrapAction 

type ClusterBootstrapAction struct {
	// List of command line arguments passed to the JAR file's main function when executed.
	Args []string `pulumi:"args"`
	// Friendly name given to the instance fleet.
	Name string `pulumi:"name"`
	// Location of the script to run during a bootstrap action. Can be either a location in Amazon S3 or on a local file system
	Path string `pulumi:"path"`
}

type ClusterBootstrapActionArgs 

type ClusterBootstrapActionArgs struct {
	// List of command line arguments passed to the JAR file's main function when executed.
	Args pulumi.StringArrayInput `pulumi:"args"`
	// Friendly name given to the instance fleet.
	Name pulumi.StringInput `pulumi:"name"`
	// Location of the script to run during a bootstrap action. Can be either a location in Amazon S3 or on a local file system
	Path pulumi.StringInput `pulumi:"path"`
}

func (ClusterBootstrapActionArgs) ElementType 

func (ClusterBootstrapActionArgs) ElementType() reflect.Type

func (ClusterBootstrapActionArgs) ToClusterBootstrapActionOutput 

func (i ClusterBootstrapActionArgs) ToClusterBootstrapActionOutput() ClusterBootstrapActionOutput

func (ClusterBootstrapActionArgs) ToClusterBootstrapActionOutputWithContext 

func (i ClusterBootstrapActionArgs) ToClusterBootstrapActionOutputWithContext(ctx context.Context) ClusterBootstrapActionOutput

type ClusterBootstrapActionArray 

type ClusterBootstrapActionArray []ClusterBootstrapActionInput

func (ClusterBootstrapActionArray) ElementType 

func (ClusterBootstrapActionArray) ElementType() reflect.Type

func (ClusterBootstrapActionArray) ToClusterBootstrapActionArrayOutput 

func (i ClusterBootstrapActionArray) ToClusterBootstrapActionArrayOutput() ClusterBootstrapActionArrayOutput

func (ClusterBootstrapActionArray) ToClusterBootstrapActionArrayOutputWithContext 

func (i ClusterBootstrapActionArray) ToClusterBootstrapActionArrayOutputWithContext(ctx context.Context) ClusterBootstrapActionArrayOutput

type ClusterBootstrapActionArrayInput 

type ClusterBootstrapActionArrayInput interface {
	pulumi.Input

	ToClusterBootstrapActionArrayOutput() ClusterBootstrapActionArrayOutput
	ToClusterBootstrapActionArrayOutputWithContext(context.Context) ClusterBootstrapActionArrayOutput
}

ClusterBootstrapActionArrayInput is an input type that accepts ClusterBootstrapActionArray and ClusterBootstrapActionArrayOutput values. You can construct a concrete instance of `ClusterBootstrapActionArrayInput` via: 

ClusterBootstrapActionArray{ ClusterBootstrapActionArgs{...} }

type ClusterBootstrapActionArrayOutput 

type ClusterBootstrapActionArrayOutput struct{ *pulumi.OutputState }

func (ClusterBootstrapActionArrayOutput) ElementType 

func (ClusterBootstrapActionArrayOutput) ElementType() reflect.Type

func (ClusterBootstrapActionArrayOutput) Index 

func (o ClusterBootstrapActionArrayOutput) Index(i pulumi.IntInput) ClusterBootstrapActionOutput

func (ClusterBootstrapActionArrayOutput) ToClusterBootstrapActionArrayOutput 

func (o ClusterBootstrapActionArrayOutput) ToClusterBootstrapActionArrayOutput() ClusterBootstrapActionArrayOutput

func (ClusterBootstrapActionArrayOutput) ToClusterBootstrapActionArrayOutputWithContext 

func (o ClusterBootstrapActionArrayOutput) ToClusterBootstrapActionArrayOutputWithContext(ctx context.Context) ClusterBootstrapActionArrayOutput

type ClusterBootstrapActionInput 

type ClusterBootstrapActionInput interface {
	pulumi.Input

	ToClusterBootstrapActionOutput() ClusterBootstrapActionOutput
	ToClusterBootstrapActionOutputWithContext(context.Context) ClusterBootstrapActionOutput
}

ClusterBootstrapActionInput is an input type that accepts ClusterBootstrapActionArgs and ClusterBootstrapActionOutput values. You can construct a concrete instance of `ClusterBootstrapActionInput` via: 

ClusterBootstrapActionArgs{...}

type ClusterBootstrapActionOutput 

type ClusterBootstrapActionOutput struct{ *pulumi.OutputState }

func (ClusterBootstrapActionOutput) Args 

func (o ClusterBootstrapActionOutput) Args() pulumi.StringArrayOutput

List of command line arguments passed to the JAR file's main function when executed.

func (ClusterBootstrapActionOutput) ElementType 

func (ClusterBootstrapActionOutput) ElementType() reflect.Type

func (ClusterBootstrapActionOutput) Name 

func (o ClusterBootstrapActionOutput) Name() pulumi.StringOutput

Friendly name given to the instance fleet.

func (ClusterBootstrapActionOutput) Path 

func (o ClusterBootstrapActionOutput) Path() pulumi.StringOutput

Location of the script to run during a bootstrap action. Can be either a location in Amazon S3 or on a local file system

func (ClusterBootstrapActionOutput) ToClusterBootstrapActionOutput 

func (o ClusterBootstrapActionOutput) ToClusterBootstrapActionOutput() ClusterBootstrapActionOutput

func (ClusterBootstrapActionOutput) ToClusterBootstrapActionOutputWithContext 

func (o ClusterBootstrapActionOutput) ToClusterBootstrapActionOutputWithContext(ctx context.Context) ClusterBootstrapActionOutput

type ClusterCoreInstanceFleet added in v3.3.0 

type ClusterCoreInstanceFleet struct {
	// The ID of the EMR Cluster
	Id *string `pulumi:"id"`
	// Configuration block for instance fleet
	InstanceTypeConfigs []ClusterCoreInstanceFleetInstanceTypeConfig `pulumi:"instanceTypeConfigs"`
	// Configuration block for launch specification
	LaunchSpecifications *ClusterCoreInstanceFleetLaunchSpecifications `pulumi:"launchSpecifications"`
	// Friendly name given to the instance fleet.
	Name                        *string `pulumi:"name"`
	ProvisionedOnDemandCapacity *int    `pulumi:"provisionedOnDemandCapacity"`
	ProvisionedSpotCapacity     *int    `pulumi:"provisionedSpotCapacity"`
	// The target capacity of On-Demand units for the instance fleet, which determines how many On-Demand instances to provision.
	TargetOnDemandCapacity *int `pulumi:"targetOnDemandCapacity"`
	// The target capacity of Spot units for the instance fleet, which determines how many Spot instances to provision.
	TargetSpotCapacity *int `pulumi:"targetSpotCapacity"`
}

type ClusterCoreInstanceFleetArgs added in v3.3.0 

type ClusterCoreInstanceFleetArgs struct {
	// The ID of the EMR Cluster
	Id pulumi.StringPtrInput `pulumi:"id"`
	// Configuration block for instance fleet
	InstanceTypeConfigs ClusterCoreInstanceFleetInstanceTypeConfigArrayInput `pulumi:"instanceTypeConfigs"`
	// Configuration block for launch specification
	LaunchSpecifications ClusterCoreInstanceFleetLaunchSpecificationsPtrInput `pulumi:"launchSpecifications"`
	// Friendly name given to the instance fleet.
	Name                        pulumi.StringPtrInput `pulumi:"name"`
	ProvisionedOnDemandCapacity pulumi.IntPtrInput    `pulumi:"provisionedOnDemandCapacity"`
	ProvisionedSpotCapacity     pulumi.IntPtrInput    `pulumi:"provisionedSpotCapacity"`
	// The target capacity of On-Demand units for the instance fleet, which determines how many On-Demand instances to provision.
	TargetOnDemandCapacity pulumi.IntPtrInput `pulumi:"targetOnDemandCapacity"`
	// The target capacity of Spot units for the instance fleet, which determines how many Spot instances to provision.
	TargetSpotCapacity pulumi.IntPtrInput `pulumi:"targetSpotCapacity"`
}

func (ClusterCoreInstanceFleetArgs) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetArgs) ElementType() reflect.Type

func (ClusterCoreInstanceFleetArgs) ToClusterCoreInstanceFleetOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetArgs) ToClusterCoreInstanceFleetOutput() ClusterCoreInstanceFleetOutput

func (ClusterCoreInstanceFleetArgs) ToClusterCoreInstanceFleetOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetArgs) ToClusterCoreInstanceFleetOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetOutput

func (ClusterCoreInstanceFleetArgs) ToClusterCoreInstanceFleetPtrOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetArgs) ToClusterCoreInstanceFleetPtrOutput() ClusterCoreInstanceFleetPtrOutput

func (ClusterCoreInstanceFleetArgs) ToClusterCoreInstanceFleetPtrOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetArgs) ToClusterCoreInstanceFleetPtrOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetPtrOutput

type ClusterCoreInstanceFleetInput added in v3.3.0 

type ClusterCoreInstanceFleetInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetOutput() ClusterCoreInstanceFleetOutput
	ToClusterCoreInstanceFleetOutputWithContext(context.Context) ClusterCoreInstanceFleetOutput
}

ClusterCoreInstanceFleetInput is an input type that accepts ClusterCoreInstanceFleetArgs and ClusterCoreInstanceFleetOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetInput` via: 

ClusterCoreInstanceFleetArgs{...}

type ClusterCoreInstanceFleetInstanceTypeConfig added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfig struct {
	// The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPrice *string `pulumi:"bidPrice"`
	// The bid price, as a percentage of On-Demand price, for each EC2 Spot instance as defined by `instanceType`. Expressed as a number (for example, 20 specifies 20%). If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPriceAsPercentageOfOnDemandPrice *float64 `pulumi:"bidPriceAsPercentageOfOnDemandPrice"`
	// A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.
	Configurations []ClusterCoreInstanceFleetInstanceTypeConfigConfiguration `pulumi:"configurations"`
	// Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.
	EbsConfigs []ClusterCoreInstanceFleetInstanceTypeConfigEbsConfig `pulumi:"ebsConfigs"`
	// An EC2 instance type, such as m4.xlarge.
	InstanceType string `pulumi:"instanceType"`
	// The number of units that a provisioned instance of this type provides toward fulfilling the target capacities defined in `emr.InstanceFleet`.
	WeightedCapacity *int `pulumi:"weightedCapacity"`
}

type ClusterCoreInstanceFleetInstanceTypeConfigArgs added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigArgs struct {
	// The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPrice pulumi.StringPtrInput `pulumi:"bidPrice"`
	// The bid price, as a percentage of On-Demand price, for each EC2 Spot instance as defined by `instanceType`. Expressed as a number (for example, 20 specifies 20%). If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPriceAsPercentageOfOnDemandPrice pulumi.Float64PtrInput `pulumi:"bidPriceAsPercentageOfOnDemandPrice"`
	// A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.
	Configurations ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayInput `pulumi:"configurations"`
	// Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.
	EbsConfigs ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayInput `pulumi:"ebsConfigs"`
	// An EC2 instance type, such as m4.xlarge.
	InstanceType pulumi.StringInput `pulumi:"instanceType"`
	// The number of units that a provisioned instance of this type provides toward fulfilling the target capacities defined in `emr.InstanceFleet`.
	WeightedCapacity pulumi.IntPtrInput `pulumi:"weightedCapacity"`
}

func (ClusterCoreInstanceFleetInstanceTypeConfigArgs) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigArgs) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigArgs) ToClusterCoreInstanceFleetInstanceTypeConfigOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigArgs) ToClusterCoreInstanceFleetInstanceTypeConfigOutput() ClusterCoreInstanceFleetInstanceTypeConfigOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigArgs) ToClusterCoreInstanceFleetInstanceTypeConfigOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigArgs) ToClusterCoreInstanceFleetInstanceTypeConfigOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigOutput

type ClusterCoreInstanceFleetInstanceTypeConfigArray added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigArray []ClusterCoreInstanceFleetInstanceTypeConfigInput

func (ClusterCoreInstanceFleetInstanceTypeConfigArray) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigArray) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigArray) ToClusterCoreInstanceFleetInstanceTypeConfigArrayOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigArray) ToClusterCoreInstanceFleetInstanceTypeConfigArrayOutput() ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigArray) ToClusterCoreInstanceFleetInstanceTypeConfigArrayOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigArray) ToClusterCoreInstanceFleetInstanceTypeConfigArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput

type ClusterCoreInstanceFleetInstanceTypeConfigArrayInput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigArrayInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetInstanceTypeConfigArrayOutput() ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput
	ToClusterCoreInstanceFleetInstanceTypeConfigArrayOutputWithContext(context.Context) ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput
}

ClusterCoreInstanceFleetInstanceTypeConfigArrayInput is an input type that accepts ClusterCoreInstanceFleetInstanceTypeConfigArray and ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetInstanceTypeConfigArrayInput` via: 

ClusterCoreInstanceFleetInstanceTypeConfigArray{ ClusterCoreInstanceFleetInstanceTypeConfigArgs{...} }

type ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput) Index added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput) Index(i pulumi.IntInput) ClusterCoreInstanceFleetInstanceTypeConfigOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigArrayOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigArrayOutput() ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigArrayOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput

type ClusterCoreInstanceFleetInstanceTypeConfigConfiguration added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigConfiguration struct {
	// The classification within a configuration.
	Classification *string `pulumi:"classification"`
	// A map of properties specified within a configuration classification
	Properties map[string]interface{} `pulumi:"properties"`
}

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArgs added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArgs struct {
	// The classification within a configuration.
	Classification pulumi.StringPtrInput `pulumi:"classification"`
	// A map of properties specified within a configuration classification
	Properties pulumi.MapInput `pulumi:"properties"`
}

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArgs) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArgs) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArgs) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArgs) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput() ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArgs) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArgs) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArray added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArray []ClusterCoreInstanceFleetInstanceTypeConfigConfigurationInput

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArray) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArray) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArray) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArray) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput() ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArray) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArray) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayInput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput() ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput
	ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext(context.Context) ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput
}

ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayInput is an input type that accepts ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArray and ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayInput` via: 

ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArray{ ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArgs{...} }

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput) Index added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput) Index(i pulumi.IntInput) ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput() ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationInput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput() ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput
	ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutputWithContext(context.Context) ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput
}

ClusterCoreInstanceFleetInstanceTypeConfigConfigurationInput is an input type that accepts ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArgs and ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetInstanceTypeConfigConfigurationInput` via: 

ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArgs{...}

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput) Classification added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput) Classification() pulumi.StringPtrOutput

The classification within a configuration.

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput) Properties added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput) Properties() pulumi.MapOutput

A map of properties specified within a configuration classification

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput() ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput) ToClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigConfigurationOutput

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfig added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfig struct {
	// The number of I/O operations per second (IOPS) that the volume supports
	Iops *int `pulumi:"iops"`
	// The volume size, in gibibytes (GiB).
	Size int `pulumi:"size"`
	// The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).
	Type string `pulumi:"type"`
	// The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)
	VolumesPerInstance *int `pulumi:"volumesPerInstance"`
}

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs struct {
	// The number of I/O operations per second (IOPS) that the volume supports
	Iops pulumi.IntPtrInput `pulumi:"iops"`
	// The volume size, in gibibytes (GiB).
	Size pulumi.IntInput `pulumi:"size"`
	// The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).
	Type pulumi.StringInput `pulumi:"type"`
	// The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)
	VolumesPerInstance pulumi.IntPtrInput `pulumi:"volumesPerInstance"`
}

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput() ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray []ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigInput

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput() ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayInput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput() ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput
	ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext(context.Context) ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput
}

ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayInput is an input type that accepts ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray and ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayInput` via: 

ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArray{ ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs{...} }

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) Index added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) Index(i pulumi.IntInput) ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput() ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigInput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput() ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput
	ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext(context.Context) ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput
}

ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigInput is an input type that accepts ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs and ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigInput` via: 

ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArgs{...}

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) Iops added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) Iops() pulumi.IntPtrOutput

The number of I/O operations per second (IOPS) that the volume supports

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) Size added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) Size() pulumi.IntOutput

The volume size, in gibibytes (GiB).

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput() ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) ToClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) Type added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) Type() pulumi.StringOutput

The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).

func (ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) VolumesPerInstance added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigOutput) VolumesPerInstance() pulumi.IntPtrOutput

The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)

type ClusterCoreInstanceFleetInstanceTypeConfigInput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetInstanceTypeConfigOutput() ClusterCoreInstanceFleetInstanceTypeConfigOutput
	ToClusterCoreInstanceFleetInstanceTypeConfigOutputWithContext(context.Context) ClusterCoreInstanceFleetInstanceTypeConfigOutput
}

ClusterCoreInstanceFleetInstanceTypeConfigInput is an input type that accepts ClusterCoreInstanceFleetInstanceTypeConfigArgs and ClusterCoreInstanceFleetInstanceTypeConfigOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetInstanceTypeConfigInput` via: 

ClusterCoreInstanceFleetInstanceTypeConfigArgs{...}

type ClusterCoreInstanceFleetInstanceTypeConfigOutput added in v3.3.0 

type ClusterCoreInstanceFleetInstanceTypeConfigOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetInstanceTypeConfigOutput) BidPrice added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigOutput) BidPrice() pulumi.StringPtrOutput

The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.

func (ClusterCoreInstanceFleetInstanceTypeConfigOutput) BidPriceAsPercentageOfOnDemandPrice added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigOutput) BidPriceAsPercentageOfOnDemandPrice() pulumi.Float64PtrOutput

The bid price, as a percentage of On-Demand price, for each EC2 Spot instance as defined by `instanceType`. Expressed as a number (for example, 20 specifies 20%). If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.

func (ClusterCoreInstanceFleetInstanceTypeConfigOutput) Configurations added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigOutput) Configurations() ClusterCoreInstanceFleetInstanceTypeConfigConfigurationArrayOutput

A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.

func (ClusterCoreInstanceFleetInstanceTypeConfigOutput) EbsConfigs added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigOutput) EbsConfigs() ClusterCoreInstanceFleetInstanceTypeConfigEbsConfigArrayOutput

Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.

func (ClusterCoreInstanceFleetInstanceTypeConfigOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetInstanceTypeConfigOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetInstanceTypeConfigOutput) InstanceType added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigOutput) InstanceType() pulumi.StringOutput

An EC2 instance type, such as m4.xlarge.

func (ClusterCoreInstanceFleetInstanceTypeConfigOutput) ToClusterCoreInstanceFleetInstanceTypeConfigOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigOutput) ToClusterCoreInstanceFleetInstanceTypeConfigOutput() ClusterCoreInstanceFleetInstanceTypeConfigOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigOutput) ToClusterCoreInstanceFleetInstanceTypeConfigOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigOutput) ToClusterCoreInstanceFleetInstanceTypeConfigOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetInstanceTypeConfigOutput

func (ClusterCoreInstanceFleetInstanceTypeConfigOutput) WeightedCapacity added in v3.3.0 

func (o ClusterCoreInstanceFleetInstanceTypeConfigOutput) WeightedCapacity() pulumi.IntPtrOutput

The number of units that a provisioned instance of this type provides toward fulfilling the target capacities defined in `emr.InstanceFleet`.

type ClusterCoreInstanceFleetLaunchSpecifications added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecifications struct {
	// Configuration block for on demand instances launch specifications
	OnDemandSpecifications []ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecification `pulumi:"onDemandSpecifications"`
	// Configuration block for spot instances launch specifications
	SpotSpecifications []ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecification `pulumi:"spotSpecifications"`
}

type ClusterCoreInstanceFleetLaunchSpecificationsArgs added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsArgs struct {
	// Configuration block for on demand instances launch specifications
	OnDemandSpecifications ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput `pulumi:"onDemandSpecifications"`
	// Configuration block for spot instances launch specifications
	SpotSpecifications ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayInput `pulumi:"spotSpecifications"`
}

func (ClusterCoreInstanceFleetLaunchSpecificationsArgs) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetLaunchSpecificationsArgs) ElementType() reflect.Type

func (ClusterCoreInstanceFleetLaunchSpecificationsArgs) ToClusterCoreInstanceFleetLaunchSpecificationsOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsArgs) ToClusterCoreInstanceFleetLaunchSpecificationsOutput() ClusterCoreInstanceFleetLaunchSpecificationsOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsArgs) ToClusterCoreInstanceFleetLaunchSpecificationsOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsArgs) ToClusterCoreInstanceFleetLaunchSpecificationsOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsArgs) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsArgs) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutput() ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsArgs) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsArgs) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput

type ClusterCoreInstanceFleetLaunchSpecificationsInput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetLaunchSpecificationsOutput() ClusterCoreInstanceFleetLaunchSpecificationsOutput
	ToClusterCoreInstanceFleetLaunchSpecificationsOutputWithContext(context.Context) ClusterCoreInstanceFleetLaunchSpecificationsOutput
}

ClusterCoreInstanceFleetLaunchSpecificationsInput is an input type that accepts ClusterCoreInstanceFleetLaunchSpecificationsArgs and ClusterCoreInstanceFleetLaunchSpecificationsOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetLaunchSpecificationsInput` via: 

ClusterCoreInstanceFleetLaunchSpecificationsArgs{...}

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecification added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecification struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy string `pulumi:"allocationStrategy"`
}

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy pulumi.StringInput `pulumi:"allocationStrategy"`
}

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ElementType() reflect.Type

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput() ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArray added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArray []ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationInput

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ElementType() reflect.Type

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput() ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput() ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput
	ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext(context.Context) ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput
}

ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput is an input type that accepts ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArray and ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput` via: 

ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArray{ ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs{...} }

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) Index added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) Index(i pulumi.IntInput) ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput() ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationInput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput() ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput
	ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext(context.Context) ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput
}

ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationInput is an input type that accepts ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs and ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationInput` via: 

ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs{...}

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) AllocationStrategy added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) AllocationStrategy() pulumi.StringOutput

Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput() ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

type ClusterCoreInstanceFleetLaunchSpecificationsOutput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetLaunchSpecificationsOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetLaunchSpecificationsOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetLaunchSpecificationsOutput) OnDemandSpecifications added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOutput) OnDemandSpecifications() ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

Configuration block for on demand instances launch specifications

func (ClusterCoreInstanceFleetLaunchSpecificationsOutput) SpotSpecifications added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOutput) SpotSpecifications() ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

Configuration block for spot instances launch specifications

func (ClusterCoreInstanceFleetLaunchSpecificationsOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOutput() ClusterCoreInstanceFleetLaunchSpecificationsOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOutput) ToClusterCoreInstanceFleetLaunchSpecificationsOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsOutput) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOutput) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutput() ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsOutput) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsOutput) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput

type ClusterCoreInstanceFleetLaunchSpecificationsPtrInput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsPtrInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutput() ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput
	ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutputWithContext(context.Context) ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput
}

ClusterCoreInstanceFleetLaunchSpecificationsPtrInput is an input type that accepts ClusterCoreInstanceFleetLaunchSpecificationsArgs, ClusterCoreInstanceFleetLaunchSpecificationsPtr and ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetLaunchSpecificationsPtrInput` via: 

        ClusterCoreInstanceFleetLaunchSpecificationsArgs{...}

or:

        nil

func ClusterCoreInstanceFleetLaunchSpecificationsPtr added in v3.3.0 

func ClusterCoreInstanceFleetLaunchSpecificationsPtr(v *ClusterCoreInstanceFleetLaunchSpecificationsArgs) ClusterCoreInstanceFleetLaunchSpecificationsPtrInput

type ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) Elem added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) Elem() ClusterCoreInstanceFleetLaunchSpecificationsOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) OnDemandSpecifications added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) OnDemandSpecifications() ClusterCoreInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

Configuration block for on demand instances launch specifications

func (ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) SpotSpecifications added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) SpotSpecifications() ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

Configuration block for spot instances launch specifications

func (ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutput() ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput) ToClusterCoreInstanceFleetLaunchSpecificationsPtrOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecification added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecification struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy string `pulumi:"allocationStrategy"`
	// The defined duration for Spot instances (also known as Spot blocks) in minutes. When specified, the Spot instance does not terminate before the defined duration expires, and defined duration pricing for Spot instances applies. Valid values are 60, 120, 180, 240, 300, or 360. The duration period starts as soon as a Spot instance receives its instance ID. At the end of the duration, Amazon EC2 marks the Spot instance for termination and provides a Spot instance termination notice, which gives the instance a two-minute warning before it terminates.
	BlockDurationMinutes *int `pulumi:"blockDurationMinutes"`
	// The action to take when TargetSpotCapacity has not been fulfilled when the TimeoutDurationMinutes has expired; that is, when all Spot instances could not be provisioned within the Spot provisioning timeout. Valid values are `TERMINATE_CLUSTER` and `SWITCH_TO_ON_DEMAND`. SWITCH_TO_ON_DEMAND specifies that if no Spot instances are available, On-Demand Instances should be provisioned to fulfill any remaining Spot capacity.
	TimeoutAction string `pulumi:"timeoutAction"`
	// The spot provisioning timeout period in minutes. If Spot instances are not provisioned within this time period, the TimeOutAction is taken. Minimum value is 5 and maximum value is 1440. The timeout applies only during initial provisioning, when the cluster is first created.
	TimeoutDurationMinutes int `pulumi:"timeoutDurationMinutes"`
}

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy pulumi.StringInput `pulumi:"allocationStrategy"`
	// The defined duration for Spot instances (also known as Spot blocks) in minutes. When specified, the Spot instance does not terminate before the defined duration expires, and defined duration pricing for Spot instances applies. Valid values are 60, 120, 180, 240, 300, or 360. The duration period starts as soon as a Spot instance receives its instance ID. At the end of the duration, Amazon EC2 marks the Spot instance for termination and provides a Spot instance termination notice, which gives the instance a two-minute warning before it terminates.
	BlockDurationMinutes pulumi.IntPtrInput `pulumi:"blockDurationMinutes"`
	// The action to take when TargetSpotCapacity has not been fulfilled when the TimeoutDurationMinutes has expired; that is, when all Spot instances could not be provisioned within the Spot provisioning timeout. Valid values are `TERMINATE_CLUSTER` and `SWITCH_TO_ON_DEMAND`. SWITCH_TO_ON_DEMAND specifies that if no Spot instances are available, On-Demand Instances should be provisioned to fulfill any remaining Spot capacity.
	TimeoutAction pulumi.StringInput `pulumi:"timeoutAction"`
	// The spot provisioning timeout period in minutes. If Spot instances are not provisioned within this time period, the TimeOutAction is taken. Minimum value is 5 and maximum value is 1440. The timeout applies only during initial provisioning, when the cluster is first created.
	TimeoutDurationMinutes pulumi.IntInput `pulumi:"timeoutDurationMinutes"`
}

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ElementType() reflect.Type

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput() ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArray added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArray []ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationInput

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArray) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArray) ElementType() reflect.Type

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArray) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArray) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput() ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArray) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext added in v3.3.0 

func (i ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArray) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayInput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput() ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput
	ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext(context.Context) ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput
}

ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayInput is an input type that accepts ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArray and ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayInput` via: 

ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArray{ ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs{...} }

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) Index added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) Index(i pulumi.IntInput) ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput() ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationInput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput() ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput
	ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext(context.Context) ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput
}

ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationInput is an input type that accepts ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs and ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationInput` via: 

ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationArgs{...}

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput added in v3.3.0 

type ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) AllocationStrategy added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) AllocationStrategy() pulumi.StringOutput

Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) BlockDurationMinutes added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) BlockDurationMinutes() pulumi.IntPtrOutput

The defined duration for Spot instances (also known as Spot blocks) in minutes. When specified, the Spot instance does not terminate before the defined duration expires, and defined duration pricing for Spot instances applies. Valid values are 60, 120, 180, 240, 300, or 360. The duration period starts as soon as a Spot instance receives its instance ID. At the end of the duration, Amazon EC2 marks the Spot instance for termination and provides a Spot instance termination notice, which gives the instance a two-minute warning before it terminates.

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutAction added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutAction() pulumi.StringOutput

The action to take when TargetSpotCapacity has not been fulfilled when the TimeoutDurationMinutes has expired; that is, when all Spot instances could not be provisioned within the Spot provisioning timeout. Valid values are `TERMINATE_CLUSTER` and `SWITCH_TO_ON_DEMAND`. SWITCH_TO_ON_DEMAND specifies that if no Spot instances are available, On-Demand Instances should be provisioned to fulfill any remaining Spot capacity.

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutDurationMinutes added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutDurationMinutes() pulumi.IntOutput

The spot provisioning timeout period in minutes. If Spot instances are not provisioned within this time period, the TimeOutAction is taken. Minimum value is 5 and maximum value is 1440. The timeout applies only during initial provisioning, when the cluster is first created.

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput() ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput

func (ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetLaunchSpecificationsSpotSpecificationOutput

type ClusterCoreInstanceFleetOutput added in v3.3.0 

type ClusterCoreInstanceFleetOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetOutput) Id added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) Id() pulumi.StringPtrOutput

The ID of the EMR Cluster

func (ClusterCoreInstanceFleetOutput) InstanceTypeConfigs added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) InstanceTypeConfigs() ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput

Configuration block for instance fleet

func (ClusterCoreInstanceFleetOutput) LaunchSpecifications added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) LaunchSpecifications() ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput

Configuration block for launch specification

func (ClusterCoreInstanceFleetOutput) Name added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) Name() pulumi.StringPtrOutput

Friendly name given to the instance fleet.

func (ClusterCoreInstanceFleetOutput) ProvisionedOnDemandCapacity added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) ProvisionedOnDemandCapacity() pulumi.IntPtrOutput

func (ClusterCoreInstanceFleetOutput) ProvisionedSpotCapacity added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) ProvisionedSpotCapacity() pulumi.IntPtrOutput

func (ClusterCoreInstanceFleetOutput) TargetOnDemandCapacity added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) TargetOnDemandCapacity() pulumi.IntPtrOutput

The target capacity of On-Demand units for the instance fleet, which determines how many On-Demand instances to provision.

func (ClusterCoreInstanceFleetOutput) TargetSpotCapacity added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) TargetSpotCapacity() pulumi.IntPtrOutput

The target capacity of Spot units for the instance fleet, which determines how many Spot instances to provision.

func (ClusterCoreInstanceFleetOutput) ToClusterCoreInstanceFleetOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) ToClusterCoreInstanceFleetOutput() ClusterCoreInstanceFleetOutput

func (ClusterCoreInstanceFleetOutput) ToClusterCoreInstanceFleetOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) ToClusterCoreInstanceFleetOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetOutput

func (ClusterCoreInstanceFleetOutput) ToClusterCoreInstanceFleetPtrOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) ToClusterCoreInstanceFleetPtrOutput() ClusterCoreInstanceFleetPtrOutput

func (ClusterCoreInstanceFleetOutput) ToClusterCoreInstanceFleetPtrOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetOutput) ToClusterCoreInstanceFleetPtrOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetPtrOutput

type ClusterCoreInstanceFleetPtrInput added in v3.3.0 

type ClusterCoreInstanceFleetPtrInput interface {
	pulumi.Input

	ToClusterCoreInstanceFleetPtrOutput() ClusterCoreInstanceFleetPtrOutput
	ToClusterCoreInstanceFleetPtrOutputWithContext(context.Context) ClusterCoreInstanceFleetPtrOutput
}

ClusterCoreInstanceFleetPtrInput is an input type that accepts ClusterCoreInstanceFleetArgs, ClusterCoreInstanceFleetPtr and ClusterCoreInstanceFleetPtrOutput values. You can construct a concrete instance of `ClusterCoreInstanceFleetPtrInput` via: 

        ClusterCoreInstanceFleetArgs{...}

or:

        nil

func ClusterCoreInstanceFleetPtr added in v3.3.0 

func ClusterCoreInstanceFleetPtr(v *ClusterCoreInstanceFleetArgs) ClusterCoreInstanceFleetPtrInput

type ClusterCoreInstanceFleetPtrOutput added in v3.3.0 

type ClusterCoreInstanceFleetPtrOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceFleetPtrOutput) Elem added in v3.3.0 

func (o ClusterCoreInstanceFleetPtrOutput) Elem() ClusterCoreInstanceFleetOutput

func (ClusterCoreInstanceFleetPtrOutput) ElementType added in v3.3.0 

func (ClusterCoreInstanceFleetPtrOutput) ElementType() reflect.Type

func (ClusterCoreInstanceFleetPtrOutput) Id added in v3.3.0 

func (o ClusterCoreInstanceFleetPtrOutput) Id() pulumi.StringPtrOutput

The ID of the EMR Cluster

func (ClusterCoreInstanceFleetPtrOutput) InstanceTypeConfigs added in v3.3.0 

func (o ClusterCoreInstanceFleetPtrOutput) InstanceTypeConfigs() ClusterCoreInstanceFleetInstanceTypeConfigArrayOutput

Configuration block for instance fleet

func (ClusterCoreInstanceFleetPtrOutput) LaunchSpecifications added in v3.3.0 

func (o ClusterCoreInstanceFleetPtrOutput) LaunchSpecifications() ClusterCoreInstanceFleetLaunchSpecificationsPtrOutput

Configuration block for launch specification

func (ClusterCoreInstanceFleetPtrOutput) Name added in v3.3.0 

func (o ClusterCoreInstanceFleetPtrOutput) Name() pulumi.StringPtrOutput

Friendly name given to the instance fleet.

func (ClusterCoreInstanceFleetPtrOutput) ProvisionedOnDemandCapacity added in v3.3.0 

func (o ClusterCoreInstanceFleetPtrOutput) ProvisionedOnDemandCapacity() pulumi.IntPtrOutput

func (ClusterCoreInstanceFleetPtrOutput) ProvisionedSpotCapacity added in v3.3.0 

func (o ClusterCoreInstanceFleetPtrOutput) ProvisionedSpotCapacity() pulumi.IntPtrOutput

func (ClusterCoreInstanceFleetPtrOutput) TargetOnDemandCapacity added in v3.3.0 

func (o ClusterCoreInstanceFleetPtrOutput) TargetOnDemandCapacity() pulumi.IntPtrOutput

The target capacity of On-Demand units for the instance fleet, which determines how many On-Demand instances to provision.

func (ClusterCoreInstanceFleetPtrOutput) TargetSpotCapacity added in v3.3.0 

func (o ClusterCoreInstanceFleetPtrOutput) TargetSpotCapacity() pulumi.IntPtrOutput

The target capacity of Spot units for the instance fleet, which determines how many Spot instances to provision.

func (ClusterCoreInstanceFleetPtrOutput) ToClusterCoreInstanceFleetPtrOutput added in v3.3.0 

func (o ClusterCoreInstanceFleetPtrOutput) ToClusterCoreInstanceFleetPtrOutput() ClusterCoreInstanceFleetPtrOutput

func (ClusterCoreInstanceFleetPtrOutput) ToClusterCoreInstanceFleetPtrOutputWithContext added in v3.3.0 

func (o ClusterCoreInstanceFleetPtrOutput) ToClusterCoreInstanceFleetPtrOutputWithContext(ctx context.Context) ClusterCoreInstanceFleetPtrOutput

type ClusterCoreInstanceGroup 

type ClusterCoreInstanceGroup struct {
	// String containing the [EMR Auto Scaling Policy](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-automatic-scaling.html) JSON.
	AutoscalingPolicy *string `pulumi:"autoscalingPolicy"`
	// The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPrice *string `pulumi:"bidPrice"`
	// Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.
	EbsConfigs []ClusterCoreInstanceGroupEbsConfig `pulumi:"ebsConfigs"`
	// The ID of the EMR Cluster
	Id *string `pulumi:"id"`
	// Target number of instances for the instance group. Must be 1 or 3. Defaults to 1. Launching with multiple master nodes is only supported in EMR version 5.23.0+, and requires this resource's `coreInstanceGroup` to be configured. Public (Internet accessible) instances must be created in VPC subnets that have `map public IP on launch` enabled. Termination protection is automatically enabled when launched with multiple master nodes and this provider must have the `terminationProtection = false` configuration applied before destroying this resource.
	InstanceCount *int `pulumi:"instanceCount"`
	// An EC2 instance type, such as m4.xlarge.
	InstanceType string `pulumi:"instanceType"`
	// Friendly name given to the instance fleet.
	Name *string `pulumi:"name"`
}

type ClusterCoreInstanceGroupArgs 

type ClusterCoreInstanceGroupArgs struct {
	// String containing the [EMR Auto Scaling Policy](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-automatic-scaling.html) JSON.
	AutoscalingPolicy pulumi.StringPtrInput `pulumi:"autoscalingPolicy"`
	// The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPrice pulumi.StringPtrInput `pulumi:"bidPrice"`
	// Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.
	EbsConfigs ClusterCoreInstanceGroupEbsConfigArrayInput `pulumi:"ebsConfigs"`
	// The ID of the EMR Cluster
	Id pulumi.StringPtrInput `pulumi:"id"`
	// Target number of instances for the instance group. Must be 1 or 3. Defaults to 1. Launching with multiple master nodes is only supported in EMR version 5.23.0+, and requires this resource's `coreInstanceGroup` to be configured. Public (Internet accessible) instances must be created in VPC subnets that have `map public IP on launch` enabled. Termination protection is automatically enabled when launched with multiple master nodes and this provider must have the `terminationProtection = false` configuration applied before destroying this resource.
	InstanceCount pulumi.IntPtrInput `pulumi:"instanceCount"`
	// An EC2 instance type, such as m4.xlarge.
	InstanceType pulumi.StringInput `pulumi:"instanceType"`
	// Friendly name given to the instance fleet.
	Name pulumi.StringPtrInput `pulumi:"name"`
}

func (ClusterCoreInstanceGroupArgs) ElementType 

func (ClusterCoreInstanceGroupArgs) ElementType() reflect.Type

func (ClusterCoreInstanceGroupArgs) ToClusterCoreInstanceGroupOutput 

func (i ClusterCoreInstanceGroupArgs) ToClusterCoreInstanceGroupOutput() ClusterCoreInstanceGroupOutput

func (ClusterCoreInstanceGroupArgs) ToClusterCoreInstanceGroupOutputWithContext 

func (i ClusterCoreInstanceGroupArgs) ToClusterCoreInstanceGroupOutputWithContext(ctx context.Context) ClusterCoreInstanceGroupOutput

func (ClusterCoreInstanceGroupArgs) ToClusterCoreInstanceGroupPtrOutput 

func (i ClusterCoreInstanceGroupArgs) ToClusterCoreInstanceGroupPtrOutput() ClusterCoreInstanceGroupPtrOutput

func (ClusterCoreInstanceGroupArgs) ToClusterCoreInstanceGroupPtrOutputWithContext 

func (i ClusterCoreInstanceGroupArgs) ToClusterCoreInstanceGroupPtrOutputWithContext(ctx context.Context) ClusterCoreInstanceGroupPtrOutput

type ClusterCoreInstanceGroupEbsConfig 

type ClusterCoreInstanceGroupEbsConfig struct {
	// The number of I/O operations per second (IOPS) that the volume supports
	Iops *int `pulumi:"iops"`
	// The volume size, in gibibytes (GiB).
	Size int `pulumi:"size"`
	// The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).
	Type string `pulumi:"type"`
	// The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)
	VolumesPerInstance *int `pulumi:"volumesPerInstance"`
}

type ClusterCoreInstanceGroupEbsConfigArgs 

type ClusterCoreInstanceGroupEbsConfigArgs struct {
	// The number of I/O operations per second (IOPS) that the volume supports
	Iops pulumi.IntPtrInput `pulumi:"iops"`
	// The volume size, in gibibytes (GiB).
	Size pulumi.IntInput `pulumi:"size"`
	// The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).
	Type pulumi.StringInput `pulumi:"type"`
	// The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)
	VolumesPerInstance pulumi.IntPtrInput `pulumi:"volumesPerInstance"`
}

func (ClusterCoreInstanceGroupEbsConfigArgs) ElementType 

func (ClusterCoreInstanceGroupEbsConfigArgs) ElementType() reflect.Type

func (ClusterCoreInstanceGroupEbsConfigArgs) ToClusterCoreInstanceGroupEbsConfigOutput 

func (i ClusterCoreInstanceGroupEbsConfigArgs) ToClusterCoreInstanceGroupEbsConfigOutput() ClusterCoreInstanceGroupEbsConfigOutput

func (ClusterCoreInstanceGroupEbsConfigArgs) ToClusterCoreInstanceGroupEbsConfigOutputWithContext 

func (i ClusterCoreInstanceGroupEbsConfigArgs) ToClusterCoreInstanceGroupEbsConfigOutputWithContext(ctx context.Context) ClusterCoreInstanceGroupEbsConfigOutput

type ClusterCoreInstanceGroupEbsConfigArray 

type ClusterCoreInstanceGroupEbsConfigArray []ClusterCoreInstanceGroupEbsConfigInput

func (ClusterCoreInstanceGroupEbsConfigArray) ElementType 

func (ClusterCoreInstanceGroupEbsConfigArray) ElementType() reflect.Type

func (ClusterCoreInstanceGroupEbsConfigArray) ToClusterCoreInstanceGroupEbsConfigArrayOutput 

func (i ClusterCoreInstanceGroupEbsConfigArray) ToClusterCoreInstanceGroupEbsConfigArrayOutput() ClusterCoreInstanceGroupEbsConfigArrayOutput

func (ClusterCoreInstanceGroupEbsConfigArray) ToClusterCoreInstanceGroupEbsConfigArrayOutputWithContext 

func (i ClusterCoreInstanceGroupEbsConfigArray) ToClusterCoreInstanceGroupEbsConfigArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceGroupEbsConfigArrayOutput

type ClusterCoreInstanceGroupEbsConfigArrayInput 

type ClusterCoreInstanceGroupEbsConfigArrayInput interface {
	pulumi.Input

	ToClusterCoreInstanceGroupEbsConfigArrayOutput() ClusterCoreInstanceGroupEbsConfigArrayOutput
	ToClusterCoreInstanceGroupEbsConfigArrayOutputWithContext(context.Context) ClusterCoreInstanceGroupEbsConfigArrayOutput
}

ClusterCoreInstanceGroupEbsConfigArrayInput is an input type that accepts ClusterCoreInstanceGroupEbsConfigArray and ClusterCoreInstanceGroupEbsConfigArrayOutput values. You can construct a concrete instance of `ClusterCoreInstanceGroupEbsConfigArrayInput` via: 

ClusterCoreInstanceGroupEbsConfigArray{ ClusterCoreInstanceGroupEbsConfigArgs{...} }

type ClusterCoreInstanceGroupEbsConfigArrayOutput 

type ClusterCoreInstanceGroupEbsConfigArrayOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceGroupEbsConfigArrayOutput) ElementType 

func (ClusterCoreInstanceGroupEbsConfigArrayOutput) ElementType() reflect.Type

func (ClusterCoreInstanceGroupEbsConfigArrayOutput) Index 

func (o ClusterCoreInstanceGroupEbsConfigArrayOutput) Index(i pulumi.IntInput) ClusterCoreInstanceGroupEbsConfigOutput

func (ClusterCoreInstanceGroupEbsConfigArrayOutput) ToClusterCoreInstanceGroupEbsConfigArrayOutput 

func (o ClusterCoreInstanceGroupEbsConfigArrayOutput) ToClusterCoreInstanceGroupEbsConfigArrayOutput() ClusterCoreInstanceGroupEbsConfigArrayOutput

func (ClusterCoreInstanceGroupEbsConfigArrayOutput) ToClusterCoreInstanceGroupEbsConfigArrayOutputWithContext 

func (o ClusterCoreInstanceGroupEbsConfigArrayOutput) ToClusterCoreInstanceGroupEbsConfigArrayOutputWithContext(ctx context.Context) ClusterCoreInstanceGroupEbsConfigArrayOutput

type ClusterCoreInstanceGroupEbsConfigInput 

type ClusterCoreInstanceGroupEbsConfigInput interface {
	pulumi.Input

	ToClusterCoreInstanceGroupEbsConfigOutput() ClusterCoreInstanceGroupEbsConfigOutput
	ToClusterCoreInstanceGroupEbsConfigOutputWithContext(context.Context) ClusterCoreInstanceGroupEbsConfigOutput
}

ClusterCoreInstanceGroupEbsConfigInput is an input type that accepts ClusterCoreInstanceGroupEbsConfigArgs and ClusterCoreInstanceGroupEbsConfigOutput values. You can construct a concrete instance of `ClusterCoreInstanceGroupEbsConfigInput` via: 

ClusterCoreInstanceGroupEbsConfigArgs{...}

type ClusterCoreInstanceGroupEbsConfigOutput 

type ClusterCoreInstanceGroupEbsConfigOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceGroupEbsConfigOutput) ElementType 

func (ClusterCoreInstanceGroupEbsConfigOutput) ElementType() reflect.Type

func (ClusterCoreInstanceGroupEbsConfigOutput) Iops 

func (o ClusterCoreInstanceGroupEbsConfigOutput) Iops() pulumi.IntPtrOutput

The number of I/O operations per second (IOPS) that the volume supports

func (ClusterCoreInstanceGroupEbsConfigOutput) Size 

func (o ClusterCoreInstanceGroupEbsConfigOutput) Size() pulumi.IntOutput

The volume size, in gibibytes (GiB).

func (ClusterCoreInstanceGroupEbsConfigOutput) ToClusterCoreInstanceGroupEbsConfigOutput 

func (o ClusterCoreInstanceGroupEbsConfigOutput) ToClusterCoreInstanceGroupEbsConfigOutput() ClusterCoreInstanceGroupEbsConfigOutput

func (ClusterCoreInstanceGroupEbsConfigOutput) ToClusterCoreInstanceGroupEbsConfigOutputWithContext 

func (o ClusterCoreInstanceGroupEbsConfigOutput) ToClusterCoreInstanceGroupEbsConfigOutputWithContext(ctx context.Context) ClusterCoreInstanceGroupEbsConfigOutput

func (ClusterCoreInstanceGroupEbsConfigOutput) Type 

func (o ClusterCoreInstanceGroupEbsConfigOutput) Type() pulumi.StringOutput

The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).

func (ClusterCoreInstanceGroupEbsConfigOutput) VolumesPerInstance 

func (o ClusterCoreInstanceGroupEbsConfigOutput) VolumesPerInstance() pulumi.IntPtrOutput

The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)

type ClusterCoreInstanceGroupInput 

type ClusterCoreInstanceGroupInput interface {
	pulumi.Input

	ToClusterCoreInstanceGroupOutput() ClusterCoreInstanceGroupOutput
	ToClusterCoreInstanceGroupOutputWithContext(context.Context) ClusterCoreInstanceGroupOutput
}

ClusterCoreInstanceGroupInput is an input type that accepts ClusterCoreInstanceGroupArgs and ClusterCoreInstanceGroupOutput values. You can construct a concrete instance of `ClusterCoreInstanceGroupInput` via: 

ClusterCoreInstanceGroupArgs{...}

type ClusterCoreInstanceGroupOutput 

type ClusterCoreInstanceGroupOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceGroupOutput) AutoscalingPolicy 

func (o ClusterCoreInstanceGroupOutput) AutoscalingPolicy() pulumi.StringPtrOutput

String containing the [EMR Auto Scaling Policy](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-automatic-scaling.html) JSON.

func (ClusterCoreInstanceGroupOutput) BidPrice 

func (o ClusterCoreInstanceGroupOutput) BidPrice() pulumi.StringPtrOutput

The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.

func (ClusterCoreInstanceGroupOutput) EbsConfigs 

func (o ClusterCoreInstanceGroupOutput) EbsConfigs() ClusterCoreInstanceGroupEbsConfigArrayOutput

Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.

func (ClusterCoreInstanceGroupOutput) ElementType 

func (ClusterCoreInstanceGroupOutput) ElementType() reflect.Type

func (ClusterCoreInstanceGroupOutput) Id 

func (o ClusterCoreInstanceGroupOutput) Id() pulumi.StringPtrOutput

The ID of the EMR Cluster

func (ClusterCoreInstanceGroupOutput) InstanceCount 

func (o ClusterCoreInstanceGroupOutput) InstanceCount() pulumi.IntPtrOutput

Target number of instances for the instance group. Must be 1 or 3. Defaults to 1. Launching with multiple master nodes is only supported in EMR version 5.23.0+, and requires this resource's `coreInstanceGroup` to be configured. Public (Internet accessible) instances must be created in VPC subnets that have `map public IP on launch` enabled. Termination protection is automatically enabled when launched with multiple master nodes and this provider must have the `terminationProtection = false` configuration applied before destroying this resource.

func (ClusterCoreInstanceGroupOutput) InstanceType 

func (o ClusterCoreInstanceGroupOutput) InstanceType() pulumi.StringOutput

An EC2 instance type, such as m4.xlarge.

func (ClusterCoreInstanceGroupOutput) Name 

func (o ClusterCoreInstanceGroupOutput) Name() pulumi.StringPtrOutput

Friendly name given to the instance fleet.

func (ClusterCoreInstanceGroupOutput) ToClusterCoreInstanceGroupOutput 

func (o ClusterCoreInstanceGroupOutput) ToClusterCoreInstanceGroupOutput() ClusterCoreInstanceGroupOutput

func (ClusterCoreInstanceGroupOutput) ToClusterCoreInstanceGroupOutputWithContext 

func (o ClusterCoreInstanceGroupOutput) ToClusterCoreInstanceGroupOutputWithContext(ctx context.Context) ClusterCoreInstanceGroupOutput

func (ClusterCoreInstanceGroupOutput) ToClusterCoreInstanceGroupPtrOutput 

func (o ClusterCoreInstanceGroupOutput) ToClusterCoreInstanceGroupPtrOutput() ClusterCoreInstanceGroupPtrOutput

func (ClusterCoreInstanceGroupOutput) ToClusterCoreInstanceGroupPtrOutputWithContext 

func (o ClusterCoreInstanceGroupOutput) ToClusterCoreInstanceGroupPtrOutputWithContext(ctx context.Context) ClusterCoreInstanceGroupPtrOutput

type ClusterCoreInstanceGroupPtrInput 

type ClusterCoreInstanceGroupPtrInput interface {
	pulumi.Input

	ToClusterCoreInstanceGroupPtrOutput() ClusterCoreInstanceGroupPtrOutput
	ToClusterCoreInstanceGroupPtrOutputWithContext(context.Context) ClusterCoreInstanceGroupPtrOutput
}

ClusterCoreInstanceGroupPtrInput is an input type that accepts ClusterCoreInstanceGroupArgs, ClusterCoreInstanceGroupPtr and ClusterCoreInstanceGroupPtrOutput values. You can construct a concrete instance of `ClusterCoreInstanceGroupPtrInput` via: 

        ClusterCoreInstanceGroupArgs{...}

or:

        nil

func ClusterCoreInstanceGroupPtr 

func ClusterCoreInstanceGroupPtr(v *ClusterCoreInstanceGroupArgs) ClusterCoreInstanceGroupPtrInput

type ClusterCoreInstanceGroupPtrOutput 

type ClusterCoreInstanceGroupPtrOutput struct{ *pulumi.OutputState }

func (ClusterCoreInstanceGroupPtrOutput) AutoscalingPolicy 

func (o ClusterCoreInstanceGroupPtrOutput) AutoscalingPolicy() pulumi.StringPtrOutput

String containing the [EMR Auto Scaling Policy](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-automatic-scaling.html) JSON.

func (ClusterCoreInstanceGroupPtrOutput) BidPrice 

func (o ClusterCoreInstanceGroupPtrOutput) BidPrice() pulumi.StringPtrOutput

The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.

func (ClusterCoreInstanceGroupPtrOutput) EbsConfigs 

func (o ClusterCoreInstanceGroupPtrOutput) EbsConfigs() ClusterCoreInstanceGroupEbsConfigArrayOutput

Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.

func (ClusterCoreInstanceGroupPtrOutput) Elem 

func (o ClusterCoreInstanceGroupPtrOutput) Elem() ClusterCoreInstanceGroupOutput

func (ClusterCoreInstanceGroupPtrOutput) ElementType 

func (ClusterCoreInstanceGroupPtrOutput) ElementType() reflect.Type

func (ClusterCoreInstanceGroupPtrOutput) Id 

func (o ClusterCoreInstanceGroupPtrOutput) Id() pulumi.StringPtrOutput

The ID of the EMR Cluster

func (ClusterCoreInstanceGroupPtrOutput) InstanceCount 

func (o ClusterCoreInstanceGroupPtrOutput) InstanceCount() pulumi.IntPtrOutput

Target number of instances for the instance group. Must be 1 or 3. Defaults to 1. Launching with multiple master nodes is only supported in EMR version 5.23.0+, and requires this resource's `coreInstanceGroup` to be configured. Public (Internet accessible) instances must be created in VPC subnets that have `map public IP on launch` enabled. Termination protection is automatically enabled when launched with multiple master nodes and this provider must have the `terminationProtection = false` configuration applied before destroying this resource.

func (ClusterCoreInstanceGroupPtrOutput) InstanceType 

func (o ClusterCoreInstanceGroupPtrOutput) InstanceType() pulumi.StringPtrOutput

An EC2 instance type, such as m4.xlarge.

func (ClusterCoreInstanceGroupPtrOutput) Name 

func (o ClusterCoreInstanceGroupPtrOutput) Name() pulumi.StringPtrOutput

Friendly name given to the instance fleet.

func (ClusterCoreInstanceGroupPtrOutput) ToClusterCoreInstanceGroupPtrOutput 

func (o ClusterCoreInstanceGroupPtrOutput) ToClusterCoreInstanceGroupPtrOutput() ClusterCoreInstanceGroupPtrOutput

func (ClusterCoreInstanceGroupPtrOutput) ToClusterCoreInstanceGroupPtrOutputWithContext 

func (o ClusterCoreInstanceGroupPtrOutput) ToClusterCoreInstanceGroupPtrOutputWithContext(ctx context.Context) ClusterCoreInstanceGroupPtrOutput

type ClusterEc2Attributes 

type ClusterEc2Attributes struct {
	// String containing a comma separated list of additional Amazon EC2 security group IDs for the master node
	AdditionalMasterSecurityGroups *string `pulumi:"additionalMasterSecurityGroups"`
	// String containing a comma separated list of additional Amazon EC2 security group IDs for the slave nodes as a comma separated string
	AdditionalSlaveSecurityGroups *string `pulumi:"additionalSlaveSecurityGroups"`
	// Identifier of the Amazon EC2 EMR-Managed security group for the master node
	EmrManagedMasterSecurityGroup *string `pulumi:"emrManagedMasterSecurityGroup"`
	// Identifier of the Amazon EC2 EMR-Managed security group for the slave nodes
	EmrManagedSlaveSecurityGroup *string `pulumi:"emrManagedSlaveSecurityGroup"`
	// Instance Profile for EC2 instances of the cluster assume this role
	InstanceProfile string `pulumi:"instanceProfile"`
	// Amazon EC2 key pair that can be used to ssh to the master node as the user called `hadoop`
	KeyName *string `pulumi:"keyName"`
	// Identifier of the Amazon EC2 service-access security group - required when the cluster runs on a private subnet
	ServiceAccessSecurityGroup *string `pulumi:"serviceAccessSecurityGroup"`
	// VPC subnet id where you want the job flow to launch. Cannot specify the `cc1.4xlarge` instance type for nodes of a job flow launched in a Amazon VPC
	SubnetId *string `pulumi:"subnetId"`
}

type ClusterEc2AttributesArgs 

type ClusterEc2AttributesArgs struct {
	// String containing a comma separated list of additional Amazon EC2 security group IDs for the master node
	AdditionalMasterSecurityGroups pulumi.StringPtrInput `pulumi:"additionalMasterSecurityGroups"`
	// String containing a comma separated list of additional Amazon EC2 security group IDs for the slave nodes as a comma separated string
	AdditionalSlaveSecurityGroups pulumi.StringPtrInput `pulumi:"additionalSlaveSecurityGroups"`
	// Identifier of the Amazon EC2 EMR-Managed security group for the master node
	EmrManagedMasterSecurityGroup pulumi.StringPtrInput `pulumi:"emrManagedMasterSecurityGroup"`
	// Identifier of the Amazon EC2 EMR-Managed security group for the slave nodes
	EmrManagedSlaveSecurityGroup pulumi.StringPtrInput `pulumi:"emrManagedSlaveSecurityGroup"`
	// Instance Profile for EC2 instances of the cluster assume this role
	InstanceProfile pulumi.StringInput `pulumi:"instanceProfile"`
	// Amazon EC2 key pair that can be used to ssh to the master node as the user called `hadoop`
	KeyName pulumi.StringPtrInput `pulumi:"keyName"`
	// Identifier of the Amazon EC2 service-access security group - required when the cluster runs on a private subnet
	ServiceAccessSecurityGroup pulumi.StringPtrInput `pulumi:"serviceAccessSecurityGroup"`
	// VPC subnet id where you want the job flow to launch. Cannot specify the `cc1.4xlarge` instance type for nodes of a job flow launched in a Amazon VPC
	SubnetId pulumi.StringPtrInput `pulumi:"subnetId"`
}

func (ClusterEc2AttributesArgs) ElementType 

func (ClusterEc2AttributesArgs) ElementType() reflect.Type

func (ClusterEc2AttributesArgs) ToClusterEc2AttributesOutput 

func (i ClusterEc2AttributesArgs) ToClusterEc2AttributesOutput() ClusterEc2AttributesOutput

func (ClusterEc2AttributesArgs) ToClusterEc2AttributesOutputWithContext 

func (i ClusterEc2AttributesArgs) ToClusterEc2AttributesOutputWithContext(ctx context.Context) ClusterEc2AttributesOutput

func (ClusterEc2AttributesArgs) ToClusterEc2AttributesPtrOutput 

func (i ClusterEc2AttributesArgs) ToClusterEc2AttributesPtrOutput() ClusterEc2AttributesPtrOutput

func (ClusterEc2AttributesArgs) ToClusterEc2AttributesPtrOutputWithContext 

func (i ClusterEc2AttributesArgs) ToClusterEc2AttributesPtrOutputWithContext(ctx context.Context) ClusterEc2AttributesPtrOutput

type ClusterEc2AttributesInput 

type ClusterEc2AttributesInput interface {
	pulumi.Input

	ToClusterEc2AttributesOutput() ClusterEc2AttributesOutput
	ToClusterEc2AttributesOutputWithContext(context.Context) ClusterEc2AttributesOutput
}

ClusterEc2AttributesInput is an input type that accepts ClusterEc2AttributesArgs and ClusterEc2AttributesOutput values. You can construct a concrete instance of `ClusterEc2AttributesInput` via: 

ClusterEc2AttributesArgs{...}

type ClusterEc2AttributesOutput 

type ClusterEc2AttributesOutput struct{ *pulumi.OutputState }

func (ClusterEc2AttributesOutput) AdditionalMasterSecurityGroups 

func (o ClusterEc2AttributesOutput) AdditionalMasterSecurityGroups() pulumi.StringPtrOutput

String containing a comma separated list of additional Amazon EC2 security group IDs for the master node

func (ClusterEc2AttributesOutput) AdditionalSlaveSecurityGroups 

func (o ClusterEc2AttributesOutput) AdditionalSlaveSecurityGroups() pulumi.StringPtrOutput

String containing a comma separated list of additional Amazon EC2 security group IDs for the slave nodes as a comma separated string

func (ClusterEc2AttributesOutput) ElementType 

func (ClusterEc2AttributesOutput) ElementType() reflect.Type

func (ClusterEc2AttributesOutput) EmrManagedMasterSecurityGroup 

func (o ClusterEc2AttributesOutput) EmrManagedMasterSecurityGroup() pulumi.StringPtrOutput

Identifier of the Amazon EC2 EMR-Managed security group for the master node

func (ClusterEc2AttributesOutput) EmrManagedSlaveSecurityGroup 

func (o ClusterEc2AttributesOutput) EmrManagedSlaveSecurityGroup() pulumi.StringPtrOutput

Identifier of the Amazon EC2 EMR-Managed security group for the slave nodes

func (ClusterEc2AttributesOutput) InstanceProfile 

func (o ClusterEc2AttributesOutput) InstanceProfile() pulumi.StringOutput

Instance Profile for EC2 instances of the cluster assume this role

func (ClusterEc2AttributesOutput) KeyName 

func (o ClusterEc2AttributesOutput) KeyName() pulumi.StringPtrOutput

Amazon EC2 key pair that can be used to ssh to the master node as the user called `hadoop`

func (ClusterEc2AttributesOutput) ServiceAccessSecurityGroup 

func (o ClusterEc2AttributesOutput) ServiceAccessSecurityGroup() pulumi.StringPtrOutput

Identifier of the Amazon EC2 service-access security group - required when the cluster runs on a private subnet

func (ClusterEc2AttributesOutput) SubnetId 

func (o ClusterEc2AttributesOutput) SubnetId() pulumi.StringPtrOutput

VPC subnet id where you want the job flow to launch. Cannot specify the `cc1.4xlarge` instance type for nodes of a job flow launched in a Amazon VPC

func (ClusterEc2AttributesOutput) ToClusterEc2AttributesOutput 

func (o ClusterEc2AttributesOutput) ToClusterEc2AttributesOutput() ClusterEc2AttributesOutput

func (ClusterEc2AttributesOutput) ToClusterEc2AttributesOutputWithContext 

func (o ClusterEc2AttributesOutput) ToClusterEc2AttributesOutputWithContext(ctx context.Context) ClusterEc2AttributesOutput

func (ClusterEc2AttributesOutput) ToClusterEc2AttributesPtrOutput 

func (o ClusterEc2AttributesOutput) ToClusterEc2AttributesPtrOutput() ClusterEc2AttributesPtrOutput

func (ClusterEc2AttributesOutput) ToClusterEc2AttributesPtrOutputWithContext 

func (o ClusterEc2AttributesOutput) ToClusterEc2AttributesPtrOutputWithContext(ctx context.Context) ClusterEc2AttributesPtrOutput

type ClusterEc2AttributesPtrInput 

type ClusterEc2AttributesPtrInput interface {
	pulumi.Input

	ToClusterEc2AttributesPtrOutput() ClusterEc2AttributesPtrOutput
	ToClusterEc2AttributesPtrOutputWithContext(context.Context) ClusterEc2AttributesPtrOutput
}

ClusterEc2AttributesPtrInput is an input type that accepts ClusterEc2AttributesArgs, ClusterEc2AttributesPtr and ClusterEc2AttributesPtrOutput values. You can construct a concrete instance of `ClusterEc2AttributesPtrInput` via: 

        ClusterEc2AttributesArgs{...}

or:

        nil

func ClusterEc2AttributesPtr 

func ClusterEc2AttributesPtr(v *ClusterEc2AttributesArgs) ClusterEc2AttributesPtrInput

type ClusterEc2AttributesPtrOutput 

type ClusterEc2AttributesPtrOutput struct{ *pulumi.OutputState }

func (ClusterEc2AttributesPtrOutput) AdditionalMasterSecurityGroups 

func (o ClusterEc2AttributesPtrOutput) AdditionalMasterSecurityGroups() pulumi.StringPtrOutput

String containing a comma separated list of additional Amazon EC2 security group IDs for the master node

func (ClusterEc2AttributesPtrOutput) AdditionalSlaveSecurityGroups 

func (o ClusterEc2AttributesPtrOutput) AdditionalSlaveSecurityGroups() pulumi.StringPtrOutput

String containing a comma separated list of additional Amazon EC2 security group IDs for the slave nodes as a comma separated string

func (ClusterEc2AttributesPtrOutput) Elem 

func (o ClusterEc2AttributesPtrOutput) Elem() ClusterEc2AttributesOutput

func (ClusterEc2AttributesPtrOutput) ElementType 

func (ClusterEc2AttributesPtrOutput) ElementType() reflect.Type

func (ClusterEc2AttributesPtrOutput) EmrManagedMasterSecurityGroup 

func (o ClusterEc2AttributesPtrOutput) EmrManagedMasterSecurityGroup() pulumi.StringPtrOutput

Identifier of the Amazon EC2 EMR-Managed security group for the master node

func (ClusterEc2AttributesPtrOutput) EmrManagedSlaveSecurityGroup 

func (o ClusterEc2AttributesPtrOutput) EmrManagedSlaveSecurityGroup() pulumi.StringPtrOutput

Identifier of the Amazon EC2 EMR-Managed security group for the slave nodes

func (ClusterEc2AttributesPtrOutput) InstanceProfile 

func (o ClusterEc2AttributesPtrOutput) InstanceProfile() pulumi.StringPtrOutput

Instance Profile for EC2 instances of the cluster assume this role

func (ClusterEc2AttributesPtrOutput) KeyName 

func (o ClusterEc2AttributesPtrOutput) KeyName() pulumi.StringPtrOutput

Amazon EC2 key pair that can be used to ssh to the master node as the user called `hadoop`

func (ClusterEc2AttributesPtrOutput) ServiceAccessSecurityGroup 

func (o ClusterEc2AttributesPtrOutput) ServiceAccessSecurityGroup() pulumi.StringPtrOutput

Identifier of the Amazon EC2 service-access security group - required when the cluster runs on a private subnet

func (ClusterEc2AttributesPtrOutput) SubnetId 

func (o ClusterEc2AttributesPtrOutput) SubnetId() pulumi.StringPtrOutput

VPC subnet id where you want the job flow to launch. Cannot specify the `cc1.4xlarge` instance type for nodes of a job flow launched in a Amazon VPC

func (ClusterEc2AttributesPtrOutput) ToClusterEc2AttributesPtrOutput 

func (o ClusterEc2AttributesPtrOutput) ToClusterEc2AttributesPtrOutput() ClusterEc2AttributesPtrOutput

func (ClusterEc2AttributesPtrOutput) ToClusterEc2AttributesPtrOutputWithContext 

func (o ClusterEc2AttributesPtrOutput) ToClusterEc2AttributesPtrOutputWithContext(ctx context.Context) ClusterEc2AttributesPtrOutput

type ClusterInput added in v3.13.0 

type ClusterInput interface {
	pulumi.Input

	ToClusterOutput() ClusterOutput
	ToClusterOutputWithContext(ctx context.Context) ClusterOutput
}

type ClusterKerberosAttributes 

type ClusterKerberosAttributes struct {
	// The Active Directory password for `adDomainJoinUser`. This provider cannot perform drift detection of this configuration.
	AdDomainJoinPassword *string `pulumi:"adDomainJoinPassword"`
	// Required only when establishing a cross-realm trust with an Active Directory domain. A user with sufficient privileges to join resources to the domain. This provider cannot perform drift detection of this configuration.
	AdDomainJoinUser *string `pulumi:"adDomainJoinUser"`
	// Required only when establishing a cross-realm trust with a KDC in a different realm. The cross-realm principal password, which must be identical across realms. This provider cannot perform drift detection of this configuration.
	CrossRealmTrustPrincipalPassword *string `pulumi:"crossRealmTrustPrincipalPassword"`
	// The password used within the cluster for the kadmin service on the cluster-dedicated KDC, which maintains Kerberos principals, password policies, and keytabs for the cluster. This provider cannot perform drift detection of this configuration.
	KdcAdminPassword string `pulumi:"kdcAdminPassword"`
	// The name of the Kerberos realm to which all nodes in a cluster belong. For example, `EC2.INTERNAL`
	Realm string `pulumi:"realm"`
}

type ClusterKerberosAttributesArgs 

type ClusterKerberosAttributesArgs struct {
	// The Active Directory password for `adDomainJoinUser`. This provider cannot perform drift detection of this configuration.
	AdDomainJoinPassword pulumi.StringPtrInput `pulumi:"adDomainJoinPassword"`
	// Required only when establishing a cross-realm trust with an Active Directory domain. A user with sufficient privileges to join resources to the domain. This provider cannot perform drift detection of this configuration.
	AdDomainJoinUser pulumi.StringPtrInput `pulumi:"adDomainJoinUser"`
	// Required only when establishing a cross-realm trust with a KDC in a different realm. The cross-realm principal password, which must be identical across realms. This provider cannot perform drift detection of this configuration.
	CrossRealmTrustPrincipalPassword pulumi.StringPtrInput `pulumi:"crossRealmTrustPrincipalPassword"`
	// The password used within the cluster for the kadmin service on the cluster-dedicated KDC, which maintains Kerberos principals, password policies, and keytabs for the cluster. This provider cannot perform drift detection of this configuration.
	KdcAdminPassword pulumi.StringInput `pulumi:"kdcAdminPassword"`
	// The name of the Kerberos realm to which all nodes in a cluster belong. For example, `EC2.INTERNAL`
	Realm pulumi.StringInput `pulumi:"realm"`
}

func (ClusterKerberosAttributesArgs) ElementType 

func (ClusterKerberosAttributesArgs) ElementType() reflect.Type

func (ClusterKerberosAttributesArgs) ToClusterKerberosAttributesOutput 

func (i ClusterKerberosAttributesArgs) ToClusterKerberosAttributesOutput() ClusterKerberosAttributesOutput

func (ClusterKerberosAttributesArgs) ToClusterKerberosAttributesOutputWithContext 

func (i ClusterKerberosAttributesArgs) ToClusterKerberosAttributesOutputWithContext(ctx context.Context) ClusterKerberosAttributesOutput

func (ClusterKerberosAttributesArgs) ToClusterKerberosAttributesPtrOutput 

func (i ClusterKerberosAttributesArgs) ToClusterKerberosAttributesPtrOutput() ClusterKerberosAttributesPtrOutput

func (ClusterKerberosAttributesArgs) ToClusterKerberosAttributesPtrOutputWithContext 

func (i ClusterKerberosAttributesArgs) ToClusterKerberosAttributesPtrOutputWithContext(ctx context.Context) ClusterKerberosAttributesPtrOutput

type ClusterKerberosAttributesInput 

type ClusterKerberosAttributesInput interface {
	pulumi.Input

	ToClusterKerberosAttributesOutput() ClusterKerberosAttributesOutput
	ToClusterKerberosAttributesOutputWithContext(context.Context) ClusterKerberosAttributesOutput
}

ClusterKerberosAttributesInput is an input type that accepts ClusterKerberosAttributesArgs and ClusterKerberosAttributesOutput values. You can construct a concrete instance of `ClusterKerberosAttributesInput` via: 

ClusterKerberosAttributesArgs{...}

type ClusterKerberosAttributesOutput 

type ClusterKerberosAttributesOutput struct{ *pulumi.OutputState }

func (ClusterKerberosAttributesOutput) AdDomainJoinPassword 

func (o ClusterKerberosAttributesOutput) AdDomainJoinPassword() pulumi.StringPtrOutput

The Active Directory password for `adDomainJoinUser`. This provider cannot perform drift detection of this configuration.

func (ClusterKerberosAttributesOutput) AdDomainJoinUser 

func (o ClusterKerberosAttributesOutput) AdDomainJoinUser() pulumi.StringPtrOutput

Required only when establishing a cross-realm trust with an Active Directory domain. A user with sufficient privileges to join resources to the domain. This provider cannot perform drift detection of this configuration.

func (ClusterKerberosAttributesOutput) CrossRealmTrustPrincipalPassword 

func (o ClusterKerberosAttributesOutput) CrossRealmTrustPrincipalPassword() pulumi.StringPtrOutput

Required only when establishing a cross-realm trust with a KDC in a different realm. The cross-realm principal password, which must be identical across realms. This provider cannot perform drift detection of this configuration.

func (ClusterKerberosAttributesOutput) ElementType 

func (ClusterKerberosAttributesOutput) ElementType() reflect.Type

func (ClusterKerberosAttributesOutput) KdcAdminPassword 

func (o ClusterKerberosAttributesOutput) KdcAdminPassword() pulumi.StringOutput

The password used within the cluster for the kadmin service on the cluster-dedicated KDC, which maintains Kerberos principals, password policies, and keytabs for the cluster. This provider cannot perform drift detection of this configuration.

func (ClusterKerberosAttributesOutput) Realm 

func (o ClusterKerberosAttributesOutput) Realm() pulumi.StringOutput

The name of the Kerberos realm to which all nodes in a cluster belong. For example, `EC2.INTERNAL`

func (ClusterKerberosAttributesOutput) ToClusterKerberosAttributesOutput 

func (o ClusterKerberosAttributesOutput) ToClusterKerberosAttributesOutput() ClusterKerberosAttributesOutput

func (ClusterKerberosAttributesOutput) ToClusterKerberosAttributesOutputWithContext 

func (o ClusterKerberosAttributesOutput) ToClusterKerberosAttributesOutputWithContext(ctx context.Context) ClusterKerberosAttributesOutput

func (ClusterKerberosAttributesOutput) ToClusterKerberosAttributesPtrOutput 

func (o ClusterKerberosAttributesOutput) ToClusterKerberosAttributesPtrOutput() ClusterKerberosAttributesPtrOutput

func (ClusterKerberosAttributesOutput) ToClusterKerberosAttributesPtrOutputWithContext 

func (o ClusterKerberosAttributesOutput) ToClusterKerberosAttributesPtrOutputWithContext(ctx context.Context) ClusterKerberosAttributesPtrOutput

type ClusterKerberosAttributesPtrInput 

type ClusterKerberosAttributesPtrInput interface {
	pulumi.Input

	ToClusterKerberosAttributesPtrOutput() ClusterKerberosAttributesPtrOutput
	ToClusterKerberosAttributesPtrOutputWithContext(context.Context) ClusterKerberosAttributesPtrOutput
}

ClusterKerberosAttributesPtrInput is an input type that accepts ClusterKerberosAttributesArgs, ClusterKerberosAttributesPtr and ClusterKerberosAttributesPtrOutput values. You can construct a concrete instance of `ClusterKerberosAttributesPtrInput` via: 

        ClusterKerberosAttributesArgs{...}

or:

        nil

func ClusterKerberosAttributesPtr 

func ClusterKerberosAttributesPtr(v *ClusterKerberosAttributesArgs) ClusterKerberosAttributesPtrInput

type ClusterKerberosAttributesPtrOutput 

type ClusterKerberosAttributesPtrOutput struct{ *pulumi.OutputState }

func (ClusterKerberosAttributesPtrOutput) AdDomainJoinPassword 

func (o ClusterKerberosAttributesPtrOutput) AdDomainJoinPassword() pulumi.StringPtrOutput

The Active Directory password for `adDomainJoinUser`. This provider cannot perform drift detection of this configuration.

func (ClusterKerberosAttributesPtrOutput) AdDomainJoinUser 

func (o ClusterKerberosAttributesPtrOutput) AdDomainJoinUser() pulumi.StringPtrOutput

Required only when establishing a cross-realm trust with an Active Directory domain. A user with sufficient privileges to join resources to the domain. This provider cannot perform drift detection of this configuration.

func (ClusterKerberosAttributesPtrOutput) CrossRealmTrustPrincipalPassword 

func (o ClusterKerberosAttributesPtrOutput) CrossRealmTrustPrincipalPassword() pulumi.StringPtrOutput

Required only when establishing a cross-realm trust with a KDC in a different realm. The cross-realm principal password, which must be identical across realms. This provider cannot perform drift detection of this configuration.

func (ClusterKerberosAttributesPtrOutput) Elem 

func (o ClusterKerberosAttributesPtrOutput) Elem() ClusterKerberosAttributesOutput

func (ClusterKerberosAttributesPtrOutput) ElementType 

func (ClusterKerberosAttributesPtrOutput) ElementType() reflect.Type

func (ClusterKerberosAttributesPtrOutput) KdcAdminPassword 

func (o ClusterKerberosAttributesPtrOutput) KdcAdminPassword() pulumi.StringPtrOutput

The password used within the cluster for the kadmin service on the cluster-dedicated KDC, which maintains Kerberos principals, password policies, and keytabs for the cluster. This provider cannot perform drift detection of this configuration.

func (ClusterKerberosAttributesPtrOutput) Realm 

func (o ClusterKerberosAttributesPtrOutput) Realm() pulumi.StringPtrOutput

The name of the Kerberos realm to which all nodes in a cluster belong. For example, `EC2.INTERNAL`

func (ClusterKerberosAttributesPtrOutput) ToClusterKerberosAttributesPtrOutput 

func (o ClusterKerberosAttributesPtrOutput) ToClusterKerberosAttributesPtrOutput() ClusterKerberosAttributesPtrOutput

func (ClusterKerberosAttributesPtrOutput) ToClusterKerberosAttributesPtrOutputWithContext 

func (o ClusterKerberosAttributesPtrOutput) ToClusterKerberosAttributesPtrOutputWithContext(ctx context.Context) ClusterKerberosAttributesPtrOutput

type ClusterMap added in v3.25.0 

type ClusterMap map[string]ClusterInput

func (ClusterMap) ElementType added in v3.25.0 

func (ClusterMap) ElementType() reflect.Type

func (ClusterMap) ToClusterMapOutput added in v3.25.0 

func (i ClusterMap) ToClusterMapOutput() ClusterMapOutput

func (ClusterMap) ToClusterMapOutputWithContext added in v3.25.0 

func (i ClusterMap) ToClusterMapOutputWithContext(ctx context.Context) ClusterMapOutput

type ClusterMapInput added in v3.25.0 

type ClusterMapInput interface {
	pulumi.Input

	ToClusterMapOutput() ClusterMapOutput
	ToClusterMapOutputWithContext(context.Context) ClusterMapOutput
}

ClusterMapInput is an input type that accepts ClusterMap and ClusterMapOutput values. You can construct a concrete instance of `ClusterMapInput` via: 

ClusterMap{ "key": ClusterArgs{...} }

type ClusterMapOutput added in v3.25.0 

type ClusterMapOutput struct{ *pulumi.OutputState }

func (ClusterMapOutput) ElementType added in v3.25.0 

func (ClusterMapOutput) ElementType() reflect.Type

func (ClusterMapOutput) MapIndex added in v3.25.0 

func (o ClusterMapOutput) MapIndex(k pulumi.StringInput) ClusterOutput

func (ClusterMapOutput) ToClusterMapOutput added in v3.25.0 

func (o ClusterMapOutput) ToClusterMapOutput() ClusterMapOutput

func (ClusterMapOutput) ToClusterMapOutputWithContext added in v3.25.0 

func (o ClusterMapOutput) ToClusterMapOutputWithContext(ctx context.Context) ClusterMapOutput

type ClusterMasterInstanceFleet added in v3.3.0 

type ClusterMasterInstanceFleet struct {
	// The ID of the EMR Cluster
	Id *string `pulumi:"id"`
	// Configuration block for instance fleet
	InstanceTypeConfigs []ClusterMasterInstanceFleetInstanceTypeConfig `pulumi:"instanceTypeConfigs"`
	// Configuration block for launch specification
	LaunchSpecifications *ClusterMasterInstanceFleetLaunchSpecifications `pulumi:"launchSpecifications"`
	// Friendly name given to the instance fleet.
	Name                        *string `pulumi:"name"`
	ProvisionedOnDemandCapacity *int    `pulumi:"provisionedOnDemandCapacity"`
	ProvisionedSpotCapacity     *int    `pulumi:"provisionedSpotCapacity"`
	// The target capacity of On-Demand units for the instance fleet, which determines how many On-Demand instances to provision.
	TargetOnDemandCapacity *int `pulumi:"targetOnDemandCapacity"`
	// The target capacity of Spot units for the instance fleet, which determines how many Spot instances to provision.
	TargetSpotCapacity *int `pulumi:"targetSpotCapacity"`
}

type ClusterMasterInstanceFleetArgs added in v3.3.0 

type ClusterMasterInstanceFleetArgs struct {
	// The ID of the EMR Cluster
	Id pulumi.StringPtrInput `pulumi:"id"`
	// Configuration block for instance fleet
	InstanceTypeConfigs ClusterMasterInstanceFleetInstanceTypeConfigArrayInput `pulumi:"instanceTypeConfigs"`
	// Configuration block for launch specification
	LaunchSpecifications ClusterMasterInstanceFleetLaunchSpecificationsPtrInput `pulumi:"launchSpecifications"`
	// Friendly name given to the instance fleet.
	Name                        pulumi.StringPtrInput `pulumi:"name"`
	ProvisionedOnDemandCapacity pulumi.IntPtrInput    `pulumi:"provisionedOnDemandCapacity"`
	ProvisionedSpotCapacity     pulumi.IntPtrInput    `pulumi:"provisionedSpotCapacity"`
	// The target capacity of On-Demand units for the instance fleet, which determines how many On-Demand instances to provision.
	TargetOnDemandCapacity pulumi.IntPtrInput `pulumi:"targetOnDemandCapacity"`
	// The target capacity of Spot units for the instance fleet, which determines how many Spot instances to provision.
	TargetSpotCapacity pulumi.IntPtrInput `pulumi:"targetSpotCapacity"`
}

func (ClusterMasterInstanceFleetArgs) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetArgs) ElementType() reflect.Type

func (ClusterMasterInstanceFleetArgs) ToClusterMasterInstanceFleetOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetArgs) ToClusterMasterInstanceFleetOutput() ClusterMasterInstanceFleetOutput

func (ClusterMasterInstanceFleetArgs) ToClusterMasterInstanceFleetOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetArgs) ToClusterMasterInstanceFleetOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetOutput

func (ClusterMasterInstanceFleetArgs) ToClusterMasterInstanceFleetPtrOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetArgs) ToClusterMasterInstanceFleetPtrOutput() ClusterMasterInstanceFleetPtrOutput

func (ClusterMasterInstanceFleetArgs) ToClusterMasterInstanceFleetPtrOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetArgs) ToClusterMasterInstanceFleetPtrOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetPtrOutput

type ClusterMasterInstanceFleetInput added in v3.3.0 

type ClusterMasterInstanceFleetInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetOutput() ClusterMasterInstanceFleetOutput
	ToClusterMasterInstanceFleetOutputWithContext(context.Context) ClusterMasterInstanceFleetOutput
}

ClusterMasterInstanceFleetInput is an input type that accepts ClusterMasterInstanceFleetArgs and ClusterMasterInstanceFleetOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetInput` via: 

ClusterMasterInstanceFleetArgs{...}

type ClusterMasterInstanceFleetInstanceTypeConfig added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfig struct {
	// The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPrice *string `pulumi:"bidPrice"`
	// The bid price, as a percentage of On-Demand price, for each EC2 Spot instance as defined by `instanceType`. Expressed as a number (for example, 20 specifies 20%). If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPriceAsPercentageOfOnDemandPrice *float64 `pulumi:"bidPriceAsPercentageOfOnDemandPrice"`
	// A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.
	Configurations []ClusterMasterInstanceFleetInstanceTypeConfigConfiguration `pulumi:"configurations"`
	// Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.
	EbsConfigs []ClusterMasterInstanceFleetInstanceTypeConfigEbsConfig `pulumi:"ebsConfigs"`
	// An EC2 instance type, such as m4.xlarge.
	InstanceType string `pulumi:"instanceType"`
	// The number of units that a provisioned instance of this type provides toward fulfilling the target capacities defined in `emr.InstanceFleet`.
	WeightedCapacity *int `pulumi:"weightedCapacity"`
}

type ClusterMasterInstanceFleetInstanceTypeConfigArgs added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigArgs struct {
	// The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPrice pulumi.StringPtrInput `pulumi:"bidPrice"`
	// The bid price, as a percentage of On-Demand price, for each EC2 Spot instance as defined by `instanceType`. Expressed as a number (for example, 20 specifies 20%). If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPriceAsPercentageOfOnDemandPrice pulumi.Float64PtrInput `pulumi:"bidPriceAsPercentageOfOnDemandPrice"`
	// A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.
	Configurations ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayInput `pulumi:"configurations"`
	// Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.
	EbsConfigs ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayInput `pulumi:"ebsConfigs"`
	// An EC2 instance type, such as m4.xlarge.
	InstanceType pulumi.StringInput `pulumi:"instanceType"`
	// The number of units that a provisioned instance of this type provides toward fulfilling the target capacities defined in `emr.InstanceFleet`.
	WeightedCapacity pulumi.IntPtrInput `pulumi:"weightedCapacity"`
}

func (ClusterMasterInstanceFleetInstanceTypeConfigArgs) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigArgs) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigArgs) ToClusterMasterInstanceFleetInstanceTypeConfigOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigArgs) ToClusterMasterInstanceFleetInstanceTypeConfigOutput() ClusterMasterInstanceFleetInstanceTypeConfigOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigArgs) ToClusterMasterInstanceFleetInstanceTypeConfigOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigArgs) ToClusterMasterInstanceFleetInstanceTypeConfigOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigOutput

type ClusterMasterInstanceFleetInstanceTypeConfigArray added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigArray []ClusterMasterInstanceFleetInstanceTypeConfigInput

func (ClusterMasterInstanceFleetInstanceTypeConfigArray) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigArray) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigArray) ToClusterMasterInstanceFleetInstanceTypeConfigArrayOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigArray) ToClusterMasterInstanceFleetInstanceTypeConfigArrayOutput() ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigArray) ToClusterMasterInstanceFleetInstanceTypeConfigArrayOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigArray) ToClusterMasterInstanceFleetInstanceTypeConfigArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput

type ClusterMasterInstanceFleetInstanceTypeConfigArrayInput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigArrayInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetInstanceTypeConfigArrayOutput() ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput
	ToClusterMasterInstanceFleetInstanceTypeConfigArrayOutputWithContext(context.Context) ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput
}

ClusterMasterInstanceFleetInstanceTypeConfigArrayInput is an input type that accepts ClusterMasterInstanceFleetInstanceTypeConfigArray and ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetInstanceTypeConfigArrayInput` via: 

ClusterMasterInstanceFleetInstanceTypeConfigArray{ ClusterMasterInstanceFleetInstanceTypeConfigArgs{...} }

type ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput) Index added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput) Index(i pulumi.IntInput) ClusterMasterInstanceFleetInstanceTypeConfigOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigArrayOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigArrayOutput() ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigArrayOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput

type ClusterMasterInstanceFleetInstanceTypeConfigConfiguration added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigConfiguration struct {
	// The classification within a configuration.
	Classification *string `pulumi:"classification"`
	// A map of properties specified within a configuration classification
	Properties map[string]interface{} `pulumi:"properties"`
}

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArgs added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArgs struct {
	// The classification within a configuration.
	Classification pulumi.StringPtrInput `pulumi:"classification"`
	// A map of properties specified within a configuration classification
	Properties pulumi.MapInput `pulumi:"properties"`
}

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArgs) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArgs) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArgs) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArgs) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput() ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArgs) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArgs) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArray added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArray []ClusterMasterInstanceFleetInstanceTypeConfigConfigurationInput

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArray) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArray) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArray) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArray) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput() ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArray) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArray) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayInput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput() ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput
	ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext(context.Context) ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput
}

ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayInput is an input type that accepts ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArray and ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayInput` via: 

ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArray{ ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArgs{...} }

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput) Index added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput) Index(i pulumi.IntInput) ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput() ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationInput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput() ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput
	ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutputWithContext(context.Context) ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput
}

ClusterMasterInstanceFleetInstanceTypeConfigConfigurationInput is an input type that accepts ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArgs and ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetInstanceTypeConfigConfigurationInput` via: 

ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArgs{...}

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput) Classification added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput) Classification() pulumi.StringPtrOutput

The classification within a configuration.

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput) Properties added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput) Properties() pulumi.MapOutput

A map of properties specified within a configuration classification

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput() ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput) ToClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigConfigurationOutput

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfig added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfig struct {
	// The number of I/O operations per second (IOPS) that the volume supports
	Iops *int `pulumi:"iops"`
	// The volume size, in gibibytes (GiB).
	Size int `pulumi:"size"`
	// The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).
	Type string `pulumi:"type"`
	// The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)
	VolumesPerInstance *int `pulumi:"volumesPerInstance"`
}

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArgs added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArgs struct {
	// The number of I/O operations per second (IOPS) that the volume supports
	Iops pulumi.IntPtrInput `pulumi:"iops"`
	// The volume size, in gibibytes (GiB).
	Size pulumi.IntInput `pulumi:"size"`
	// The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).
	Type pulumi.StringInput `pulumi:"type"`
	// The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)
	VolumesPerInstance pulumi.IntPtrInput `pulumi:"volumesPerInstance"`
}

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArgs) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArgs) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArgs) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArgs) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput() ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArgs) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArgs) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArray added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArray []ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigInput

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArray) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArray) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArray) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArray) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput() ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArray) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArray) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayInput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput() ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput
	ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext(context.Context) ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput
}

ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayInput is an input type that accepts ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArray and ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayInput` via: 

ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArray{ ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArgs{...} }

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) Index added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) Index(i pulumi.IntInput) ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput() ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigInput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput() ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput
	ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext(context.Context) ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput
}

ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigInput is an input type that accepts ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArgs and ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigInput` via: 

ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArgs{...}

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) Iops added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) Iops() pulumi.IntPtrOutput

The number of I/O operations per second (IOPS) that the volume supports

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) Size added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) Size() pulumi.IntOutput

The volume size, in gibibytes (GiB).

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput() ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) ToClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) Type added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) Type() pulumi.StringOutput

The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).

func (ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) VolumesPerInstance added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigOutput) VolumesPerInstance() pulumi.IntPtrOutput

The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)

type ClusterMasterInstanceFleetInstanceTypeConfigInput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetInstanceTypeConfigOutput() ClusterMasterInstanceFleetInstanceTypeConfigOutput
	ToClusterMasterInstanceFleetInstanceTypeConfigOutputWithContext(context.Context) ClusterMasterInstanceFleetInstanceTypeConfigOutput
}

ClusterMasterInstanceFleetInstanceTypeConfigInput is an input type that accepts ClusterMasterInstanceFleetInstanceTypeConfigArgs and ClusterMasterInstanceFleetInstanceTypeConfigOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetInstanceTypeConfigInput` via: 

ClusterMasterInstanceFleetInstanceTypeConfigArgs{...}

type ClusterMasterInstanceFleetInstanceTypeConfigOutput added in v3.3.0 

type ClusterMasterInstanceFleetInstanceTypeConfigOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetInstanceTypeConfigOutput) BidPrice added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigOutput) BidPrice() pulumi.StringPtrOutput

The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.

func (ClusterMasterInstanceFleetInstanceTypeConfigOutput) BidPriceAsPercentageOfOnDemandPrice added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigOutput) BidPriceAsPercentageOfOnDemandPrice() pulumi.Float64PtrOutput

The bid price, as a percentage of On-Demand price, for each EC2 Spot instance as defined by `instanceType`. Expressed as a number (for example, 20 specifies 20%). If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.

func (ClusterMasterInstanceFleetInstanceTypeConfigOutput) Configurations added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigOutput) Configurations() ClusterMasterInstanceFleetInstanceTypeConfigConfigurationArrayOutput

A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.

func (ClusterMasterInstanceFleetInstanceTypeConfigOutput) EbsConfigs added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigOutput) EbsConfigs() ClusterMasterInstanceFleetInstanceTypeConfigEbsConfigArrayOutput

Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.

func (ClusterMasterInstanceFleetInstanceTypeConfigOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetInstanceTypeConfigOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetInstanceTypeConfigOutput) InstanceType added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigOutput) InstanceType() pulumi.StringOutput

An EC2 instance type, such as m4.xlarge.

func (ClusterMasterInstanceFleetInstanceTypeConfigOutput) ToClusterMasterInstanceFleetInstanceTypeConfigOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigOutput) ToClusterMasterInstanceFleetInstanceTypeConfigOutput() ClusterMasterInstanceFleetInstanceTypeConfigOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigOutput) ToClusterMasterInstanceFleetInstanceTypeConfigOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigOutput) ToClusterMasterInstanceFleetInstanceTypeConfigOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetInstanceTypeConfigOutput

func (ClusterMasterInstanceFleetInstanceTypeConfigOutput) WeightedCapacity added in v3.3.0 

func (o ClusterMasterInstanceFleetInstanceTypeConfigOutput) WeightedCapacity() pulumi.IntPtrOutput

The number of units that a provisioned instance of this type provides toward fulfilling the target capacities defined in `emr.InstanceFleet`.

type ClusterMasterInstanceFleetLaunchSpecifications added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecifications struct {
	// Configuration block for on demand instances launch specifications
	OnDemandSpecifications []ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecification `pulumi:"onDemandSpecifications"`
	// Configuration block for spot instances launch specifications
	SpotSpecifications []ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecification `pulumi:"spotSpecifications"`
}

type ClusterMasterInstanceFleetLaunchSpecificationsArgs added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsArgs struct {
	// Configuration block for on demand instances launch specifications
	OnDemandSpecifications ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput `pulumi:"onDemandSpecifications"`
	// Configuration block for spot instances launch specifications
	SpotSpecifications ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayInput `pulumi:"spotSpecifications"`
}

func (ClusterMasterInstanceFleetLaunchSpecificationsArgs) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetLaunchSpecificationsArgs) ElementType() reflect.Type

func (ClusterMasterInstanceFleetLaunchSpecificationsArgs) ToClusterMasterInstanceFleetLaunchSpecificationsOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsArgs) ToClusterMasterInstanceFleetLaunchSpecificationsOutput() ClusterMasterInstanceFleetLaunchSpecificationsOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsArgs) ToClusterMasterInstanceFleetLaunchSpecificationsOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsArgs) ToClusterMasterInstanceFleetLaunchSpecificationsOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsArgs) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsArgs) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutput() ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsArgs) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsArgs) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput

type ClusterMasterInstanceFleetLaunchSpecificationsInput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetLaunchSpecificationsOutput() ClusterMasterInstanceFleetLaunchSpecificationsOutput
	ToClusterMasterInstanceFleetLaunchSpecificationsOutputWithContext(context.Context) ClusterMasterInstanceFleetLaunchSpecificationsOutput
}

ClusterMasterInstanceFleetLaunchSpecificationsInput is an input type that accepts ClusterMasterInstanceFleetLaunchSpecificationsArgs and ClusterMasterInstanceFleetLaunchSpecificationsOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetLaunchSpecificationsInput` via: 

ClusterMasterInstanceFleetLaunchSpecificationsArgs{...}

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecification added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecification struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy string `pulumi:"allocationStrategy"`
}

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy pulumi.StringInput `pulumi:"allocationStrategy"`
}

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ElementType() reflect.Type

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput() ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArray added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArray []ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationInput

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ElementType() reflect.Type

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput() ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput() ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput
	ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext(context.Context) ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput
}

ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput is an input type that accepts ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArray and ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput` via: 

ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArray{ ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs{...} }

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) Index added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) Index(i pulumi.IntInput) ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput() ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationInput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput() ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput
	ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext(context.Context) ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput
}

ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationInput is an input type that accepts ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs and ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationInput` via: 

ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArgs{...}

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) AllocationStrategy added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) AllocationStrategy() pulumi.StringOutput

Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput() ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

type ClusterMasterInstanceFleetLaunchSpecificationsOutput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetLaunchSpecificationsOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetLaunchSpecificationsOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetLaunchSpecificationsOutput) OnDemandSpecifications added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOutput) OnDemandSpecifications() ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

Configuration block for on demand instances launch specifications

func (ClusterMasterInstanceFleetLaunchSpecificationsOutput) SpotSpecifications added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOutput) SpotSpecifications() ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

Configuration block for spot instances launch specifications

func (ClusterMasterInstanceFleetLaunchSpecificationsOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOutput() ClusterMasterInstanceFleetLaunchSpecificationsOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOutput) ToClusterMasterInstanceFleetLaunchSpecificationsOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsOutput) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOutput) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutput() ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsOutput) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsOutput) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput

type ClusterMasterInstanceFleetLaunchSpecificationsPtrInput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsPtrInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutput() ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput
	ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutputWithContext(context.Context) ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput
}

ClusterMasterInstanceFleetLaunchSpecificationsPtrInput is an input type that accepts ClusterMasterInstanceFleetLaunchSpecificationsArgs, ClusterMasterInstanceFleetLaunchSpecificationsPtr and ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetLaunchSpecificationsPtrInput` via: 

        ClusterMasterInstanceFleetLaunchSpecificationsArgs{...}

or:

        nil

func ClusterMasterInstanceFleetLaunchSpecificationsPtr added in v3.3.0 

func ClusterMasterInstanceFleetLaunchSpecificationsPtr(v *ClusterMasterInstanceFleetLaunchSpecificationsArgs) ClusterMasterInstanceFleetLaunchSpecificationsPtrInput

type ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) Elem added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) Elem() ClusterMasterInstanceFleetLaunchSpecificationsOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) OnDemandSpecifications added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) OnDemandSpecifications() ClusterMasterInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

Configuration block for on demand instances launch specifications

func (ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) SpotSpecifications added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) SpotSpecifications() ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

Configuration block for spot instances launch specifications

func (ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutput() ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput) ToClusterMasterInstanceFleetLaunchSpecificationsPtrOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecification added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecification struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy string `pulumi:"allocationStrategy"`
	// The defined duration for Spot instances (also known as Spot blocks) in minutes. When specified, the Spot instance does not terminate before the defined duration expires, and defined duration pricing for Spot instances applies. Valid values are 60, 120, 180, 240, 300, or 360. The duration period starts as soon as a Spot instance receives its instance ID. At the end of the duration, Amazon EC2 marks the Spot instance for termination and provides a Spot instance termination notice, which gives the instance a two-minute warning before it terminates.
	BlockDurationMinutes *int `pulumi:"blockDurationMinutes"`
	// The action to take when TargetSpotCapacity has not been fulfilled when the TimeoutDurationMinutes has expired; that is, when all Spot instances could not be provisioned within the Spot provisioning timeout. Valid values are `TERMINATE_CLUSTER` and `SWITCH_TO_ON_DEMAND`. SWITCH_TO_ON_DEMAND specifies that if no Spot instances are available, On-Demand Instances should be provisioned to fulfill any remaining Spot capacity.
	TimeoutAction string `pulumi:"timeoutAction"`
	// The spot provisioning timeout period in minutes. If Spot instances are not provisioned within this time period, the TimeOutAction is taken. Minimum value is 5 and maximum value is 1440. The timeout applies only during initial provisioning, when the cluster is first created.
	TimeoutDurationMinutes int `pulumi:"timeoutDurationMinutes"`
}

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArgs added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArgs struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy pulumi.StringInput `pulumi:"allocationStrategy"`
	// The defined duration for Spot instances (also known as Spot blocks) in minutes. When specified, the Spot instance does not terminate before the defined duration expires, and defined duration pricing for Spot instances applies. Valid values are 60, 120, 180, 240, 300, or 360. The duration period starts as soon as a Spot instance receives its instance ID. At the end of the duration, Amazon EC2 marks the Spot instance for termination and provides a Spot instance termination notice, which gives the instance a two-minute warning before it terminates.
	BlockDurationMinutes pulumi.IntPtrInput `pulumi:"blockDurationMinutes"`
	// The action to take when TargetSpotCapacity has not been fulfilled when the TimeoutDurationMinutes has expired; that is, when all Spot instances could not be provisioned within the Spot provisioning timeout. Valid values are `TERMINATE_CLUSTER` and `SWITCH_TO_ON_DEMAND`. SWITCH_TO_ON_DEMAND specifies that if no Spot instances are available, On-Demand Instances should be provisioned to fulfill any remaining Spot capacity.
	TimeoutAction pulumi.StringInput `pulumi:"timeoutAction"`
	// The spot provisioning timeout period in minutes. If Spot instances are not provisioned within this time period, the TimeOutAction is taken. Minimum value is 5 and maximum value is 1440. The timeout applies only during initial provisioning, when the cluster is first created.
	TimeoutDurationMinutes pulumi.IntInput `pulumi:"timeoutDurationMinutes"`
}

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ElementType() reflect.Type

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput() ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArray added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArray []ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationInput

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArray) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArray) ElementType() reflect.Type

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArray) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArray) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput() ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArray) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext added in v3.3.0 

func (i ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArray) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayInput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput() ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput
	ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext(context.Context) ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput
}

ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayInput is an input type that accepts ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArray and ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayInput` via: 

ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArray{ ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArgs{...} }

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) Index added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) Index(i pulumi.IntInput) ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput() ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationInput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput() ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput
	ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext(context.Context) ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput
}

ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationInput is an input type that accepts ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArgs and ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationInput` via: 

ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationArgs{...}

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput added in v3.3.0 

type ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) AllocationStrategy added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) AllocationStrategy() pulumi.StringOutput

Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) BlockDurationMinutes added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) BlockDurationMinutes() pulumi.IntPtrOutput

The defined duration for Spot instances (also known as Spot blocks) in minutes. When specified, the Spot instance does not terminate before the defined duration expires, and defined duration pricing for Spot instances applies. Valid values are 60, 120, 180, 240, 300, or 360. The duration period starts as soon as a Spot instance receives its instance ID. At the end of the duration, Amazon EC2 marks the Spot instance for termination and provides a Spot instance termination notice, which gives the instance a two-minute warning before it terminates.

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutAction added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutAction() pulumi.StringOutput

The action to take when TargetSpotCapacity has not been fulfilled when the TimeoutDurationMinutes has expired; that is, when all Spot instances could not be provisioned within the Spot provisioning timeout. Valid values are `TERMINATE_CLUSTER` and `SWITCH_TO_ON_DEMAND`. SWITCH_TO_ON_DEMAND specifies that if no Spot instances are available, On-Demand Instances should be provisioned to fulfill any remaining Spot capacity.

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutDurationMinutes added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutDurationMinutes() pulumi.IntOutput

The spot provisioning timeout period in minutes. If Spot instances are not provisioned within this time period, the TimeOutAction is taken. Minimum value is 5 and maximum value is 1440. The timeout applies only during initial provisioning, when the cluster is first created.

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput() ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput

func (ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetLaunchSpecificationsSpotSpecificationOutput

type ClusterMasterInstanceFleetOutput added in v3.3.0 

type ClusterMasterInstanceFleetOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetOutput) Id added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) Id() pulumi.StringPtrOutput

The ID of the EMR Cluster

func (ClusterMasterInstanceFleetOutput) InstanceTypeConfigs added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) InstanceTypeConfigs() ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput

Configuration block for instance fleet

func (ClusterMasterInstanceFleetOutput) LaunchSpecifications added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) LaunchSpecifications() ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput

Configuration block for launch specification

func (ClusterMasterInstanceFleetOutput) Name added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) Name() pulumi.StringPtrOutput

Friendly name given to the instance fleet.

func (ClusterMasterInstanceFleetOutput) ProvisionedOnDemandCapacity added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) ProvisionedOnDemandCapacity() pulumi.IntPtrOutput

func (ClusterMasterInstanceFleetOutput) ProvisionedSpotCapacity added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) ProvisionedSpotCapacity() pulumi.IntPtrOutput

func (ClusterMasterInstanceFleetOutput) TargetOnDemandCapacity added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) TargetOnDemandCapacity() pulumi.IntPtrOutput

The target capacity of On-Demand units for the instance fleet, which determines how many On-Demand instances to provision.

func (ClusterMasterInstanceFleetOutput) TargetSpotCapacity added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) TargetSpotCapacity() pulumi.IntPtrOutput

The target capacity of Spot units for the instance fleet, which determines how many Spot instances to provision.

func (ClusterMasterInstanceFleetOutput) ToClusterMasterInstanceFleetOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) ToClusterMasterInstanceFleetOutput() ClusterMasterInstanceFleetOutput

func (ClusterMasterInstanceFleetOutput) ToClusterMasterInstanceFleetOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) ToClusterMasterInstanceFleetOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetOutput

func (ClusterMasterInstanceFleetOutput) ToClusterMasterInstanceFleetPtrOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) ToClusterMasterInstanceFleetPtrOutput() ClusterMasterInstanceFleetPtrOutput

func (ClusterMasterInstanceFleetOutput) ToClusterMasterInstanceFleetPtrOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetOutput) ToClusterMasterInstanceFleetPtrOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetPtrOutput

type ClusterMasterInstanceFleetPtrInput added in v3.3.0 

type ClusterMasterInstanceFleetPtrInput interface {
	pulumi.Input

	ToClusterMasterInstanceFleetPtrOutput() ClusterMasterInstanceFleetPtrOutput
	ToClusterMasterInstanceFleetPtrOutputWithContext(context.Context) ClusterMasterInstanceFleetPtrOutput
}

ClusterMasterInstanceFleetPtrInput is an input type that accepts ClusterMasterInstanceFleetArgs, ClusterMasterInstanceFleetPtr and ClusterMasterInstanceFleetPtrOutput values. You can construct a concrete instance of `ClusterMasterInstanceFleetPtrInput` via: 

        ClusterMasterInstanceFleetArgs{...}

or:

        nil

func ClusterMasterInstanceFleetPtr added in v3.3.0 

func ClusterMasterInstanceFleetPtr(v *ClusterMasterInstanceFleetArgs) ClusterMasterInstanceFleetPtrInput

type ClusterMasterInstanceFleetPtrOutput added in v3.3.0 

type ClusterMasterInstanceFleetPtrOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceFleetPtrOutput) Elem added in v3.3.0 

func (o ClusterMasterInstanceFleetPtrOutput) Elem() ClusterMasterInstanceFleetOutput

func (ClusterMasterInstanceFleetPtrOutput) ElementType added in v3.3.0 

func (ClusterMasterInstanceFleetPtrOutput) ElementType() reflect.Type

func (ClusterMasterInstanceFleetPtrOutput) Id added in v3.3.0 

func (o ClusterMasterInstanceFleetPtrOutput) Id() pulumi.StringPtrOutput

The ID of the EMR Cluster

func (ClusterMasterInstanceFleetPtrOutput) InstanceTypeConfigs added in v3.3.0 

func (o ClusterMasterInstanceFleetPtrOutput) InstanceTypeConfigs() ClusterMasterInstanceFleetInstanceTypeConfigArrayOutput

Configuration block for instance fleet

func (ClusterMasterInstanceFleetPtrOutput) LaunchSpecifications added in v3.3.0 

func (o ClusterMasterInstanceFleetPtrOutput) LaunchSpecifications() ClusterMasterInstanceFleetLaunchSpecificationsPtrOutput

Configuration block for launch specification

func (ClusterMasterInstanceFleetPtrOutput) Name added in v3.3.0 

func (o ClusterMasterInstanceFleetPtrOutput) Name() pulumi.StringPtrOutput

Friendly name given to the instance fleet.

func (ClusterMasterInstanceFleetPtrOutput) ProvisionedOnDemandCapacity added in v3.3.0 

func (o ClusterMasterInstanceFleetPtrOutput) ProvisionedOnDemandCapacity() pulumi.IntPtrOutput

func (ClusterMasterInstanceFleetPtrOutput) ProvisionedSpotCapacity added in v3.3.0 

func (o ClusterMasterInstanceFleetPtrOutput) ProvisionedSpotCapacity() pulumi.IntPtrOutput

func (ClusterMasterInstanceFleetPtrOutput) TargetOnDemandCapacity added in v3.3.0 

func (o ClusterMasterInstanceFleetPtrOutput) TargetOnDemandCapacity() pulumi.IntPtrOutput

The target capacity of On-Demand units for the instance fleet, which determines how many On-Demand instances to provision.

func (ClusterMasterInstanceFleetPtrOutput) TargetSpotCapacity added in v3.3.0 

func (o ClusterMasterInstanceFleetPtrOutput) TargetSpotCapacity() pulumi.IntPtrOutput

The target capacity of Spot units for the instance fleet, which determines how many Spot instances to provision.

func (ClusterMasterInstanceFleetPtrOutput) ToClusterMasterInstanceFleetPtrOutput added in v3.3.0 

func (o ClusterMasterInstanceFleetPtrOutput) ToClusterMasterInstanceFleetPtrOutput() ClusterMasterInstanceFleetPtrOutput

func (ClusterMasterInstanceFleetPtrOutput) ToClusterMasterInstanceFleetPtrOutputWithContext added in v3.3.0 

func (o ClusterMasterInstanceFleetPtrOutput) ToClusterMasterInstanceFleetPtrOutputWithContext(ctx context.Context) ClusterMasterInstanceFleetPtrOutput

type ClusterMasterInstanceGroup 

type ClusterMasterInstanceGroup struct {
	// The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPrice *string `pulumi:"bidPrice"`
	// Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.
	EbsConfigs []ClusterMasterInstanceGroupEbsConfig `pulumi:"ebsConfigs"`
	// The ID of the EMR Cluster
	Id *string `pulumi:"id"`
	// Target number of instances for the instance group. Must be 1 or 3. Defaults to 1. Launching with multiple master nodes is only supported in EMR version 5.23.0+, and requires this resource's `coreInstanceGroup` to be configured. Public (Internet accessible) instances must be created in VPC subnets that have `map public IP on launch` enabled. Termination protection is automatically enabled when launched with multiple master nodes and this provider must have the `terminationProtection = false` configuration applied before destroying this resource.
	InstanceCount *int `pulumi:"instanceCount"`
	// An EC2 instance type, such as m4.xlarge.
	InstanceType string `pulumi:"instanceType"`
	// Friendly name given to the instance fleet.
	Name *string `pulumi:"name"`
}

type ClusterMasterInstanceGroupArgs 

type ClusterMasterInstanceGroupArgs struct {
	// The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPrice pulumi.StringPtrInput `pulumi:"bidPrice"`
	// Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.
	EbsConfigs ClusterMasterInstanceGroupEbsConfigArrayInput `pulumi:"ebsConfigs"`
	// The ID of the EMR Cluster
	Id pulumi.StringPtrInput `pulumi:"id"`
	// Target number of instances for the instance group. Must be 1 or 3. Defaults to 1. Launching with multiple master nodes is only supported in EMR version 5.23.0+, and requires this resource's `coreInstanceGroup` to be configured. Public (Internet accessible) instances must be created in VPC subnets that have `map public IP on launch` enabled. Termination protection is automatically enabled when launched with multiple master nodes and this provider must have the `terminationProtection = false` configuration applied before destroying this resource.
	InstanceCount pulumi.IntPtrInput `pulumi:"instanceCount"`
	// An EC2 instance type, such as m4.xlarge.
	InstanceType pulumi.StringInput `pulumi:"instanceType"`
	// Friendly name given to the instance fleet.
	Name pulumi.StringPtrInput `pulumi:"name"`
}

func (ClusterMasterInstanceGroupArgs) ElementType 

func (ClusterMasterInstanceGroupArgs) ElementType() reflect.Type

func (ClusterMasterInstanceGroupArgs) ToClusterMasterInstanceGroupOutput 

func (i ClusterMasterInstanceGroupArgs) ToClusterMasterInstanceGroupOutput() ClusterMasterInstanceGroupOutput

func (ClusterMasterInstanceGroupArgs) ToClusterMasterInstanceGroupOutputWithContext 

func (i ClusterMasterInstanceGroupArgs) ToClusterMasterInstanceGroupOutputWithContext(ctx context.Context) ClusterMasterInstanceGroupOutput

func (ClusterMasterInstanceGroupArgs) ToClusterMasterInstanceGroupPtrOutput 

func (i ClusterMasterInstanceGroupArgs) ToClusterMasterInstanceGroupPtrOutput() ClusterMasterInstanceGroupPtrOutput

func (ClusterMasterInstanceGroupArgs) ToClusterMasterInstanceGroupPtrOutputWithContext 

func (i ClusterMasterInstanceGroupArgs) ToClusterMasterInstanceGroupPtrOutputWithContext(ctx context.Context) ClusterMasterInstanceGroupPtrOutput

type ClusterMasterInstanceGroupEbsConfig 

type ClusterMasterInstanceGroupEbsConfig struct {
	// The number of I/O operations per second (IOPS) that the volume supports
	Iops *int `pulumi:"iops"`
	// The volume size, in gibibytes (GiB).
	Size int `pulumi:"size"`
	// The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).
	Type string `pulumi:"type"`
	// The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)
	VolumesPerInstance *int `pulumi:"volumesPerInstance"`
}

type ClusterMasterInstanceGroupEbsConfigArgs 

type ClusterMasterInstanceGroupEbsConfigArgs struct {
	// The number of I/O operations per second (IOPS) that the volume supports
	Iops pulumi.IntPtrInput `pulumi:"iops"`
	// The volume size, in gibibytes (GiB).
	Size pulumi.IntInput `pulumi:"size"`
	// The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).
	Type pulumi.StringInput `pulumi:"type"`
	// The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)
	VolumesPerInstance pulumi.IntPtrInput `pulumi:"volumesPerInstance"`
}

func (ClusterMasterInstanceGroupEbsConfigArgs) ElementType 

func (ClusterMasterInstanceGroupEbsConfigArgs) ElementType() reflect.Type

func (ClusterMasterInstanceGroupEbsConfigArgs) ToClusterMasterInstanceGroupEbsConfigOutput 

func (i ClusterMasterInstanceGroupEbsConfigArgs) ToClusterMasterInstanceGroupEbsConfigOutput() ClusterMasterInstanceGroupEbsConfigOutput

func (ClusterMasterInstanceGroupEbsConfigArgs) ToClusterMasterInstanceGroupEbsConfigOutputWithContext 

func (i ClusterMasterInstanceGroupEbsConfigArgs) ToClusterMasterInstanceGroupEbsConfigOutputWithContext(ctx context.Context) ClusterMasterInstanceGroupEbsConfigOutput

type ClusterMasterInstanceGroupEbsConfigArray 

type ClusterMasterInstanceGroupEbsConfigArray []ClusterMasterInstanceGroupEbsConfigInput

func (ClusterMasterInstanceGroupEbsConfigArray) ElementType 

func (ClusterMasterInstanceGroupEbsConfigArray) ElementType() reflect.Type

func (ClusterMasterInstanceGroupEbsConfigArray) ToClusterMasterInstanceGroupEbsConfigArrayOutput 

func (i ClusterMasterInstanceGroupEbsConfigArray) ToClusterMasterInstanceGroupEbsConfigArrayOutput() ClusterMasterInstanceGroupEbsConfigArrayOutput

func (ClusterMasterInstanceGroupEbsConfigArray) ToClusterMasterInstanceGroupEbsConfigArrayOutputWithContext 

func (i ClusterMasterInstanceGroupEbsConfigArray) ToClusterMasterInstanceGroupEbsConfigArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceGroupEbsConfigArrayOutput

type ClusterMasterInstanceGroupEbsConfigArrayInput 

type ClusterMasterInstanceGroupEbsConfigArrayInput interface {
	pulumi.Input

	ToClusterMasterInstanceGroupEbsConfigArrayOutput() ClusterMasterInstanceGroupEbsConfigArrayOutput
	ToClusterMasterInstanceGroupEbsConfigArrayOutputWithContext(context.Context) ClusterMasterInstanceGroupEbsConfigArrayOutput
}

ClusterMasterInstanceGroupEbsConfigArrayInput is an input type that accepts ClusterMasterInstanceGroupEbsConfigArray and ClusterMasterInstanceGroupEbsConfigArrayOutput values. You can construct a concrete instance of `ClusterMasterInstanceGroupEbsConfigArrayInput` via: 

ClusterMasterInstanceGroupEbsConfigArray{ ClusterMasterInstanceGroupEbsConfigArgs{...} }

type ClusterMasterInstanceGroupEbsConfigArrayOutput 

type ClusterMasterInstanceGroupEbsConfigArrayOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceGroupEbsConfigArrayOutput) ElementType 

func (ClusterMasterInstanceGroupEbsConfigArrayOutput) ElementType() reflect.Type

func (ClusterMasterInstanceGroupEbsConfigArrayOutput) Index 

func (o ClusterMasterInstanceGroupEbsConfigArrayOutput) Index(i pulumi.IntInput) ClusterMasterInstanceGroupEbsConfigOutput

func (ClusterMasterInstanceGroupEbsConfigArrayOutput) ToClusterMasterInstanceGroupEbsConfigArrayOutput 

func (o ClusterMasterInstanceGroupEbsConfigArrayOutput) ToClusterMasterInstanceGroupEbsConfigArrayOutput() ClusterMasterInstanceGroupEbsConfigArrayOutput

func (ClusterMasterInstanceGroupEbsConfigArrayOutput) ToClusterMasterInstanceGroupEbsConfigArrayOutputWithContext 

func (o ClusterMasterInstanceGroupEbsConfigArrayOutput) ToClusterMasterInstanceGroupEbsConfigArrayOutputWithContext(ctx context.Context) ClusterMasterInstanceGroupEbsConfigArrayOutput

type ClusterMasterInstanceGroupEbsConfigInput 

type ClusterMasterInstanceGroupEbsConfigInput interface {
	pulumi.Input

	ToClusterMasterInstanceGroupEbsConfigOutput() ClusterMasterInstanceGroupEbsConfigOutput
	ToClusterMasterInstanceGroupEbsConfigOutputWithContext(context.Context) ClusterMasterInstanceGroupEbsConfigOutput
}

ClusterMasterInstanceGroupEbsConfigInput is an input type that accepts ClusterMasterInstanceGroupEbsConfigArgs and ClusterMasterInstanceGroupEbsConfigOutput values. You can construct a concrete instance of `ClusterMasterInstanceGroupEbsConfigInput` via: 

ClusterMasterInstanceGroupEbsConfigArgs{...}

type ClusterMasterInstanceGroupEbsConfigOutput 

type ClusterMasterInstanceGroupEbsConfigOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceGroupEbsConfigOutput) ElementType 

func (ClusterMasterInstanceGroupEbsConfigOutput) ElementType() reflect.Type

func (ClusterMasterInstanceGroupEbsConfigOutput) Iops 

func (o ClusterMasterInstanceGroupEbsConfigOutput) Iops() pulumi.IntPtrOutput

The number of I/O operations per second (IOPS) that the volume supports

func (ClusterMasterInstanceGroupEbsConfigOutput) Size 

func (o ClusterMasterInstanceGroupEbsConfigOutput) Size() pulumi.IntOutput

The volume size, in gibibytes (GiB).

func (ClusterMasterInstanceGroupEbsConfigOutput) ToClusterMasterInstanceGroupEbsConfigOutput 

func (o ClusterMasterInstanceGroupEbsConfigOutput) ToClusterMasterInstanceGroupEbsConfigOutput() ClusterMasterInstanceGroupEbsConfigOutput

func (ClusterMasterInstanceGroupEbsConfigOutput) ToClusterMasterInstanceGroupEbsConfigOutputWithContext 

func (o ClusterMasterInstanceGroupEbsConfigOutput) ToClusterMasterInstanceGroupEbsConfigOutputWithContext(ctx context.Context) ClusterMasterInstanceGroupEbsConfigOutput

func (ClusterMasterInstanceGroupEbsConfigOutput) Type 

func (o ClusterMasterInstanceGroupEbsConfigOutput) Type() pulumi.StringOutput

The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).

func (ClusterMasterInstanceGroupEbsConfigOutput) VolumesPerInstance 

func (o ClusterMasterInstanceGroupEbsConfigOutput) VolumesPerInstance() pulumi.IntPtrOutput

The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)

type ClusterMasterInstanceGroupInput 

type ClusterMasterInstanceGroupInput interface {
	pulumi.Input

	ToClusterMasterInstanceGroupOutput() ClusterMasterInstanceGroupOutput
	ToClusterMasterInstanceGroupOutputWithContext(context.Context) ClusterMasterInstanceGroupOutput
}

ClusterMasterInstanceGroupInput is an input type that accepts ClusterMasterInstanceGroupArgs and ClusterMasterInstanceGroupOutput values. You can construct a concrete instance of `ClusterMasterInstanceGroupInput` via: 

ClusterMasterInstanceGroupArgs{...}

type ClusterMasterInstanceGroupOutput 

type ClusterMasterInstanceGroupOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceGroupOutput) BidPrice 

func (o ClusterMasterInstanceGroupOutput) BidPrice() pulumi.StringPtrOutput

The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.

func (ClusterMasterInstanceGroupOutput) EbsConfigs 

func (o ClusterMasterInstanceGroupOutput) EbsConfigs() ClusterMasterInstanceGroupEbsConfigArrayOutput

Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.

func (ClusterMasterInstanceGroupOutput) ElementType 

func (ClusterMasterInstanceGroupOutput) ElementType() reflect.Type

func (ClusterMasterInstanceGroupOutput) Id 

func (o ClusterMasterInstanceGroupOutput) Id() pulumi.StringPtrOutput

The ID of the EMR Cluster

func (ClusterMasterInstanceGroupOutput) InstanceCount 

func (o ClusterMasterInstanceGroupOutput) InstanceCount() pulumi.IntPtrOutput

Target number of instances for the instance group. Must be 1 or 3. Defaults to 1. Launching with multiple master nodes is only supported in EMR version 5.23.0+, and requires this resource's `coreInstanceGroup` to be configured. Public (Internet accessible) instances must be created in VPC subnets that have `map public IP on launch` enabled. Termination protection is automatically enabled when launched with multiple master nodes and this provider must have the `terminationProtection = false` configuration applied before destroying this resource.

func (ClusterMasterInstanceGroupOutput) InstanceType 

func (o ClusterMasterInstanceGroupOutput) InstanceType() pulumi.StringOutput

An EC2 instance type, such as m4.xlarge.

func (ClusterMasterInstanceGroupOutput) Name 

func (o ClusterMasterInstanceGroupOutput) Name() pulumi.StringPtrOutput

Friendly name given to the instance fleet.

func (ClusterMasterInstanceGroupOutput) ToClusterMasterInstanceGroupOutput 

func (o ClusterMasterInstanceGroupOutput) ToClusterMasterInstanceGroupOutput() ClusterMasterInstanceGroupOutput

func (ClusterMasterInstanceGroupOutput) ToClusterMasterInstanceGroupOutputWithContext 

func (o ClusterMasterInstanceGroupOutput) ToClusterMasterInstanceGroupOutputWithContext(ctx context.Context) ClusterMasterInstanceGroupOutput

func (ClusterMasterInstanceGroupOutput) ToClusterMasterInstanceGroupPtrOutput 

func (o ClusterMasterInstanceGroupOutput) ToClusterMasterInstanceGroupPtrOutput() ClusterMasterInstanceGroupPtrOutput

func (ClusterMasterInstanceGroupOutput) ToClusterMasterInstanceGroupPtrOutputWithContext 

func (o ClusterMasterInstanceGroupOutput) ToClusterMasterInstanceGroupPtrOutputWithContext(ctx context.Context) ClusterMasterInstanceGroupPtrOutput

type ClusterMasterInstanceGroupPtrInput 

type ClusterMasterInstanceGroupPtrInput interface {
	pulumi.Input

	ToClusterMasterInstanceGroupPtrOutput() ClusterMasterInstanceGroupPtrOutput
	ToClusterMasterInstanceGroupPtrOutputWithContext(context.Context) ClusterMasterInstanceGroupPtrOutput
}

ClusterMasterInstanceGroupPtrInput is an input type that accepts ClusterMasterInstanceGroupArgs, ClusterMasterInstanceGroupPtr and ClusterMasterInstanceGroupPtrOutput values. You can construct a concrete instance of `ClusterMasterInstanceGroupPtrInput` via: 

        ClusterMasterInstanceGroupArgs{...}

or:

        nil

func ClusterMasterInstanceGroupPtr 

func ClusterMasterInstanceGroupPtr(v *ClusterMasterInstanceGroupArgs) ClusterMasterInstanceGroupPtrInput

type ClusterMasterInstanceGroupPtrOutput 

type ClusterMasterInstanceGroupPtrOutput struct{ *pulumi.OutputState }

func (ClusterMasterInstanceGroupPtrOutput) BidPrice 

func (o ClusterMasterInstanceGroupPtrOutput) BidPrice() pulumi.StringPtrOutput

The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.

func (ClusterMasterInstanceGroupPtrOutput) EbsConfigs 

func (o ClusterMasterInstanceGroupPtrOutput) EbsConfigs() ClusterMasterInstanceGroupEbsConfigArrayOutput

Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.

func (ClusterMasterInstanceGroupPtrOutput) Elem 

func (o ClusterMasterInstanceGroupPtrOutput) Elem() ClusterMasterInstanceGroupOutput

func (ClusterMasterInstanceGroupPtrOutput) ElementType 

func (ClusterMasterInstanceGroupPtrOutput) ElementType() reflect.Type

func (ClusterMasterInstanceGroupPtrOutput) Id 

func (o ClusterMasterInstanceGroupPtrOutput) Id() pulumi.StringPtrOutput

The ID of the EMR Cluster

func (ClusterMasterInstanceGroupPtrOutput) InstanceCount 

func (o ClusterMasterInstanceGroupPtrOutput) InstanceCount() pulumi.IntPtrOutput

Target number of instances for the instance group. Must be 1 or 3. Defaults to 1. Launching with multiple master nodes is only supported in EMR version 5.23.0+, and requires this resource's `coreInstanceGroup` to be configured. Public (Internet accessible) instances must be created in VPC subnets that have `map public IP on launch` enabled. Termination protection is automatically enabled when launched with multiple master nodes and this provider must have the `terminationProtection = false` configuration applied before destroying this resource.

func (ClusterMasterInstanceGroupPtrOutput) InstanceType 

func (o ClusterMasterInstanceGroupPtrOutput) InstanceType() pulumi.StringPtrOutput

An EC2 instance type, such as m4.xlarge.

func (ClusterMasterInstanceGroupPtrOutput) Name 

func (o ClusterMasterInstanceGroupPtrOutput) Name() pulumi.StringPtrOutput

Friendly name given to the instance fleet.

func (ClusterMasterInstanceGroupPtrOutput) ToClusterMasterInstanceGroupPtrOutput 

func (o ClusterMasterInstanceGroupPtrOutput) ToClusterMasterInstanceGroupPtrOutput() ClusterMasterInstanceGroupPtrOutput

func (ClusterMasterInstanceGroupPtrOutput) ToClusterMasterInstanceGroupPtrOutputWithContext 

func (o ClusterMasterInstanceGroupPtrOutput) ToClusterMasterInstanceGroupPtrOutputWithContext(ctx context.Context) ClusterMasterInstanceGroupPtrOutput

type ClusterOutput added in v3.13.0 

type ClusterOutput struct {
	*pulumi.OutputState
}

func (ClusterOutput) ElementType added in v3.13.0 

func (ClusterOutput) ElementType() reflect.Type

func (ClusterOutput) ToClusterOutput added in v3.13.0 

func (o ClusterOutput) ToClusterOutput() ClusterOutput

func (ClusterOutput) ToClusterOutputWithContext added in v3.13.0 

func (o ClusterOutput) ToClusterOutputWithContext(ctx context.Context) ClusterOutput

func (ClusterOutput) ToClusterPtrOutput added in v3.25.0 

func (o ClusterOutput) ToClusterPtrOutput() ClusterPtrOutput

func (ClusterOutput) ToClusterPtrOutputWithContext added in v3.25.0 

func (o ClusterOutput) ToClusterPtrOutputWithContext(ctx context.Context) ClusterPtrOutput

type ClusterPtrInput added in v3.25.0 

type ClusterPtrInput interface {
	pulumi.Input

	ToClusterPtrOutput() ClusterPtrOutput
	ToClusterPtrOutputWithContext(ctx context.Context) ClusterPtrOutput
}

type ClusterPtrOutput added in v3.25.0 

type ClusterPtrOutput struct {
	*pulumi.OutputState
}

func (ClusterPtrOutput) ElementType added in v3.25.0 

func (ClusterPtrOutput) ElementType() reflect.Type

func (ClusterPtrOutput) ToClusterPtrOutput added in v3.25.0 

func (o ClusterPtrOutput) ToClusterPtrOutput() ClusterPtrOutput

func (ClusterPtrOutput) ToClusterPtrOutputWithContext added in v3.25.0 

func (o ClusterPtrOutput) ToClusterPtrOutputWithContext(ctx context.Context) ClusterPtrOutput

type ClusterState 

type ClusterState struct {
	// A JSON string for selecting additional features such as adding proxy information. Note: Currently there is no API to retrieve the value of this argument after EMR cluster creation from provider, therefore this provider cannot detect drift from the actual EMR cluster if its value is changed outside this provider.
	AdditionalInfo pulumi.StringPtrInput
	// A list of applications for the cluster. Valid values are: `Flink`, `Hadoop`, `Hive`, `Mahout`, `Pig`, `Spark`, and `JupyterHub` (as of EMR 5.14.0). Case insensitive
	Applications pulumi.StringArrayInput
	Arn          pulumi.StringPtrInput
	// An IAM role for automatic scaling policies. The IAM role provides permissions that the automatic scaling feature requires to launch and terminate EC2 instances in an instance group.
	AutoscalingRole pulumi.StringPtrInput
	// Ordered list of bootstrap actions that will be run before Hadoop is started on the cluster nodes. Defined below.
	BootstrapActions ClusterBootstrapActionArrayInput
	ClusterState     pulumi.StringPtrInput
	// A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.
	Configurations pulumi.StringPtrInput
	// A JSON string for supplying list of configurations for the EMR cluster.
	ConfigurationsJson pulumi.StringPtrInput
	// Configuration block to use an [Instance Fleet](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-fleet.html) for the core node type. Cannot be specified if any `coreInstanceGroup` configuration blocks are set. Detailed below.
	CoreInstanceFleet ClusterCoreInstanceFleetPtrInput
	// Configuration block to use an [Instance Group](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-group-configuration.html#emr-plan-instance-groups) for the [core node type](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html#emr-plan-core).
	CoreInstanceGroup ClusterCoreInstanceGroupPtrInput
	// A custom Amazon Linux AMI for the cluster (instead of an EMR-owned AMI). Available in Amazon EMR version 5.7.0 and later.
	CustomAmiId pulumi.StringPtrInput
	// Size in GiB of the EBS root device volume of the Linux AMI that is used for each EC2 instance. Available in Amazon EMR version 4.x and later.
	EbsRootVolumeSize pulumi.IntPtrInput
	// Attributes for the EC2 instances running the job flow. Defined below
	Ec2Attributes ClusterEc2AttributesPtrInput
	// Switch on/off run cluster with no steps or when all steps are complete (default is on)
	KeepJobFlowAliveWhenNoSteps pulumi.BoolPtrInput
	// Kerberos configuration for the cluster. Defined below
	KerberosAttributes ClusterKerberosAttributesPtrInput
	// S3 bucket to write the log files of the job flow. If a value is not provided, logs are not created
	LogUri pulumi.StringPtrInput
	// Configuration block to use an [Instance Fleet](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-fleet.html) for the master node type. Cannot be specified if any `masterInstanceGroup` configuration blocks are set. Detailed below.
	MasterInstanceFleet ClusterMasterInstanceFleetPtrInput
	// Configuration block to use an [Instance Group](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-instance-group-configuration.html#emr-plan-instance-groups) for the [master node type](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html#emr-plan-master).
	MasterInstanceGroup ClusterMasterInstanceGroupPtrInput
	// The public DNS name of the master EC2 instance.
	// * `core_instance_group.0.id` - Core node type Instance Group ID, if using Instance Group for this node type.
	MasterPublicDns pulumi.StringPtrInput
	// Friendly name given to the instance fleet.
	Name pulumi.StringPtrInput
	// The release label for the Amazon EMR release
	ReleaseLabel pulumi.StringPtrInput
	// The way that individual Amazon EC2 instances terminate when an automatic scale-in activity occurs or an `instance group` is resized.
	ScaleDownBehavior pulumi.StringPtrInput
	// The security configuration name to attach to the EMR cluster. Only valid for EMR clusters with `releaseLabel` 4.8.0 or greater
	SecurityConfiguration pulumi.StringPtrInput
	// IAM role that will be assumed by the Amazon EMR service to access AWS resources
	ServiceRole pulumi.StringPtrInput
	// The number of steps that can be executed concurrently. You can specify a maximum of 256 steps. Only valid for EMR clusters with `releaseLabel` 5.28.0 or greater. (default is 1)
	StepConcurrencyLevel pulumi.IntPtrInput
	// List of steps to run when creating the cluster. Defined below. It is highly recommended to utilize [`ignoreChanges`](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) if other steps are being managed outside of this provider.
	Steps ClusterStepArrayInput
	// list of tags to apply to the EMR Cluster
	Tags pulumi.StringMapInput
	// Switch on/off termination protection (default is `false`, except when using multiple master nodes). Before attempting to destroy the resource when termination protection is enabled, this configuration must be applied with its value set to `false`.
	TerminationProtection pulumi.BoolPtrInput
	// Whether the job flow is visible to all IAM users of the AWS account associated with the job flow. Default `true`
	VisibleToAllUsers pulumi.BoolPtrInput
}

func (ClusterState) ElementType 

func (ClusterState) ElementType() reflect.Type

type ClusterStep 

type ClusterStep struct {
	// The action to take if the step fails. Valid values: `TERMINATE_JOB_FLOW`, `TERMINATE_CLUSTER`, `CANCEL_AND_WAIT`, and `CONTINUE`
	ActionOnFailure string `pulumi:"actionOnFailure"`
	// The JAR file used for the step. Defined below.
	HadoopJarStep ClusterStepHadoopJarStep `pulumi:"hadoopJarStep"`
	// Friendly name given to the instance fleet.
	Name string `pulumi:"name"`
}

type ClusterStepArgs 

type ClusterStepArgs struct {
	// The action to take if the step fails. Valid values: `TERMINATE_JOB_FLOW`, `TERMINATE_CLUSTER`, `CANCEL_AND_WAIT`, and `CONTINUE`
	ActionOnFailure pulumi.StringInput `pulumi:"actionOnFailure"`
	// The JAR file used for the step. Defined below.
	HadoopJarStep ClusterStepHadoopJarStepInput `pulumi:"hadoopJarStep"`
	// Friendly name given to the instance fleet.
	Name pulumi.StringInput `pulumi:"name"`
}

func (ClusterStepArgs) ElementType 

func (ClusterStepArgs) ElementType() reflect.Type

func (ClusterStepArgs) ToClusterStepOutput 

func (i ClusterStepArgs) ToClusterStepOutput() ClusterStepOutput

func (ClusterStepArgs) ToClusterStepOutputWithContext 

func (i ClusterStepArgs) ToClusterStepOutputWithContext(ctx context.Context) ClusterStepOutput

type ClusterStepArray 

type ClusterStepArray []ClusterStepInput

func (ClusterStepArray) ElementType 

func (ClusterStepArray) ElementType() reflect.Type

func (ClusterStepArray) ToClusterStepArrayOutput 

func (i ClusterStepArray) ToClusterStepArrayOutput() ClusterStepArrayOutput

func (ClusterStepArray) ToClusterStepArrayOutputWithContext 

func (i ClusterStepArray) ToClusterStepArrayOutputWithContext(ctx context.Context) ClusterStepArrayOutput

type ClusterStepArrayInput 

type ClusterStepArrayInput interface {
	pulumi.Input

	ToClusterStepArrayOutput() ClusterStepArrayOutput
	ToClusterStepArrayOutputWithContext(context.Context) ClusterStepArrayOutput
}

ClusterStepArrayInput is an input type that accepts ClusterStepArray and ClusterStepArrayOutput values. You can construct a concrete instance of `ClusterStepArrayInput` via: 

ClusterStepArray{ ClusterStepArgs{...} }

type ClusterStepArrayOutput 

type ClusterStepArrayOutput struct{ *pulumi.OutputState }

func (ClusterStepArrayOutput) ElementType 

func (ClusterStepArrayOutput) ElementType() reflect.Type

func (ClusterStepArrayOutput) Index 

func (o ClusterStepArrayOutput) Index(i pulumi.IntInput) ClusterStepOutput

func (ClusterStepArrayOutput) ToClusterStepArrayOutput 

func (o ClusterStepArrayOutput) ToClusterStepArrayOutput() ClusterStepArrayOutput

func (ClusterStepArrayOutput) ToClusterStepArrayOutputWithContext 

func (o ClusterStepArrayOutput) ToClusterStepArrayOutputWithContext(ctx context.Context) ClusterStepArrayOutput

type ClusterStepHadoopJarStep 

type ClusterStepHadoopJarStep struct {
	// List of command line arguments passed to the JAR file's main function when executed.
	Args []string `pulumi:"args"`
	// Path to a JAR file run during the step.
	Jar string `pulumi:"jar"`
	// Name of the main class in the specified Java file. If not specified, the JAR file should specify a Main-Class in its manifest file.
	MainClass *string `pulumi:"mainClass"`
	// A map of properties specified within a configuration classification
	Properties map[string]string `pulumi:"properties"`
}

type ClusterStepHadoopJarStepArgs 

type ClusterStepHadoopJarStepArgs struct {
	// List of command line arguments passed to the JAR file's main function when executed.
	Args pulumi.StringArrayInput `pulumi:"args"`
	// Path to a JAR file run during the step.
	Jar pulumi.StringInput `pulumi:"jar"`
	// Name of the main class in the specified Java file. If not specified, the JAR file should specify a Main-Class in its manifest file.
	MainClass pulumi.StringPtrInput `pulumi:"mainClass"`
	// A map of properties specified within a configuration classification
	Properties pulumi.StringMapInput `pulumi:"properties"`
}

func (ClusterStepHadoopJarStepArgs) ElementType 

func (ClusterStepHadoopJarStepArgs) ElementType() reflect.Type

func (ClusterStepHadoopJarStepArgs) ToClusterStepHadoopJarStepOutput 

func (i ClusterStepHadoopJarStepArgs) ToClusterStepHadoopJarStepOutput() ClusterStepHadoopJarStepOutput

func (ClusterStepHadoopJarStepArgs) ToClusterStepHadoopJarStepOutputWithContext 

func (i ClusterStepHadoopJarStepArgs) ToClusterStepHadoopJarStepOutputWithContext(ctx context.Context) ClusterStepHadoopJarStepOutput

type ClusterStepHadoopJarStepInput 

type ClusterStepHadoopJarStepInput interface {
	pulumi.Input

	ToClusterStepHadoopJarStepOutput() ClusterStepHadoopJarStepOutput
	ToClusterStepHadoopJarStepOutputWithContext(context.Context) ClusterStepHadoopJarStepOutput
}

ClusterStepHadoopJarStepInput is an input type that accepts ClusterStepHadoopJarStepArgs and ClusterStepHadoopJarStepOutput values. You can construct a concrete instance of `ClusterStepHadoopJarStepInput` via: 

ClusterStepHadoopJarStepArgs{...}

type ClusterStepHadoopJarStepOutput 

type ClusterStepHadoopJarStepOutput struct{ *pulumi.OutputState }

func (ClusterStepHadoopJarStepOutput) Args 

func (o ClusterStepHadoopJarStepOutput) Args() pulumi.StringArrayOutput

List of command line arguments passed to the JAR file's main function when executed.

func (ClusterStepHadoopJarStepOutput) ElementType 

func (ClusterStepHadoopJarStepOutput) ElementType() reflect.Type

func (ClusterStepHadoopJarStepOutput) Jar 

func (o ClusterStepHadoopJarStepOutput) Jar() pulumi.StringOutput

Path to a JAR file run during the step.

func (ClusterStepHadoopJarStepOutput) MainClass 

func (o ClusterStepHadoopJarStepOutput) MainClass() pulumi.StringPtrOutput

Name of the main class in the specified Java file. If not specified, the JAR file should specify a Main-Class in its manifest file.

func (ClusterStepHadoopJarStepOutput) Properties 

func (o ClusterStepHadoopJarStepOutput) Properties() pulumi.StringMapOutput

A map of properties specified within a configuration classification

func (ClusterStepHadoopJarStepOutput) ToClusterStepHadoopJarStepOutput 

func (o ClusterStepHadoopJarStepOutput) ToClusterStepHadoopJarStepOutput() ClusterStepHadoopJarStepOutput

func (ClusterStepHadoopJarStepOutput) ToClusterStepHadoopJarStepOutputWithContext 

func (o ClusterStepHadoopJarStepOutput) ToClusterStepHadoopJarStepOutputWithContext(ctx context.Context) ClusterStepHadoopJarStepOutput

type ClusterStepInput 

type ClusterStepInput interface {
	pulumi.Input

	ToClusterStepOutput() ClusterStepOutput
	ToClusterStepOutputWithContext(context.Context) ClusterStepOutput
}

ClusterStepInput is an input type that accepts ClusterStepArgs and ClusterStepOutput values. You can construct a concrete instance of `ClusterStepInput` via: 

ClusterStepArgs{...}

type ClusterStepOutput 

type ClusterStepOutput struct{ *pulumi.OutputState }

func (ClusterStepOutput) ActionOnFailure 

func (o ClusterStepOutput) ActionOnFailure() pulumi.StringOutput

The action to take if the step fails. Valid values: `TERMINATE_JOB_FLOW`, `TERMINATE_CLUSTER`, `CANCEL_AND_WAIT`, and `CONTINUE`

func (ClusterStepOutput) ElementType 

func (ClusterStepOutput) ElementType() reflect.Type

func (ClusterStepOutput) HadoopJarStep 

func (o ClusterStepOutput) HadoopJarStep() ClusterStepHadoopJarStepOutput

The JAR file used for the step. Defined below.

func (ClusterStepOutput) Name 

func (o ClusterStepOutput) Name() pulumi.StringOutput

Friendly name given to the instance fleet.

func (ClusterStepOutput) ToClusterStepOutput 

func (o ClusterStepOutput) ToClusterStepOutput() ClusterStepOutput

func (ClusterStepOutput) ToClusterStepOutputWithContext 

func (o ClusterStepOutput) ToClusterStepOutputWithContext(ctx context.Context) ClusterStepOutput

type InstanceFleet added in v3.3.0 

type InstanceFleet struct {
	pulumi.CustomResourceState

	// ID of the EMR Cluster to attach to. Changing this forces a new resource to be created.
	ClusterId pulumi.StringOutput `pulumi:"clusterId"`
	// Configuration block for instance fleet
	InstanceTypeConfigs InstanceFleetInstanceTypeConfigArrayOutput `pulumi:"instanceTypeConfigs"`
	// Configuration block for launch specification
	LaunchSpecifications InstanceFleetLaunchSpecificationsPtrOutput `pulumi:"launchSpecifications"`
	// Friendly name given to the instance fleet.
	Name                        pulumi.StringOutput `pulumi:"name"`
	ProvisionedOnDemandCapacity pulumi.IntOutput    `pulumi:"provisionedOnDemandCapacity"`
	ProvisionedSpotCapacity     pulumi.IntOutput    `pulumi:"provisionedSpotCapacity"`
	// The target capacity of On-Demand units for the instance fleet, which determines how many On-Demand instances to provision.
	TargetOnDemandCapacity pulumi.IntPtrOutput `pulumi:"targetOnDemandCapacity"`
	// The target capacity of Spot units for the instance fleet, which determines how many Spot instances to provision.
	TargetSpotCapacity pulumi.IntPtrOutput `pulumi:"targetSpotCapacity"`
}

Provides an Elastic MapReduce Cluster Instance Fleet configuration. See [Amazon Elastic MapReduce Documentation](https://aws.amazon.com/documentation/emr/) for more information.

> **NOTE:** At this time, Instance Fleets cannot be destroyed through the API nor web interface. Instance Fleets are destroyed when the EMR Cluster is destroyed. the provider will resize any Instance Fleet to zero when destroying the resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/emr"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := emr.NewInstanceFleet(ctx, "task", &emr.InstanceFleetArgs{
			ClusterId: pulumi.Any(aws_emr_cluster.Cluster.Id),
			InstanceTypeConfigs: emr.InstanceFleetInstanceTypeConfigArray{
				&emr.InstanceFleetInstanceTypeConfigArgs{
					BidPriceAsPercentageOfOnDemandPrice: pulumi.Float64(100),
					EbsConfigs: emr.InstanceFleetInstanceTypeConfigEbsConfigArray{
						&emr.InstanceFleetInstanceTypeConfigEbsConfigArgs{
							Size:               pulumi.Int(100),
							Type:               pulumi.String("gp2"),
							VolumesPerInstance: pulumi.Int(1),
						},
					},
					InstanceType:     pulumi.String("m4.xlarge"),
					WeightedCapacity: pulumi.Int(1),
				},
				&emr.InstanceFleetInstanceTypeConfigArgs{
					BidPriceAsPercentageOfOnDemandPrice: pulumi.Float64(100),
					EbsConfigs: emr.InstanceFleetInstanceTypeConfigEbsConfigArray{
						&emr.InstanceFleetInstanceTypeConfigEbsConfigArgs{
							Size:               pulumi.Int(100),
							Type:               pulumi.String("gp2"),
							VolumesPerInstance: pulumi.Int(1),
						},
					},
					InstanceType:     pulumi.String("m4.2xlarge"),
					WeightedCapacity: pulumi.Int(2),
				},
			},
			LaunchSpecifications: &emr.InstanceFleetLaunchSpecificationsArgs{
				SpotSpecifications: emr.InstanceFleetLaunchSpecificationsSpotSpecificationArray{
					&emr.InstanceFleetLaunchSpecificationsSpotSpecificationArgs{
						AllocationStrategy:     pulumi.String("capacity-optimized"),
						BlockDurationMinutes:   pulumi.Int(0),
						TimeoutAction:          pulumi.String("TERMINATE_CLUSTER"),
						TimeoutDurationMinutes: pulumi.Int(10),
					},
				},
			},
			TargetOnDemandCapacity: pulumi.Int(1),
			TargetSpotCapacity:     pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

EMR Instance Fleet can be imported with the EMR Cluster identifier and Instance Fleet identifier separated by a forward slash (`/`), e.g. console

```sh 

$ pulumi import aws:emr/instanceFleet:InstanceFleet example j-123456ABCDEF/if-15EK4O09RZLNR

```

func GetInstanceFleet added in v3.3.0 

func GetInstanceFleet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *InstanceFleetState, opts ...pulumi.ResourceOption) (*InstanceFleet, error)

GetInstanceFleet gets an existing InstanceFleet resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewInstanceFleet added in v3.3.0 

func NewInstanceFleet(ctx *pulumi.Context,
	name string, args *InstanceFleetArgs, opts ...pulumi.ResourceOption) (*InstanceFleet, error)

NewInstanceFleet registers a new resource with the given unique name, arguments, and options.

func (*InstanceFleet) ElementType added in v3.13.0 

func (*InstanceFleet) ElementType() reflect.Type

func (*InstanceFleet) ToInstanceFleetOutput added in v3.13.0 

func (i *InstanceFleet) ToInstanceFleetOutput() InstanceFleetOutput

func (*InstanceFleet) ToInstanceFleetOutputWithContext added in v3.13.0 

func (i *InstanceFleet) ToInstanceFleetOutputWithContext(ctx context.Context) InstanceFleetOutput

func (*InstanceFleet) ToInstanceFleetPtrOutput added in v3.25.0 

func (i *InstanceFleet) ToInstanceFleetPtrOutput() InstanceFleetPtrOutput

func (*InstanceFleet) ToInstanceFleetPtrOutputWithContext added in v3.25.0 

func (i *InstanceFleet) ToInstanceFleetPtrOutputWithContext(ctx context.Context) InstanceFleetPtrOutput

type InstanceFleetArgs added in v3.3.0 

type InstanceFleetArgs struct {
	// ID of the EMR Cluster to attach to. Changing this forces a new resource to be created.
	ClusterId pulumi.StringInput
	// Configuration block for instance fleet
	InstanceTypeConfigs InstanceFleetInstanceTypeConfigArrayInput
	// Configuration block for launch specification
	LaunchSpecifications InstanceFleetLaunchSpecificationsPtrInput
	// Friendly name given to the instance fleet.
	Name pulumi.StringPtrInput
	// The target capacity of On-Demand units for the instance fleet, which determines how many On-Demand instances to provision.
	TargetOnDemandCapacity pulumi.IntPtrInput
	// The target capacity of Spot units for the instance fleet, which determines how many Spot instances to provision.
	TargetSpotCapacity pulumi.IntPtrInput
}

The set of arguments for constructing a InstanceFleet resource.

func (InstanceFleetArgs) ElementType added in v3.3.0 

func (InstanceFleetArgs) ElementType() reflect.Type

type InstanceFleetArray added in v3.25.0 

type InstanceFleetArray []InstanceFleetInput

func (InstanceFleetArray) ElementType added in v3.25.0 

func (InstanceFleetArray) ElementType() reflect.Type

func (InstanceFleetArray) ToInstanceFleetArrayOutput added in v3.25.0 

func (i InstanceFleetArray) ToInstanceFleetArrayOutput() InstanceFleetArrayOutput

func (InstanceFleetArray) ToInstanceFleetArrayOutputWithContext added in v3.25.0 

func (i InstanceFleetArray) ToInstanceFleetArrayOutputWithContext(ctx context.Context) InstanceFleetArrayOutput

type InstanceFleetArrayInput added in v3.25.0 

type InstanceFleetArrayInput interface {
	pulumi.Input

	ToInstanceFleetArrayOutput() InstanceFleetArrayOutput
	ToInstanceFleetArrayOutputWithContext(context.Context) InstanceFleetArrayOutput
}

InstanceFleetArrayInput is an input type that accepts InstanceFleetArray and InstanceFleetArrayOutput values. You can construct a concrete instance of `InstanceFleetArrayInput` via: 

InstanceFleetArray{ InstanceFleetArgs{...} }

type InstanceFleetArrayOutput added in v3.25.0 

type InstanceFleetArrayOutput struct{ *pulumi.OutputState }

func (InstanceFleetArrayOutput) ElementType added in v3.25.0 

func (InstanceFleetArrayOutput) ElementType() reflect.Type

func (InstanceFleetArrayOutput) Index added in v3.25.0 

func (o InstanceFleetArrayOutput) Index(i pulumi.IntInput) InstanceFleetOutput

func (InstanceFleetArrayOutput) ToInstanceFleetArrayOutput added in v3.25.0 

func (o InstanceFleetArrayOutput) ToInstanceFleetArrayOutput() InstanceFleetArrayOutput

func (InstanceFleetArrayOutput) ToInstanceFleetArrayOutputWithContext added in v3.25.0 

func (o InstanceFleetArrayOutput) ToInstanceFleetArrayOutputWithContext(ctx context.Context) InstanceFleetArrayOutput

type InstanceFleetInput added in v3.13.0 

type InstanceFleetInput interface {
	pulumi.Input

	ToInstanceFleetOutput() InstanceFleetOutput
	ToInstanceFleetOutputWithContext(ctx context.Context) InstanceFleetOutput
}

type InstanceFleetInstanceTypeConfig added in v3.3.0 

type InstanceFleetInstanceTypeConfig struct {
	// The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPrice *string `pulumi:"bidPrice"`
	// The bid price, as a percentage of On-Demand price, for each EC2 Spot instance as defined by `instanceType`. Expressed as a number (for example, 20 specifies 20%). If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPriceAsPercentageOfOnDemandPrice *float64 `pulumi:"bidPriceAsPercentageOfOnDemandPrice"`
	// A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.
	Configurations []InstanceFleetInstanceTypeConfigConfiguration `pulumi:"configurations"`
	// Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.
	EbsConfigs []InstanceFleetInstanceTypeConfigEbsConfig `pulumi:"ebsConfigs"`
	// An EC2 instance type, such as m4.xlarge.
	InstanceType string `pulumi:"instanceType"`
	// The number of units that a provisioned instance of this type provides toward fulfilling the target capacities defined in `emr.InstanceFleet`.
	WeightedCapacity *int `pulumi:"weightedCapacity"`
}

type InstanceFleetInstanceTypeConfigArgs added in v3.3.0 

type InstanceFleetInstanceTypeConfigArgs struct {
	// The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPrice pulumi.StringPtrInput `pulumi:"bidPrice"`
	// The bid price, as a percentage of On-Demand price, for each EC2 Spot instance as defined by `instanceType`. Expressed as a number (for example, 20 specifies 20%). If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.
	BidPriceAsPercentageOfOnDemandPrice pulumi.Float64PtrInput `pulumi:"bidPriceAsPercentageOfOnDemandPrice"`
	// A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.
	Configurations InstanceFleetInstanceTypeConfigConfigurationArrayInput `pulumi:"configurations"`
	// Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.
	EbsConfigs InstanceFleetInstanceTypeConfigEbsConfigArrayInput `pulumi:"ebsConfigs"`
	// An EC2 instance type, such as m4.xlarge.
	InstanceType pulumi.StringInput `pulumi:"instanceType"`
	// The number of units that a provisioned instance of this type provides toward fulfilling the target capacities defined in `emr.InstanceFleet`.
	WeightedCapacity pulumi.IntPtrInput `pulumi:"weightedCapacity"`
}

func (InstanceFleetInstanceTypeConfigArgs) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigArgs) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigArgs) ToInstanceFleetInstanceTypeConfigOutput added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigArgs) ToInstanceFleetInstanceTypeConfigOutput() InstanceFleetInstanceTypeConfigOutput

func (InstanceFleetInstanceTypeConfigArgs) ToInstanceFleetInstanceTypeConfigOutputWithContext added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigArgs) ToInstanceFleetInstanceTypeConfigOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigOutput

type InstanceFleetInstanceTypeConfigArray added in v3.3.0 

type InstanceFleetInstanceTypeConfigArray []InstanceFleetInstanceTypeConfigInput

func (InstanceFleetInstanceTypeConfigArray) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigArray) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigArray) ToInstanceFleetInstanceTypeConfigArrayOutput added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigArray) ToInstanceFleetInstanceTypeConfigArrayOutput() InstanceFleetInstanceTypeConfigArrayOutput

func (InstanceFleetInstanceTypeConfigArray) ToInstanceFleetInstanceTypeConfigArrayOutputWithContext added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigArray) ToInstanceFleetInstanceTypeConfigArrayOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigArrayOutput

type InstanceFleetInstanceTypeConfigArrayInput added in v3.3.0 

type InstanceFleetInstanceTypeConfigArrayInput interface {
	pulumi.Input

	ToInstanceFleetInstanceTypeConfigArrayOutput() InstanceFleetInstanceTypeConfigArrayOutput
	ToInstanceFleetInstanceTypeConfigArrayOutputWithContext(context.Context) InstanceFleetInstanceTypeConfigArrayOutput
}

InstanceFleetInstanceTypeConfigArrayInput is an input type that accepts InstanceFleetInstanceTypeConfigArray and InstanceFleetInstanceTypeConfigArrayOutput values. You can construct a concrete instance of `InstanceFleetInstanceTypeConfigArrayInput` via: 

InstanceFleetInstanceTypeConfigArray{ InstanceFleetInstanceTypeConfigArgs{...} }

type InstanceFleetInstanceTypeConfigArrayOutput added in v3.3.0 

type InstanceFleetInstanceTypeConfigArrayOutput struct{ *pulumi.OutputState }

func (InstanceFleetInstanceTypeConfigArrayOutput) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigArrayOutput) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigArrayOutput) Index added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigArrayOutput) Index(i pulumi.IntInput) InstanceFleetInstanceTypeConfigOutput

func (InstanceFleetInstanceTypeConfigArrayOutput) ToInstanceFleetInstanceTypeConfigArrayOutput added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigArrayOutput) ToInstanceFleetInstanceTypeConfigArrayOutput() InstanceFleetInstanceTypeConfigArrayOutput

func (InstanceFleetInstanceTypeConfigArrayOutput) ToInstanceFleetInstanceTypeConfigArrayOutputWithContext added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigArrayOutput) ToInstanceFleetInstanceTypeConfigArrayOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigArrayOutput

type InstanceFleetInstanceTypeConfigConfiguration added in v3.3.0 

type InstanceFleetInstanceTypeConfigConfiguration struct {
	// The classification within a configuration.
	Classification *string `pulumi:"classification"`
	// A map of properties specified within a configuration classification
	Properties map[string]interface{} `pulumi:"properties"`
}

type InstanceFleetInstanceTypeConfigConfigurationArgs added in v3.3.0 

type InstanceFleetInstanceTypeConfigConfigurationArgs struct {
	// The classification within a configuration.
	Classification pulumi.StringPtrInput `pulumi:"classification"`
	// A map of properties specified within a configuration classification
	Properties pulumi.MapInput `pulumi:"properties"`
}

func (InstanceFleetInstanceTypeConfigConfigurationArgs) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigConfigurationArgs) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigConfigurationArgs) ToInstanceFleetInstanceTypeConfigConfigurationOutput added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigConfigurationArgs) ToInstanceFleetInstanceTypeConfigConfigurationOutput() InstanceFleetInstanceTypeConfigConfigurationOutput

func (InstanceFleetInstanceTypeConfigConfigurationArgs) ToInstanceFleetInstanceTypeConfigConfigurationOutputWithContext added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigConfigurationArgs) ToInstanceFleetInstanceTypeConfigConfigurationOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigConfigurationOutput

type InstanceFleetInstanceTypeConfigConfigurationArray added in v3.3.0 

type InstanceFleetInstanceTypeConfigConfigurationArray []InstanceFleetInstanceTypeConfigConfigurationInput

func (InstanceFleetInstanceTypeConfigConfigurationArray) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigConfigurationArray) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigConfigurationArray) ToInstanceFleetInstanceTypeConfigConfigurationArrayOutput added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigConfigurationArray) ToInstanceFleetInstanceTypeConfigConfigurationArrayOutput() InstanceFleetInstanceTypeConfigConfigurationArrayOutput

func (InstanceFleetInstanceTypeConfigConfigurationArray) ToInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigConfigurationArray) ToInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigConfigurationArrayOutput

type InstanceFleetInstanceTypeConfigConfigurationArrayInput added in v3.3.0 

type InstanceFleetInstanceTypeConfigConfigurationArrayInput interface {
	pulumi.Input

	ToInstanceFleetInstanceTypeConfigConfigurationArrayOutput() InstanceFleetInstanceTypeConfigConfigurationArrayOutput
	ToInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext(context.Context) InstanceFleetInstanceTypeConfigConfigurationArrayOutput
}

InstanceFleetInstanceTypeConfigConfigurationArrayInput is an input type that accepts InstanceFleetInstanceTypeConfigConfigurationArray and InstanceFleetInstanceTypeConfigConfigurationArrayOutput values. You can construct a concrete instance of `InstanceFleetInstanceTypeConfigConfigurationArrayInput` via: 

InstanceFleetInstanceTypeConfigConfigurationArray{ InstanceFleetInstanceTypeConfigConfigurationArgs{...} }

type InstanceFleetInstanceTypeConfigConfigurationArrayOutput added in v3.3.0 

type InstanceFleetInstanceTypeConfigConfigurationArrayOutput struct{ *pulumi.OutputState }

func (InstanceFleetInstanceTypeConfigConfigurationArrayOutput) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigConfigurationArrayOutput) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigConfigurationArrayOutput) Index added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigConfigurationArrayOutput) Index(i pulumi.IntInput) InstanceFleetInstanceTypeConfigConfigurationOutput

func (InstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToInstanceFleetInstanceTypeConfigConfigurationArrayOutput added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToInstanceFleetInstanceTypeConfigConfigurationArrayOutput() InstanceFleetInstanceTypeConfigConfigurationArrayOutput

func (InstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigConfigurationArrayOutput) ToInstanceFleetInstanceTypeConfigConfigurationArrayOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigConfigurationArrayOutput

type InstanceFleetInstanceTypeConfigConfigurationInput added in v3.3.0 

type InstanceFleetInstanceTypeConfigConfigurationInput interface {
	pulumi.Input

	ToInstanceFleetInstanceTypeConfigConfigurationOutput() InstanceFleetInstanceTypeConfigConfigurationOutput
	ToInstanceFleetInstanceTypeConfigConfigurationOutputWithContext(context.Context) InstanceFleetInstanceTypeConfigConfigurationOutput
}

InstanceFleetInstanceTypeConfigConfigurationInput is an input type that accepts InstanceFleetInstanceTypeConfigConfigurationArgs and InstanceFleetInstanceTypeConfigConfigurationOutput values. You can construct a concrete instance of `InstanceFleetInstanceTypeConfigConfigurationInput` via: 

InstanceFleetInstanceTypeConfigConfigurationArgs{...}

type InstanceFleetInstanceTypeConfigConfigurationOutput added in v3.3.0 

type InstanceFleetInstanceTypeConfigConfigurationOutput struct{ *pulumi.OutputState }

func (InstanceFleetInstanceTypeConfigConfigurationOutput) Classification added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigConfigurationOutput) Classification() pulumi.StringPtrOutput

The classification within a configuration.

func (InstanceFleetInstanceTypeConfigConfigurationOutput) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigConfigurationOutput) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigConfigurationOutput) Properties added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigConfigurationOutput) Properties() pulumi.MapOutput

A map of properties specified within a configuration classification

func (InstanceFleetInstanceTypeConfigConfigurationOutput) ToInstanceFleetInstanceTypeConfigConfigurationOutput added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigConfigurationOutput) ToInstanceFleetInstanceTypeConfigConfigurationOutput() InstanceFleetInstanceTypeConfigConfigurationOutput

func (InstanceFleetInstanceTypeConfigConfigurationOutput) ToInstanceFleetInstanceTypeConfigConfigurationOutputWithContext added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigConfigurationOutput) ToInstanceFleetInstanceTypeConfigConfigurationOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigConfigurationOutput

type InstanceFleetInstanceTypeConfigEbsConfig added in v3.3.0 

type InstanceFleetInstanceTypeConfigEbsConfig struct {
	// The number of I/O operations per second (IOPS) that the volume supports
	Iops *int `pulumi:"iops"`
	// The volume size, in gibibytes (GiB).
	Size int `pulumi:"size"`
	// The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).
	Type string `pulumi:"type"`
	// The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)
	VolumesPerInstance *int `pulumi:"volumesPerInstance"`
}

type InstanceFleetInstanceTypeConfigEbsConfigArgs added in v3.3.0 

type InstanceFleetInstanceTypeConfigEbsConfigArgs struct {
	// The number of I/O operations per second (IOPS) that the volume supports
	Iops pulumi.IntPtrInput `pulumi:"iops"`
	// The volume size, in gibibytes (GiB).
	Size pulumi.IntInput `pulumi:"size"`
	// The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).
	Type pulumi.StringInput `pulumi:"type"`
	// The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)
	VolumesPerInstance pulumi.IntPtrInput `pulumi:"volumesPerInstance"`
}

func (InstanceFleetInstanceTypeConfigEbsConfigArgs) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigEbsConfigArgs) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigEbsConfigArgs) ToInstanceFleetInstanceTypeConfigEbsConfigOutput added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigEbsConfigArgs) ToInstanceFleetInstanceTypeConfigEbsConfigOutput() InstanceFleetInstanceTypeConfigEbsConfigOutput

func (InstanceFleetInstanceTypeConfigEbsConfigArgs) ToInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigEbsConfigArgs) ToInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigEbsConfigOutput

type InstanceFleetInstanceTypeConfigEbsConfigArray added in v3.3.0 

type InstanceFleetInstanceTypeConfigEbsConfigArray []InstanceFleetInstanceTypeConfigEbsConfigInput

func (InstanceFleetInstanceTypeConfigEbsConfigArray) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigEbsConfigArray) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigEbsConfigArray) ToInstanceFleetInstanceTypeConfigEbsConfigArrayOutput added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigEbsConfigArray) ToInstanceFleetInstanceTypeConfigEbsConfigArrayOutput() InstanceFleetInstanceTypeConfigEbsConfigArrayOutput

func (InstanceFleetInstanceTypeConfigEbsConfigArray) ToInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext added in v3.3.0 

func (i InstanceFleetInstanceTypeConfigEbsConfigArray) ToInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigEbsConfigArrayOutput

type InstanceFleetInstanceTypeConfigEbsConfigArrayInput added in v3.3.0 

type InstanceFleetInstanceTypeConfigEbsConfigArrayInput interface {
	pulumi.Input

	ToInstanceFleetInstanceTypeConfigEbsConfigArrayOutput() InstanceFleetInstanceTypeConfigEbsConfigArrayOutput
	ToInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext(context.Context) InstanceFleetInstanceTypeConfigEbsConfigArrayOutput
}

InstanceFleetInstanceTypeConfigEbsConfigArrayInput is an input type that accepts InstanceFleetInstanceTypeConfigEbsConfigArray and InstanceFleetInstanceTypeConfigEbsConfigArrayOutput values. You can construct a concrete instance of `InstanceFleetInstanceTypeConfigEbsConfigArrayInput` via: 

InstanceFleetInstanceTypeConfigEbsConfigArray{ InstanceFleetInstanceTypeConfigEbsConfigArgs{...} }

type InstanceFleetInstanceTypeConfigEbsConfigArrayOutput added in v3.3.0 

type InstanceFleetInstanceTypeConfigEbsConfigArrayOutput struct{ *pulumi.OutputState }

func (InstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigEbsConfigArrayOutput) Index added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigEbsConfigArrayOutput) Index(i pulumi.IntInput) InstanceFleetInstanceTypeConfigEbsConfigOutput

func (InstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToInstanceFleetInstanceTypeConfigEbsConfigArrayOutput added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToInstanceFleetInstanceTypeConfigEbsConfigArrayOutput() InstanceFleetInstanceTypeConfigEbsConfigArrayOutput

func (InstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigEbsConfigArrayOutput) ToInstanceFleetInstanceTypeConfigEbsConfigArrayOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigEbsConfigArrayOutput

type InstanceFleetInstanceTypeConfigEbsConfigInput added in v3.3.0 

type InstanceFleetInstanceTypeConfigEbsConfigInput interface {
	pulumi.Input

	ToInstanceFleetInstanceTypeConfigEbsConfigOutput() InstanceFleetInstanceTypeConfigEbsConfigOutput
	ToInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext(context.Context) InstanceFleetInstanceTypeConfigEbsConfigOutput
}

InstanceFleetInstanceTypeConfigEbsConfigInput is an input type that accepts InstanceFleetInstanceTypeConfigEbsConfigArgs and InstanceFleetInstanceTypeConfigEbsConfigOutput values. You can construct a concrete instance of `InstanceFleetInstanceTypeConfigEbsConfigInput` via: 

InstanceFleetInstanceTypeConfigEbsConfigArgs{...}

type InstanceFleetInstanceTypeConfigEbsConfigOutput added in v3.3.0 

type InstanceFleetInstanceTypeConfigEbsConfigOutput struct{ *pulumi.OutputState }

func (InstanceFleetInstanceTypeConfigEbsConfigOutput) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigEbsConfigOutput) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigEbsConfigOutput) Iops added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigEbsConfigOutput) Iops() pulumi.IntPtrOutput

The number of I/O operations per second (IOPS) that the volume supports

func (InstanceFleetInstanceTypeConfigEbsConfigOutput) Size added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigEbsConfigOutput) Size() pulumi.IntOutput

The volume size, in gibibytes (GiB).

func (InstanceFleetInstanceTypeConfigEbsConfigOutput) ToInstanceFleetInstanceTypeConfigEbsConfigOutput added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigEbsConfigOutput) ToInstanceFleetInstanceTypeConfigEbsConfigOutput() InstanceFleetInstanceTypeConfigEbsConfigOutput

func (InstanceFleetInstanceTypeConfigEbsConfigOutput) ToInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigEbsConfigOutput) ToInstanceFleetInstanceTypeConfigEbsConfigOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigEbsConfigOutput

func (InstanceFleetInstanceTypeConfigEbsConfigOutput) Type added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigEbsConfigOutput) Type() pulumi.StringOutput

The volume type. Valid options are `gp2`, `io1`, `standard` and `st1`. See [EBS Volume Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html).

func (InstanceFleetInstanceTypeConfigEbsConfigOutput) VolumesPerInstance added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigEbsConfigOutput) VolumesPerInstance() pulumi.IntPtrOutput

The number of EBS volumes with this configuration to attach to each EC2 instance in the instance group (default is 1)

type InstanceFleetInstanceTypeConfigInput added in v3.3.0 

type InstanceFleetInstanceTypeConfigInput interface {
	pulumi.Input

	ToInstanceFleetInstanceTypeConfigOutput() InstanceFleetInstanceTypeConfigOutput
	ToInstanceFleetInstanceTypeConfigOutputWithContext(context.Context) InstanceFleetInstanceTypeConfigOutput
}

InstanceFleetInstanceTypeConfigInput is an input type that accepts InstanceFleetInstanceTypeConfigArgs and InstanceFleetInstanceTypeConfigOutput values. You can construct a concrete instance of `InstanceFleetInstanceTypeConfigInput` via: 

InstanceFleetInstanceTypeConfigArgs{...}

type InstanceFleetInstanceTypeConfigOutput added in v3.3.0 

type InstanceFleetInstanceTypeConfigOutput struct{ *pulumi.OutputState }

func (InstanceFleetInstanceTypeConfigOutput) BidPrice added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigOutput) BidPrice() pulumi.StringPtrOutput

The bid price for each EC2 Spot instance type as defined by `instanceType`. Expressed in USD. If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.

func (InstanceFleetInstanceTypeConfigOutput) BidPriceAsPercentageOfOnDemandPrice added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigOutput) BidPriceAsPercentageOfOnDemandPrice() pulumi.Float64PtrOutput

The bid price, as a percentage of On-Demand price, for each EC2 Spot instance as defined by `instanceType`. Expressed as a number (for example, 20 specifies 20%). If neither `bidPrice` nor `bidPriceAsPercentageOfOnDemandPrice` is provided, `bidPriceAsPercentageOfOnDemandPrice` defaults to 100%.

func (InstanceFleetInstanceTypeConfigOutput) Configurations added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigOutput) Configurations() InstanceFleetInstanceTypeConfigConfigurationArrayOutput

A configuration classification that applies when provisioning cluster instances, which can include configurations for applications and software that run on the cluster. List of `configuration` blocks.

func (InstanceFleetInstanceTypeConfigOutput) EbsConfigs added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigOutput) EbsConfigs() InstanceFleetInstanceTypeConfigEbsConfigArrayOutput

Configuration block(s) for EBS volumes attached to each instance in the instance group. Detailed below.

func (InstanceFleetInstanceTypeConfigOutput) ElementType added in v3.3.0 

func (InstanceFleetInstanceTypeConfigOutput) ElementType() reflect.Type

func (InstanceFleetInstanceTypeConfigOutput) InstanceType added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigOutput) InstanceType() pulumi.StringOutput

An EC2 instance type, such as m4.xlarge.

func (InstanceFleetInstanceTypeConfigOutput) ToInstanceFleetInstanceTypeConfigOutput added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigOutput) ToInstanceFleetInstanceTypeConfigOutput() InstanceFleetInstanceTypeConfigOutput

func (InstanceFleetInstanceTypeConfigOutput) ToInstanceFleetInstanceTypeConfigOutputWithContext added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigOutput) ToInstanceFleetInstanceTypeConfigOutputWithContext(ctx context.Context) InstanceFleetInstanceTypeConfigOutput

func (InstanceFleetInstanceTypeConfigOutput) WeightedCapacity added in v3.3.0 

func (o InstanceFleetInstanceTypeConfigOutput) WeightedCapacity() pulumi.IntPtrOutput

The number of units that a provisioned instance of this type provides toward fulfilling the target capacities defined in `emr.InstanceFleet`.

type InstanceFleetLaunchSpecifications added in v3.3.0 

type InstanceFleetLaunchSpecifications struct {
	// Configuration block for on demand instances launch specifications
	OnDemandSpecifications []InstanceFleetLaunchSpecificationsOnDemandSpecification `pulumi:"onDemandSpecifications"`
	// Configuration block for spot instances launch specifications
	SpotSpecifications []InstanceFleetLaunchSpecificationsSpotSpecification `pulumi:"spotSpecifications"`
}

type InstanceFleetLaunchSpecificationsArgs added in v3.3.0 

type InstanceFleetLaunchSpecificationsArgs struct {
	// Configuration block for on demand instances launch specifications
	OnDemandSpecifications InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput `pulumi:"onDemandSpecifications"`
	// Configuration block for spot instances launch specifications
	SpotSpecifications InstanceFleetLaunchSpecificationsSpotSpecificationArrayInput `pulumi:"spotSpecifications"`
}

func (InstanceFleetLaunchSpecificationsArgs) ElementType added in v3.3.0 

func (InstanceFleetLaunchSpecificationsArgs) ElementType() reflect.Type

func (InstanceFleetLaunchSpecificationsArgs) ToInstanceFleetLaunchSpecificationsOutput added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsArgs) ToInstanceFleetLaunchSpecificationsOutput() InstanceFleetLaunchSpecificationsOutput

func (InstanceFleetLaunchSpecificationsArgs) ToInstanceFleetLaunchSpecificationsOutputWithContext added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsArgs) ToInstanceFleetLaunchSpecificationsOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsOutput

func (InstanceFleetLaunchSpecificationsArgs) ToInstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsArgs) ToInstanceFleetLaunchSpecificationsPtrOutput() InstanceFleetLaunchSpecificationsPtrOutput

func (InstanceFleetLaunchSpecificationsArgs) ToInstanceFleetLaunchSpecificationsPtrOutputWithContext added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsArgs) ToInstanceFleetLaunchSpecificationsPtrOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsPtrOutput

type InstanceFleetLaunchSpecificationsInput added in v3.3.0 

type InstanceFleetLaunchSpecificationsInput interface {
	pulumi.Input

	ToInstanceFleetLaunchSpecificationsOutput() InstanceFleetLaunchSpecificationsOutput
	ToInstanceFleetLaunchSpecificationsOutputWithContext(context.Context) InstanceFleetLaunchSpecificationsOutput
}

InstanceFleetLaunchSpecificationsInput is an input type that accepts InstanceFleetLaunchSpecificationsArgs and InstanceFleetLaunchSpecificationsOutput values. You can construct a concrete instance of `InstanceFleetLaunchSpecificationsInput` via: 

InstanceFleetLaunchSpecificationsArgs{...}

type InstanceFleetLaunchSpecificationsOnDemandSpecification added in v3.3.0 

type InstanceFleetLaunchSpecificationsOnDemandSpecification struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy string `pulumi:"allocationStrategy"`
}

type InstanceFleetLaunchSpecificationsOnDemandSpecificationArgs added in v3.3.0 

type InstanceFleetLaunchSpecificationsOnDemandSpecificationArgs struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy pulumi.StringInput `pulumi:"allocationStrategy"`
}

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ElementType added in v3.3.0 

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ElementType() reflect.Type

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput() InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsOnDemandSpecificationArgs) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

type InstanceFleetLaunchSpecificationsOnDemandSpecificationArray added in v3.3.0 

type InstanceFleetLaunchSpecificationsOnDemandSpecificationArray []InstanceFleetLaunchSpecificationsOnDemandSpecificationInput

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ElementType added in v3.3.0 

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ElementType() reflect.Type

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput() InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsOnDemandSpecificationArray) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

type InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput added in v3.3.0 

type InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput interface {
	pulumi.Input

	ToInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput() InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput
	ToInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext(context.Context) InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput
}

InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput is an input type that accepts InstanceFleetLaunchSpecificationsOnDemandSpecificationArray and InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput values. You can construct a concrete instance of `InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayInput` via: 

InstanceFleetLaunchSpecificationsOnDemandSpecificationArray{ InstanceFleetLaunchSpecificationsOnDemandSpecificationArgs{...} }

type InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput added in v3.3.0 

type InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput struct{ *pulumi.OutputState }

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ElementType added in v3.3.0 

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ElementType() reflect.Type

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) Index added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) Index(i pulumi.IntInput) InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput() InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

type InstanceFleetLaunchSpecificationsOnDemandSpecificationInput added in v3.3.0 

type InstanceFleetLaunchSpecificationsOnDemandSpecificationInput interface {
	pulumi.Input

	ToInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput() InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput
	ToInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext(context.Context) InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput
}

InstanceFleetLaunchSpecificationsOnDemandSpecificationInput is an input type that accepts InstanceFleetLaunchSpecificationsOnDemandSpecificationArgs and InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput values. You can construct a concrete instance of `InstanceFleetLaunchSpecificationsOnDemandSpecificationInput` via: 

InstanceFleetLaunchSpecificationsOnDemandSpecificationArgs{...}

type InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput added in v3.3.0 

type InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput struct{ *pulumi.OutputState }

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) AllocationStrategy added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) AllocationStrategy() pulumi.StringOutput

Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ElementType added in v3.3.0 

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ElementType() reflect.Type

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationOutput() InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

func (InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput) ToInstanceFleetLaunchSpecificationsOnDemandSpecificationOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsOnDemandSpecificationOutput

type InstanceFleetLaunchSpecificationsOutput added in v3.3.0 

type InstanceFleetLaunchSpecificationsOutput struct{ *pulumi.OutputState }

func (InstanceFleetLaunchSpecificationsOutput) ElementType added in v3.3.0 

func (InstanceFleetLaunchSpecificationsOutput) ElementType() reflect.Type

func (InstanceFleetLaunchSpecificationsOutput) OnDemandSpecifications added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOutput) OnDemandSpecifications() InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

Configuration block for on demand instances launch specifications

func (InstanceFleetLaunchSpecificationsOutput) SpotSpecifications added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOutput) SpotSpecifications() InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

Configuration block for spot instances launch specifications

func (InstanceFleetLaunchSpecificationsOutput) ToInstanceFleetLaunchSpecificationsOutput added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOutput) ToInstanceFleetLaunchSpecificationsOutput() InstanceFleetLaunchSpecificationsOutput

func (InstanceFleetLaunchSpecificationsOutput) ToInstanceFleetLaunchSpecificationsOutputWithContext added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOutput) ToInstanceFleetLaunchSpecificationsOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsOutput

func (InstanceFleetLaunchSpecificationsOutput) ToInstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOutput) ToInstanceFleetLaunchSpecificationsPtrOutput() InstanceFleetLaunchSpecificationsPtrOutput

func (InstanceFleetLaunchSpecificationsOutput) ToInstanceFleetLaunchSpecificationsPtrOutputWithContext added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsOutput) ToInstanceFleetLaunchSpecificationsPtrOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsPtrOutput

type InstanceFleetLaunchSpecificationsPtrInput added in v3.3.0 

type InstanceFleetLaunchSpecificationsPtrInput interface {
	pulumi.Input

	ToInstanceFleetLaunchSpecificationsPtrOutput() InstanceFleetLaunchSpecificationsPtrOutput
	ToInstanceFleetLaunchSpecificationsPtrOutputWithContext(context.Context) InstanceFleetLaunchSpecificationsPtrOutput
}

InstanceFleetLaunchSpecificationsPtrInput is an input type that accepts InstanceFleetLaunchSpecificationsArgs, InstanceFleetLaunchSpecificationsPtr and InstanceFleetLaunchSpecificationsPtrOutput values. You can construct a concrete instance of `InstanceFleetLaunchSpecificationsPtrInput` via: 

        InstanceFleetLaunchSpecificationsArgs{...}

or:

        nil

func InstanceFleetLaunchSpecificationsPtr added in v3.3.0 

func InstanceFleetLaunchSpecificationsPtr(v *InstanceFleetLaunchSpecificationsArgs) InstanceFleetLaunchSpecificationsPtrInput

type InstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

type InstanceFleetLaunchSpecificationsPtrOutput struct{ *pulumi.OutputState }

func (InstanceFleetLaunchSpecificationsPtrOutput) Elem added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsPtrOutput) Elem() InstanceFleetLaunchSpecificationsOutput

func (InstanceFleetLaunchSpecificationsPtrOutput) ElementType added in v3.3.0 

func (InstanceFleetLaunchSpecificationsPtrOutput) ElementType() reflect.Type

func (InstanceFleetLaunchSpecificationsPtrOutput) OnDemandSpecifications added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsPtrOutput) OnDemandSpecifications() InstanceFleetLaunchSpecificationsOnDemandSpecificationArrayOutput

Configuration block for on demand instances launch specifications

func (InstanceFleetLaunchSpecificationsPtrOutput) SpotSpecifications added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsPtrOutput) SpotSpecifications() InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

Configuration block for spot instances launch specifications

func (InstanceFleetLaunchSpecificationsPtrOutput) ToInstanceFleetLaunchSpecificationsPtrOutput added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsPtrOutput) ToInstanceFleetLaunchSpecificationsPtrOutput() InstanceFleetLaunchSpecificationsPtrOutput

func (InstanceFleetLaunchSpecificationsPtrOutput) ToInstanceFleetLaunchSpecificationsPtrOutputWithContext added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsPtrOutput) ToInstanceFleetLaunchSpecificationsPtrOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsPtrOutput

type InstanceFleetLaunchSpecificationsSpotSpecification added in v3.3.0 

type InstanceFleetLaunchSpecificationsSpotSpecification struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy string `pulumi:"allocationStrategy"`
	// The defined duration for Spot instances (also known as Spot blocks) in minutes. When specified, the Spot instance does not terminate before the defined duration expires, and defined duration pricing for Spot instances applies. Valid values are 60, 120, 180, 240, 300, or 360. The duration period starts as soon as a Spot instance receives its instance ID. At the end of the duration, Amazon EC2 marks the Spot instance for termination and provides a Spot instance termination notice, which gives the instance a two-minute warning before it terminates.
	BlockDurationMinutes *int `pulumi:"blockDurationMinutes"`
	// The action to take when TargetSpotCapacity has not been fulfilled when the TimeoutDurationMinutes has expired; that is, when all Spot instances could not be provisioned within the Spot provisioning timeout. Valid values are `TERMINATE_CLUSTER` and `SWITCH_TO_ON_DEMAND`. SWITCH_TO_ON_DEMAND specifies that if no Spot instances are available, On-Demand Instances should be provisioned to fulfill any remaining Spot capacity.
	TimeoutAction string `pulumi:"timeoutAction"`
	// The spot provisioning timeout period in minutes. If Spot instances are not provisioned within this time period, the TimeOutAction is taken. Minimum value is 5 and maximum value is 1440. The timeout applies only during initial provisioning, when the cluster is first created.
	TimeoutDurationMinutes int `pulumi:"timeoutDurationMinutes"`
}

type InstanceFleetLaunchSpecificationsSpotSpecificationArgs added in v3.3.0 

type InstanceFleetLaunchSpecificationsSpotSpecificationArgs struct {
	// Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.
	AllocationStrategy pulumi.StringInput `pulumi:"allocationStrategy"`
	// The defined duration for Spot instances (also known as Spot blocks) in minutes. When specified, the Spot instance does not terminate before the defined duration expires, and defined duration pricing for Spot instances applies. Valid values are 60, 120, 180, 240, 300, or 360. The duration period starts as soon as a Spot instance receives its instance ID. At the end of the duration, Amazon EC2 marks the Spot instance for termination and provides a Spot instance termination notice, which gives the instance a two-minute warning before it terminates.
	BlockDurationMinutes pulumi.IntPtrInput `pulumi:"blockDurationMinutes"`
	// The action to take when TargetSpotCapacity has not been fulfilled when the TimeoutDurationMinutes has expired; that is, when all Spot instances could not be provisioned within the Spot provisioning timeout. Valid values are `TERMINATE_CLUSTER` and `SWITCH_TO_ON_DEMAND`. SWITCH_TO_ON_DEMAND specifies that if no Spot instances are available, On-Demand Instances should be provisioned to fulfill any remaining Spot capacity.
	TimeoutAction pulumi.StringInput `pulumi:"timeoutAction"`
	// The spot provisioning timeout period in minutes. If Spot instances are not provisioned within this time period, the TimeOutAction is taken. Minimum value is 5 and maximum value is 1440. The timeout applies only during initial provisioning, when the cluster is first created.
	TimeoutDurationMinutes pulumi.IntInput `pulumi:"timeoutDurationMinutes"`
}

func (InstanceFleetLaunchSpecificationsSpotSpecificationArgs) ElementType added in v3.3.0 

func (InstanceFleetLaunchSpecificationsSpotSpecificationArgs) ElementType() reflect.Type

func (InstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToInstanceFleetLaunchSpecificationsSpotSpecificationOutput added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToInstanceFleetLaunchSpecificationsSpotSpecificationOutput() InstanceFleetLaunchSpecificationsSpotSpecificationOutput

func (InstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsSpotSpecificationArgs) ToInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsSpotSpecificationOutput

type InstanceFleetLaunchSpecificationsSpotSpecificationArray added in v3.3.0 

type InstanceFleetLaunchSpecificationsSpotSpecificationArray []InstanceFleetLaunchSpecificationsSpotSpecificationInput

func (InstanceFleetLaunchSpecificationsSpotSpecificationArray) ElementType added in v3.3.0 

func (InstanceFleetLaunchSpecificationsSpotSpecificationArray) ElementType() reflect.Type

func (InstanceFleetLaunchSpecificationsSpotSpecificationArray) ToInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsSpotSpecificationArray) ToInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput() InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

func (InstanceFleetLaunchSpecificationsSpotSpecificationArray) ToInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext added in v3.3.0 

func (i InstanceFleetLaunchSpecificationsSpotSpecificationArray) ToInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

type InstanceFleetLaunchSpecificationsSpotSpecificationArrayInput added in v3.3.0 

type InstanceFleetLaunchSpecificationsSpotSpecificationArrayInput interface {
	pulumi.Input

	ToInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput() InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput
	ToInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext(context.Context) InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput
}

InstanceFleetLaunchSpecificationsSpotSpecificationArrayInput is an input type that accepts InstanceFleetLaunchSpecificationsSpotSpecificationArray and InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput values. You can construct a concrete instance of `InstanceFleetLaunchSpecificationsSpotSpecificationArrayInput` via: 

InstanceFleetLaunchSpecificationsSpotSpecificationArray{ InstanceFleetLaunchSpecificationsSpotSpecificationArgs{...} }

type InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput added in v3.3.0 

type InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput struct{ *pulumi.OutputState }

func (InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ElementType added in v3.3.0 

func (InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ElementType() reflect.Type

func (InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) Index added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) Index(i pulumi.IntInput) InstanceFleetLaunchSpecificationsSpotSpecificationOutput

func (InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput() InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

func (InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput) ToInstanceFleetLaunchSpecificationsSpotSpecificationArrayOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsSpotSpecificationArrayOutput

type InstanceFleetLaunchSpecificationsSpotSpecificationInput added in v3.3.0 

type InstanceFleetLaunchSpecificationsSpotSpecificationInput interface {
	pulumi.Input

	ToInstanceFleetLaunchSpecificationsSpotSpecificationOutput() InstanceFleetLaunchSpecificationsSpotSpecificationOutput
	ToInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext(context.Context) InstanceFleetLaunchSpecificationsSpotSpecificationOutput
}

InstanceFleetLaunchSpecificationsSpotSpecificationInput is an input type that accepts InstanceFleetLaunchSpecificationsSpotSpecificationArgs and InstanceFleetLaunchSpecificationsSpotSpecificationOutput values. You can construct a concrete instance of `InstanceFleetLaunchSpecificationsSpotSpecificationInput` via: 

InstanceFleetLaunchSpecificationsSpotSpecificationArgs{...}

type InstanceFleetLaunchSpecificationsSpotSpecificationOutput added in v3.3.0 

type InstanceFleetLaunchSpecificationsSpotSpecificationOutput struct{ *pulumi.OutputState }

func (InstanceFleetLaunchSpecificationsSpotSpecificationOutput) AllocationStrategy added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsSpotSpecificationOutput) AllocationStrategy() pulumi.StringOutput

Specifies the strategy to use in launching Spot instance fleets. Currently, the only option is `capacity-optimized` (the default), which launches instances from Spot instance pools with optimal capacity for the number of instances that are launching.

func (InstanceFleetLaunchSpecificationsSpotSpecificationOutput) BlockDurationMinutes added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsSpotSpecificationOutput) BlockDurationMinutes() pulumi.IntPtrOutput

The defined duration for Spot instances (also known as Spot blocks) in minutes. When specified, the Spot instance does not terminate before the defined duration expires, and defined duration pricing for Spot instances applies. Valid values are 60, 120, 180, 240, 300, or 360. The duration period starts as soon as a Spot instance receives its instance ID. At the end of the duration, Amazon EC2 marks the Spot instance for termination and provides a Spot instance termination notice, which gives the instance a two-minute warning before it terminates.

func (InstanceFleetLaunchSpecificationsSpotSpecificationOutput) ElementType added in v3.3.0 

func (InstanceFleetLaunchSpecificationsSpotSpecificationOutput) ElementType() reflect.Type

func (InstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutAction added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutAction() pulumi.StringOutput

The action to take when TargetSpotCapacity has not been fulfilled when the TimeoutDurationMinutes has expired; that is, when all Spot instances could not be provisioned within the Spot provisioning timeout. Valid values are `TERMINATE_CLUSTER` and `SWITCH_TO_ON_DEMAND`. SWITCH_TO_ON_DEMAND specifies that if no Spot instances are available, On-Demand Instances should be provisioned to fulfill any remaining Spot capacity.

func (InstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutDurationMinutes added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsSpotSpecificationOutput) TimeoutDurationMinutes() pulumi.IntOutput

The spot provisioning timeout period in minutes. If Spot instances are not provisioned within this time period, the TimeOutAction is taken. Minimum value is 5 and maximum value is 1440. The timeout applies only during initial provisioning, when the cluster is first created.

func (InstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToInstanceFleetLaunchSpecificationsSpotSpecificationOutput added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToInstanceFleetLaunchSpecificationsSpotSpecificationOutput() InstanceFleetLaunchSpecificationsSpotSpecificationOutput

func (InstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext added in v3.3.0 

func (o InstanceFleetLaunchSpecificationsSpotSpecificationOutput) ToInstanceFleetLaunchSpecificationsSpotSpecificationOutputWithContext(ctx context.Context) InstanceFleetLaunchSpecificationsSpotSpecificationOutput

type InstanceFleetMap added in v3.25.0 

type InstanceFleetMap map[string]InstanceFleetInput

func (InstanceFleetMap) ElementType added in v3.25.0 

func (InstanceFleetMap) ElementType() reflect.Type

func (InstanceFleetMap) ToInstanceFleetMapOutput added in v3.25.0 

func (i InstanceFleetMap) ToInstanceFleetMapOutput() InstanceFleetMapOutput

func (InstanceFleetMap) ToInstanceFleetMapOutputWithContext added in v3.25.0 

func (i InstanceFleetMap) ToInstanceFleetMapOutputWithContext(ctx context.Context) InstanceFleetMapOutput

type InstanceFleetMapInput added in v3.25.0 

type InstanceFleetMapInput interface {
	pulumi.Input

	ToInstanceFleetMapOutput() InstanceFleetMapOutput
	ToInstanceFleetMapOutputWithContext(context.Context) InstanceFleetMapOutput
}

InstanceFleetMapInput is an input type that accepts InstanceFleetMap and InstanceFleetMapOutput values. You can construct a concrete instance of `InstanceFleetMapInput` via: 

InstanceFleetMap{ "key": InstanceFleetArgs{...} }

type InstanceFleetMapOutput added in v3.25.0 

type InstanceFleetMapOutput struct{ *pulumi.OutputState }

func (InstanceFleetMapOutput) ElementType added in v3.25.0 

func (InstanceFleetMapOutput) ElementType() reflect.Type

func (InstanceFleetMapOutput) MapIndex added in v3.25.0 

func (o InstanceFleetMapOutput) MapIndex(k pulumi.StringInput) InstanceFleetOutput

func (InstanceFleetMapOutput) ToInstanceFleetMapOutput added in v3.25.0 

func (o InstanceFleetMapOutput) ToInstanceFleetMapOutput() InstanceFleetMapOutput

func (InstanceFleetMapOutput) ToInstanceFleetMapOutputWithContext added in v3.25.0 

func (o InstanceFleetMapOutput) ToInstanceFleetMapOutputWithContext(ctx context.Context) InstanceFleetMapOutput

type InstanceFleetOutput added in v3.13.0 

type InstanceFleetOutput struct {
	*pulumi.OutputState
}

func (InstanceFleetOutput) ElementType added in v3.13.0 

func (InstanceFleetOutput) ElementType() reflect.Type

func (InstanceFleetOutput) ToInstanceFleetOutput added in v3.13.0 

func (o InstanceFleetOutput) ToInstanceFleetOutput() InstanceFleetOutput

func (InstanceFleetOutput) ToInstanceFleetOutputWithContext added in v3.13.0 

func (o InstanceFleetOutput) ToInstanceFleetOutputWithContext(ctx context.Context) InstanceFleetOutput

func (InstanceFleetOutput) ToInstanceFleetPtrOutput added in v3.25.0 

func (o InstanceFleetOutput) ToInstanceFleetPtrOutput() InstanceFleetPtrOutput

func (InstanceFleetOutput) ToInstanceFleetPtrOutputWithContext added in v3.25.0 

func (o InstanceFleetOutput) ToInstanceFleetPtrOutputWithContext(ctx context.Context) InstanceFleetPtrOutput

type InstanceFleetPtrInput added in v3.25.0 

type InstanceFleetPtrInput interface {
	pulumi.Input

	ToInstanceFleetPtrOutput() InstanceFleetPtrOutput
	ToInstanceFleetPtrOutputWithContext(ctx context.Context) InstanceFleetPtrOutput
}

type InstanceFleetPtrOutput added in v3.25.0 

type InstanceFleetPtrOutput struct {
	*pulumi.OutputState
}

func (InstanceFleetPtrOutput) ElementType added in v3.25.0 

func (InstanceFleetPtrOutput) ElementType() reflect.Type

func (InstanceFleetPtrOutput) ToInstanceFleetPtrOutput added in v3.25.0 

func (o InstanceFleetPtrOutput) ToInstanceFleetPtrOutput() InstanceFleetPtrOutput

func (InstanceFleetPtrOutput) ToInstanceFleetPtrOutputWithContext added in v3.25.0 

func (o InstanceFleetPtrOutput) ToInstanceFleetPtrOutputWithContext(ctx context.Context) InstanceFleetPtrOutput

type InstanceFleetState added in v3.3.0 

type InstanceFleetState struct {
	// ID of the EMR Cluster to attach to. Changing this forces a new resource to be created.
	ClusterId pulumi.StringPtrInput
	// Configuration block for instance fleet
	InstanceTypeConfigs InstanceFleetInstanceTypeConfigArrayInput
	// Configuration block for launch specification
	LaunchSpecifications InstanceFleetLaunchSpecificationsPtrInput
	// Friendly name given to the instance fleet.
	Name                        pulumi.StringPtrInput
	ProvisionedOnDemandCapacity pulumi.IntPtrInput
	ProvisionedSpotCapacity     pulumi.IntPtrInput
	// The target capacity of On-Demand units for the instance fleet, which determines how many On-Demand instances to provision.
	TargetOnDemandCapacity pulumi.IntPtrInput
	// The target capacity of Spot units for the instance fleet, which determines how many Spot instances to provision.
	TargetSpotCapacity pulumi.IntPtrInput
}

func (InstanceFleetState) ElementType added in v3.3.0 

func (InstanceFleetState) ElementType() reflect.Type

type InstanceGroup 

type InstanceGroup struct {
	pulumi.CustomResourceState

	// The autoscaling policy document. This is a JSON formatted string. See [EMR Auto Scaling](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-automatic-scaling.html)
	AutoscalingPolicy pulumi.StringPtrOutput `pulumi:"autoscalingPolicy"`
	// If set, the bid price for each EC2 instance in the instance group, expressed in USD. By setting this attribute, the instance group is being declared as a Spot Instance, and will implicitly create a Spot request. Leave this blank to use On-Demand Instances.
	BidPrice pulumi.StringPtrOutput `pulumi:"bidPrice"`
	// ID of the EMR Cluster to attach to. Changing this forces a new resource to be created.
	ClusterId pulumi.StringOutput `pulumi:"clusterId"`
	// A JSON string for supplying list of configurations specific to the EMR instance group. Note that this can only be changed when using EMR release 5.21 or later.
	ConfigurationsJson pulumi.StringPtrOutput `pulumi:"configurationsJson"`
	// One or more `ebsConfig` blocks as defined below. Changing this forces a new resource to be created.
	EbsConfigs InstanceGroupEbsConfigArrayOutput `pulumi:"ebsConfigs"`
	// Indicates whether an Amazon EBS volume is EBS-optimized. Changing this forces a new resource to be created.
	EbsOptimized pulumi.BoolPtrOutput `pulumi:"ebsOptimized"`
	// target number of instances for the instance group. defaults to 0.
	InstanceCount pulumi.IntPtrOutput `pulumi:"instanceCount"`
	// The EC2 instance type for all instances in the instance group. Changing this forces a new resource to be created.
	InstanceType pulumi.StringOutput `pulumi:"instanceType"`
	// Human friendly name given to the instance group. Changing this forces a new resource to be created.
	Name                 pulumi.StringOutput `pulumi:"name"`
	RunningInstanceCount pulumi.IntOutput    `pulumi:"runningInstanceCount"`
	Status               pulumi.StringOutput `pulumi:"status"`
}

Provides an Elastic MapReduce Cluster Instance Group configuration. See [Amazon Elastic MapReduce Documentation](https://aws.amazon.com/documentation/emr/) for more information.

> **NOTE:** At this time, Instance Groups cannot be destroyed through the API nor web interface. Instance Groups are destroyed when the EMR Cluster is destroyed. this provider will resize any Instance Group to zero when destroying the resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/emr"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := emr.NewInstanceGroup(ctx, "task", &emr.InstanceGroupArgs{
			ClusterId:     pulumi.Any(aws_emr_cluster.Tf - test - cluster.Id),
			InstanceCount: pulumi.Int(1),
			InstanceType:  pulumi.String("m5.xlarge"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

EMR task instance group can be imported using their EMR Cluster id and Instance Group id separated by a forward-slash `/`, e.g.

```sh 

$ pulumi import aws:emr/instanceGroup:InstanceGroup task_greoup j-123456ABCDEF/ig-15EK4O09RZLNR

```

func GetInstanceGroup 

func GetInstanceGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *InstanceGroupState, opts ...pulumi.ResourceOption) (*InstanceGroup, error)

GetInstanceGroup gets an existing InstanceGroup resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewInstanceGroup 

func NewInstanceGroup(ctx *pulumi.Context,
	name string, args *InstanceGroupArgs, opts ...pulumi.ResourceOption) (*InstanceGroup, error)

NewInstanceGroup registers a new resource with the given unique name, arguments, and options.

func (*InstanceGroup) ElementType added in v3.13.0 

func (*InstanceGroup) ElementType() reflect.Type

func (*InstanceGroup) ToInstanceGroupOutput added in v3.13.0 

func (i *InstanceGroup) ToInstanceGroupOutput() InstanceGroupOutput

func (*InstanceGroup) ToInstanceGroupOutputWithContext added in v3.13.0 

func (i *InstanceGroup) ToInstanceGroupOutputWithContext(ctx context.Context) InstanceGroupOutput

func (*InstanceGroup) ToInstanceGroupPtrOutput added in v3.25.0 

func (i *InstanceGroup) ToInstanceGroupPtrOutput() InstanceGroupPtrOutput

func (*InstanceGroup) ToInstanceGroupPtrOutputWithContext added in v3.25.0 

func (i *InstanceGroup) ToInstanceGroupPtrOutputWithContext(ctx context.Context) InstanceGroupPtrOutput

type InstanceGroupArgs 

type InstanceGroupArgs struct {
	// The autoscaling policy document. This is a JSON formatted string. See [EMR Auto Scaling](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-automatic-scaling.html)
	AutoscalingPolicy pulumi.StringPtrInput
	// If set, the bid price for each EC2 instance in the instance group, expressed in USD. By setting this attribute, the instance group is being declared as a Spot Instance, and will implicitly create a Spot request. Leave this blank to use On-Demand Instances.
	BidPrice pulumi.StringPtrInput
	// ID of the EMR Cluster to attach to. Changing this forces a new resource to be created.
	ClusterId pulumi.StringInput
	// A JSON string for supplying list of configurations specific to the EMR instance group. Note that this can only be changed when using EMR release 5.21 or later.
	ConfigurationsJson pulumi.StringPtrInput
	// One or more `ebsConfig` blocks as defined below. Changing this forces a new resource to be created.
	EbsConfigs InstanceGroupEbsConfigArrayInput
	// Indicates whether an Amazon EBS volume is EBS-optimized. Changing this forces a new resource to be created.
	EbsOptimized pulumi.BoolPtrInput
	// target number of instances for the instance group. defaults to 0.
	InstanceCount pulumi.IntPtrInput
	// The EC2 instance type for all instances in the instance group. Changing this forces a new resource to be created.
	InstanceType pulumi.StringInput
	// Human friendly name given to the instance group. Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
}

The set of arguments for constructing a InstanceGroup resource.

func (InstanceGroupArgs) ElementType 

func (InstanceGroupArgs) ElementType() reflect.Type

type InstanceGroupArray added in v3.25.0 

type InstanceGroupArray []InstanceGroupInput

func (InstanceGroupArray) ElementType added in v3.25.0 

func (InstanceGroupArray) ElementType() reflect.Type

func (InstanceGroupArray) ToInstanceGroupArrayOutput added in v3.25.0 

func (i InstanceGroupArray) ToInstanceGroupArrayOutput() InstanceGroupArrayOutput

func (InstanceGroupArray) ToInstanceGroupArrayOutputWithContext added in v3.25.0 

func (i InstanceGroupArray) ToInstanceGroupArrayOutputWithContext(ctx context.Context) InstanceGroupArrayOutput

type InstanceGroupArrayInput added in v3.25.0 

type InstanceGroupArrayInput interface {
	pulumi.Input

	ToInstanceGroupArrayOutput() InstanceGroupArrayOutput
	ToInstanceGroupArrayOutputWithContext(context.Context) InstanceGroupArrayOutput
}

InstanceGroupArrayInput is an input type that accepts InstanceGroupArray and InstanceGroupArrayOutput values. You can construct a concrete instance of `InstanceGroupArrayInput` via: 

InstanceGroupArray{ InstanceGroupArgs{...} }

type InstanceGroupArrayOutput added in v3.25.0 

type InstanceGroupArrayOutput struct{ *pulumi.OutputState }

func (InstanceGroupArrayOutput) ElementType added in v3.25.0 

func (InstanceGroupArrayOutput) ElementType() reflect.Type

func (InstanceGroupArrayOutput) Index added in v3.25.0 

func (o InstanceGroupArrayOutput) Index(i pulumi.IntInput) InstanceGroupOutput

func (InstanceGroupArrayOutput) ToInstanceGroupArrayOutput added in v3.25.0 

func (o InstanceGroupArrayOutput) ToInstanceGroupArrayOutput() InstanceGroupArrayOutput

func (InstanceGroupArrayOutput) ToInstanceGroupArrayOutputWithContext added in v3.25.0 

func (o InstanceGroupArrayOutput) ToInstanceGroupArrayOutputWithContext(ctx context.Context) InstanceGroupArrayOutput

type InstanceGroupEbsConfig 

type InstanceGroupEbsConfig struct {
	// The number of I/O operations per second (IOPS) that the volume supports.
	Iops *int `pulumi:"iops"`
	// The volume size, in gibibytes (GiB). This can be a number from 1 - 1024. If the volume type is EBS-optimized, the minimum value is 10.
	Size int `pulumi:"size"`
	// The volume type. Valid options are 'gp2', 'io1' and 'standard'.
	Type string `pulumi:"type"`
	// The number of EBS Volumes to attach per instance.
	VolumesPerInstance *int `pulumi:"volumesPerInstance"`
}

type InstanceGroupEbsConfigArgs 

type InstanceGroupEbsConfigArgs struct {
	// The number of I/O operations per second (IOPS) that the volume supports.
	Iops pulumi.IntPtrInput `pulumi:"iops"`
	// The volume size, in gibibytes (GiB). This can be a number from 1 - 1024. If the volume type is EBS-optimized, the minimum value is 10.
	Size pulumi.IntInput `pulumi:"size"`
	// The volume type. Valid options are 'gp2', 'io1' and 'standard'.
	Type pulumi.StringInput `pulumi:"type"`
	// The number of EBS Volumes to attach per instance.
	VolumesPerInstance pulumi.IntPtrInput `pulumi:"volumesPerInstance"`
}

func (InstanceGroupEbsConfigArgs) ElementType 

func (InstanceGroupEbsConfigArgs) ElementType() reflect.Type

func (InstanceGroupEbsConfigArgs) ToInstanceGroupEbsConfigOutput 

func (i InstanceGroupEbsConfigArgs) ToInstanceGroupEbsConfigOutput() InstanceGroupEbsConfigOutput

func (InstanceGroupEbsConfigArgs) ToInstanceGroupEbsConfigOutputWithContext 

func (i InstanceGroupEbsConfigArgs) ToInstanceGroupEbsConfigOutputWithContext(ctx context.Context) InstanceGroupEbsConfigOutput

type InstanceGroupEbsConfigArray 

type InstanceGroupEbsConfigArray []InstanceGroupEbsConfigInput

func (InstanceGroupEbsConfigArray) ElementType 

func (InstanceGroupEbsConfigArray) ElementType() reflect.Type

func (InstanceGroupEbsConfigArray) ToInstanceGroupEbsConfigArrayOutput 

func (i InstanceGroupEbsConfigArray) ToInstanceGroupEbsConfigArrayOutput() InstanceGroupEbsConfigArrayOutput

func (InstanceGroupEbsConfigArray) ToInstanceGroupEbsConfigArrayOutputWithContext 

func (i InstanceGroupEbsConfigArray) ToInstanceGroupEbsConfigArrayOutputWithContext(ctx context.Context) InstanceGroupEbsConfigArrayOutput

type InstanceGroupEbsConfigArrayInput 

type InstanceGroupEbsConfigArrayInput interface {
	pulumi.Input

	ToInstanceGroupEbsConfigArrayOutput() InstanceGroupEbsConfigArrayOutput
	ToInstanceGroupEbsConfigArrayOutputWithContext(context.Context) InstanceGroupEbsConfigArrayOutput
}

InstanceGroupEbsConfigArrayInput is an input type that accepts InstanceGroupEbsConfigArray and InstanceGroupEbsConfigArrayOutput values. You can construct a concrete instance of `InstanceGroupEbsConfigArrayInput` via: 

InstanceGroupEbsConfigArray{ InstanceGroupEbsConfigArgs{...} }

type InstanceGroupEbsConfigArrayOutput 

type InstanceGroupEbsConfigArrayOutput struct{ *pulumi.OutputState }

func (InstanceGroupEbsConfigArrayOutput) ElementType 

func (InstanceGroupEbsConfigArrayOutput) ElementType() reflect.Type

func (InstanceGroupEbsConfigArrayOutput) Index 

func (o InstanceGroupEbsConfigArrayOutput) Index(i pulumi.IntInput) InstanceGroupEbsConfigOutput

func (InstanceGroupEbsConfigArrayOutput) ToInstanceGroupEbsConfigArrayOutput 

func (o InstanceGroupEbsConfigArrayOutput) ToInstanceGroupEbsConfigArrayOutput() InstanceGroupEbsConfigArrayOutput

func (InstanceGroupEbsConfigArrayOutput) ToInstanceGroupEbsConfigArrayOutputWithContext 

func (o InstanceGroupEbsConfigArrayOutput) ToInstanceGroupEbsConfigArrayOutputWithContext(ctx context.Context) InstanceGroupEbsConfigArrayOutput

type InstanceGroupEbsConfigInput 

type InstanceGroupEbsConfigInput interface {
	pulumi.Input

	ToInstanceGroupEbsConfigOutput() InstanceGroupEbsConfigOutput
	ToInstanceGroupEbsConfigOutputWithContext(context.Context) InstanceGroupEbsConfigOutput
}

InstanceGroupEbsConfigInput is an input type that accepts InstanceGroupEbsConfigArgs and InstanceGroupEbsConfigOutput values. You can construct a concrete instance of `InstanceGroupEbsConfigInput` via: 

InstanceGroupEbsConfigArgs{...}

type InstanceGroupEbsConfigOutput 

type InstanceGroupEbsConfigOutput struct{ *pulumi.OutputState }

func (InstanceGroupEbsConfigOutput) ElementType 

func (InstanceGroupEbsConfigOutput) ElementType() reflect.Type

func (InstanceGroupEbsConfigOutput) Iops 

func (o InstanceGroupEbsConfigOutput) Iops() pulumi.IntPtrOutput

The number of I/O operations per second (IOPS) that the volume supports.

func (InstanceGroupEbsConfigOutput) Size 

func (o InstanceGroupEbsConfigOutput) Size() pulumi.IntOutput

The volume size, in gibibytes (GiB). This can be a number from 1 - 1024. If the volume type is EBS-optimized, the minimum value is 10.

func (InstanceGroupEbsConfigOutput) ToInstanceGroupEbsConfigOutput 

func (o InstanceGroupEbsConfigOutput) ToInstanceGroupEbsConfigOutput() InstanceGroupEbsConfigOutput

func (InstanceGroupEbsConfigOutput) ToInstanceGroupEbsConfigOutputWithContext 

func (o InstanceGroupEbsConfigOutput) ToInstanceGroupEbsConfigOutputWithContext(ctx context.Context) InstanceGroupEbsConfigOutput

func (InstanceGroupEbsConfigOutput) Type 

func (o InstanceGroupEbsConfigOutput) Type() pulumi.StringOutput

The volume type. Valid options are 'gp2', 'io1' and 'standard'.

func (InstanceGroupEbsConfigOutput) VolumesPerInstance 

func (o InstanceGroupEbsConfigOutput) VolumesPerInstance() pulumi.IntPtrOutput

The number of EBS Volumes to attach per instance.

type InstanceGroupInput added in v3.13.0 

type InstanceGroupInput interface {
	pulumi.Input

	ToInstanceGroupOutput() InstanceGroupOutput
	ToInstanceGroupOutputWithContext(ctx context.Context) InstanceGroupOutput
}

type InstanceGroupMap added in v3.25.0 

type InstanceGroupMap map[string]InstanceGroupInput

func (InstanceGroupMap) ElementType added in v3.25.0 

func (InstanceGroupMap) ElementType() reflect.Type

func (InstanceGroupMap) ToInstanceGroupMapOutput added in v3.25.0 

func (i InstanceGroupMap) ToInstanceGroupMapOutput() InstanceGroupMapOutput

func (InstanceGroupMap) ToInstanceGroupMapOutputWithContext added in v3.25.0 

func (i InstanceGroupMap) ToInstanceGroupMapOutputWithContext(ctx context.Context) InstanceGroupMapOutput

type InstanceGroupMapInput added in v3.25.0 

type InstanceGroupMapInput interface {
	pulumi.Input

	ToInstanceGroupMapOutput() InstanceGroupMapOutput
	ToInstanceGroupMapOutputWithContext(context.Context) InstanceGroupMapOutput
}

InstanceGroupMapInput is an input type that accepts InstanceGroupMap and InstanceGroupMapOutput values. You can construct a concrete instance of `InstanceGroupMapInput` via: 

InstanceGroupMap{ "key": InstanceGroupArgs{...} }

type InstanceGroupMapOutput added in v3.25.0 

type InstanceGroupMapOutput struct{ *pulumi.OutputState }

func (InstanceGroupMapOutput) ElementType added in v3.25.0 

func (InstanceGroupMapOutput) ElementType() reflect.Type

func (InstanceGroupMapOutput) MapIndex added in v3.25.0 

func (o InstanceGroupMapOutput) MapIndex(k pulumi.StringInput) InstanceGroupOutput

func (InstanceGroupMapOutput) ToInstanceGroupMapOutput added in v3.25.0 

func (o InstanceGroupMapOutput) ToInstanceGroupMapOutput() InstanceGroupMapOutput

func (InstanceGroupMapOutput) ToInstanceGroupMapOutputWithContext added in v3.25.0 

func (o InstanceGroupMapOutput) ToInstanceGroupMapOutputWithContext(ctx context.Context) InstanceGroupMapOutput

type InstanceGroupOutput added in v3.13.0 

type InstanceGroupOutput struct {
	*pulumi.OutputState
}

func (InstanceGroupOutput) ElementType added in v3.13.0 

func (InstanceGroupOutput) ElementType() reflect.Type

func (InstanceGroupOutput) ToInstanceGroupOutput added in v3.13.0 

func (o InstanceGroupOutput) ToInstanceGroupOutput() InstanceGroupOutput

func (InstanceGroupOutput) ToInstanceGroupOutputWithContext added in v3.13.0 

func (o InstanceGroupOutput) ToInstanceGroupOutputWithContext(ctx context.Context) InstanceGroupOutput

func (InstanceGroupOutput) ToInstanceGroupPtrOutput added in v3.25.0 

func (o InstanceGroupOutput) ToInstanceGroupPtrOutput() InstanceGroupPtrOutput

func (InstanceGroupOutput) ToInstanceGroupPtrOutputWithContext added in v3.25.0 

func (o InstanceGroupOutput) ToInstanceGroupPtrOutputWithContext(ctx context.Context) InstanceGroupPtrOutput

type InstanceGroupPtrInput added in v3.25.0 

type InstanceGroupPtrInput interface {
	pulumi.Input

	ToInstanceGroupPtrOutput() InstanceGroupPtrOutput
	ToInstanceGroupPtrOutputWithContext(ctx context.Context) InstanceGroupPtrOutput
}

type InstanceGroupPtrOutput added in v3.25.0 

type InstanceGroupPtrOutput struct {
	*pulumi.OutputState
}

func (InstanceGroupPtrOutput) ElementType added in v3.25.0 

func (InstanceGroupPtrOutput) ElementType() reflect.Type

func (InstanceGroupPtrOutput) ToInstanceGroupPtrOutput added in v3.25.0 

func (o InstanceGroupPtrOutput) ToInstanceGroupPtrOutput() InstanceGroupPtrOutput

func (InstanceGroupPtrOutput) ToInstanceGroupPtrOutputWithContext added in v3.25.0 

func (o InstanceGroupPtrOutput) ToInstanceGroupPtrOutputWithContext(ctx context.Context) InstanceGroupPtrOutput

type InstanceGroupState 

type InstanceGroupState struct {
	// The autoscaling policy document. This is a JSON formatted string. See [EMR Auto Scaling](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-automatic-scaling.html)
	AutoscalingPolicy pulumi.StringPtrInput
	// If set, the bid price for each EC2 instance in the instance group, expressed in USD. By setting this attribute, the instance group is being declared as a Spot Instance, and will implicitly create a Spot request. Leave this blank to use On-Demand Instances.
	BidPrice pulumi.StringPtrInput
	// ID of the EMR Cluster to attach to. Changing this forces a new resource to be created.
	ClusterId pulumi.StringPtrInput
	// A JSON string for supplying list of configurations specific to the EMR instance group. Note that this can only be changed when using EMR release 5.21 or later.
	ConfigurationsJson pulumi.StringPtrInput
	// One or more `ebsConfig` blocks as defined below. Changing this forces a new resource to be created.
	EbsConfigs InstanceGroupEbsConfigArrayInput
	// Indicates whether an Amazon EBS volume is EBS-optimized. Changing this forces a new resource to be created.
	EbsOptimized pulumi.BoolPtrInput
	// target number of instances for the instance group. defaults to 0.
	InstanceCount pulumi.IntPtrInput
	// The EC2 instance type for all instances in the instance group. Changing this forces a new resource to be created.
	InstanceType pulumi.StringPtrInput
	// Human friendly name given to the instance group. Changing this forces a new resource to be created.
	Name                 pulumi.StringPtrInput
	RunningInstanceCount pulumi.IntPtrInput
	Status               pulumi.StringPtrInput
}

func (InstanceGroupState) ElementType 

func (InstanceGroupState) ElementType() reflect.Type

type ManagedScalingPolicy added in v3.3.0 

type ManagedScalingPolicy struct {
	pulumi.CustomResourceState

	// The id of the EMR cluster
	ClusterId pulumi.StringOutput `pulumi:"clusterId"`
	// Configuration block with compute limit settings. Described below.
	ComputeLimits ManagedScalingPolicyComputeLimitArrayOutput `pulumi:"computeLimits"`
}

Provides a Managed Scaling policy for EMR Cluster. With Amazon EMR versions 5.30.0 and later (except for Amazon EMR 6.0.0), you can enable EMR managed scaling to automatically increase or decrease the number of instances or units in your cluster based on workload. See [Using EMR Managed Scaling in Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-scaling.html) for more information.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/emr"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		sample, err := emr.NewCluster(ctx, "sample", &emr.ClusterArgs{
			ReleaseLabel: pulumi.String("emr-5.30.0"),
			MasterInstanceGroup: &emr.ClusterMasterInstanceGroupArgs{
				InstanceType: pulumi.String("m4.large"),
			},
			CoreInstanceGroup: &emr.ClusterCoreInstanceGroupArgs{
				InstanceType: pulumi.String("c4.large"),
			},
		})
		if err != nil {
			return err
		}
		_, err = emr.NewManagedScalingPolicy(ctx, "samplepolicy", &emr.ManagedScalingPolicyArgs{
			ClusterId: sample.ID(),
			ComputeLimits: emr.ManagedScalingPolicyComputeLimitArray{
				&emr.ManagedScalingPolicyComputeLimitArgs{
					UnitType:                     pulumi.String("Instances"),
					MinimumCapacityUnits:         pulumi.Int(2),
					MaximumCapacityUnits:         pulumi.Int(10),
					MaximumOndemandCapacityUnits: pulumi.Int(2),
					MaximumCoreCapacityUnits:     pulumi.Int(10),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

EMR Managed Scaling Policies can be imported via the EMR Cluster identifier, e.g. console

```sh 

$ pulumi import aws:emr/managedScalingPolicy:ManagedScalingPolicy example j-123456ABCDEF

```

func GetManagedScalingPolicy added in v3.3.0 

func GetManagedScalingPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ManagedScalingPolicyState, opts ...pulumi.ResourceOption) (*ManagedScalingPolicy, error)

GetManagedScalingPolicy gets an existing ManagedScalingPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewManagedScalingPolicy added in v3.3.0 

func NewManagedScalingPolicy(ctx *pulumi.Context,
	name string, args *ManagedScalingPolicyArgs, opts ...pulumi.ResourceOption) (*ManagedScalingPolicy, error)

NewManagedScalingPolicy registers a new resource with the given unique name, arguments, and options.

func (*ManagedScalingPolicy) ElementType added in v3.13.0 

func (*ManagedScalingPolicy) ElementType() reflect.Type

func (*ManagedScalingPolicy) ToManagedScalingPolicyOutput added in v3.13.0 

func (i *ManagedScalingPolicy) ToManagedScalingPolicyOutput() ManagedScalingPolicyOutput

func (*ManagedScalingPolicy) ToManagedScalingPolicyOutputWithContext added in v3.13.0 

func (i *ManagedScalingPolicy) ToManagedScalingPolicyOutputWithContext(ctx context.Context) ManagedScalingPolicyOutput

func (*ManagedScalingPolicy) ToManagedScalingPolicyPtrOutput added in v3.25.0 

func (i *ManagedScalingPolicy) ToManagedScalingPolicyPtrOutput() ManagedScalingPolicyPtrOutput

func (*ManagedScalingPolicy) ToManagedScalingPolicyPtrOutputWithContext added in v3.25.0 

func (i *ManagedScalingPolicy) ToManagedScalingPolicyPtrOutputWithContext(ctx context.Context) ManagedScalingPolicyPtrOutput

type ManagedScalingPolicyArgs added in v3.3.0 

type ManagedScalingPolicyArgs struct {
	// The id of the EMR cluster
	ClusterId pulumi.StringInput
	// Configuration block with compute limit settings. Described below.
	ComputeLimits ManagedScalingPolicyComputeLimitArrayInput
}

The set of arguments for constructing a ManagedScalingPolicy resource.

func (ManagedScalingPolicyArgs) ElementType added in v3.3.0 

func (ManagedScalingPolicyArgs) ElementType() reflect.Type

type ManagedScalingPolicyArray added in v3.25.0 

type ManagedScalingPolicyArray []ManagedScalingPolicyInput

func (ManagedScalingPolicyArray) ElementType added in v3.25.0 

func (ManagedScalingPolicyArray) ElementType() reflect.Type

func (ManagedScalingPolicyArray) ToManagedScalingPolicyArrayOutput added in v3.25.0 

func (i ManagedScalingPolicyArray) ToManagedScalingPolicyArrayOutput() ManagedScalingPolicyArrayOutput

func (ManagedScalingPolicyArray) ToManagedScalingPolicyArrayOutputWithContext added in v3.25.0 

func (i ManagedScalingPolicyArray) ToManagedScalingPolicyArrayOutputWithContext(ctx context.Context) ManagedScalingPolicyArrayOutput

type ManagedScalingPolicyArrayInput added in v3.25.0 

type ManagedScalingPolicyArrayInput interface {
	pulumi.Input

	ToManagedScalingPolicyArrayOutput() ManagedScalingPolicyArrayOutput
	ToManagedScalingPolicyArrayOutputWithContext(context.Context) ManagedScalingPolicyArrayOutput
}

ManagedScalingPolicyArrayInput is an input type that accepts ManagedScalingPolicyArray and ManagedScalingPolicyArrayOutput values. You can construct a concrete instance of `ManagedScalingPolicyArrayInput` via: 

ManagedScalingPolicyArray{ ManagedScalingPolicyArgs{...} }

type ManagedScalingPolicyArrayOutput added in v3.25.0 

type ManagedScalingPolicyArrayOutput struct{ *pulumi.OutputState }

func (ManagedScalingPolicyArrayOutput) ElementType added in v3.25.0 

func (ManagedScalingPolicyArrayOutput) ElementType() reflect.Type

func (ManagedScalingPolicyArrayOutput) Index added in v3.25.0 

func (o ManagedScalingPolicyArrayOutput) Index(i pulumi.IntInput) ManagedScalingPolicyOutput

func (ManagedScalingPolicyArrayOutput) ToManagedScalingPolicyArrayOutput added in v3.25.0 

func (o ManagedScalingPolicyArrayOutput) ToManagedScalingPolicyArrayOutput() ManagedScalingPolicyArrayOutput

func (ManagedScalingPolicyArrayOutput) ToManagedScalingPolicyArrayOutputWithContext added in v3.25.0 

func (o ManagedScalingPolicyArrayOutput) ToManagedScalingPolicyArrayOutputWithContext(ctx context.Context) ManagedScalingPolicyArrayOutput

type ManagedScalingPolicyComputeLimit added in v3.3.0 

type ManagedScalingPolicyComputeLimit struct {
	// The upper boundary of EC2 units. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. Managed scaling activities are not allowed beyond this boundary. The limit only applies to the core and task nodes. The master node cannot be scaled after initial configuration.
	MaximumCapacityUnits int `pulumi:"maximumCapacityUnits"`
	// The upper boundary of EC2 units for core node type in a cluster. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. The core units are not allowed to scale beyond this boundary. The parameter is used to split capacity allocation between core and task nodes.
	MaximumCoreCapacityUnits *int `pulumi:"maximumCoreCapacityUnits"`
	// The upper boundary of On-Demand EC2 units. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. The On-Demand units are not allowed to scale beyond this boundary. The parameter is used to split capacity allocation between On-Demand and Spot instances.
	MaximumOndemandCapacityUnits *int `pulumi:"maximumOndemandCapacityUnits"`
	// The lower boundary of EC2 units. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. Managed scaling activities are not allowed beyond this boundary. The limit only applies to the core and task nodes. The master node cannot be scaled after initial configuration.
	MinimumCapacityUnits int `pulumi:"minimumCapacityUnits"`
	// The unit type used for specifying a managed scaling policy. Valid Values: `InstanceFleetUnits` | `Instances` | `VCPU`
	UnitType string `pulumi:"unitType"`
}

type ManagedScalingPolicyComputeLimitArgs added in v3.3.0 

type ManagedScalingPolicyComputeLimitArgs struct {
	// The upper boundary of EC2 units. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. Managed scaling activities are not allowed beyond this boundary. The limit only applies to the core and task nodes. The master node cannot be scaled after initial configuration.
	MaximumCapacityUnits pulumi.IntInput `pulumi:"maximumCapacityUnits"`
	// The upper boundary of EC2 units for core node type in a cluster. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. The core units are not allowed to scale beyond this boundary. The parameter is used to split capacity allocation between core and task nodes.
	MaximumCoreCapacityUnits pulumi.IntPtrInput `pulumi:"maximumCoreCapacityUnits"`
	// The upper boundary of On-Demand EC2 units. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. The On-Demand units are not allowed to scale beyond this boundary. The parameter is used to split capacity allocation between On-Demand and Spot instances.
	MaximumOndemandCapacityUnits pulumi.IntPtrInput `pulumi:"maximumOndemandCapacityUnits"`
	// The lower boundary of EC2 units. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. Managed scaling activities are not allowed beyond this boundary. The limit only applies to the core and task nodes. The master node cannot be scaled after initial configuration.
	MinimumCapacityUnits pulumi.IntInput `pulumi:"minimumCapacityUnits"`
	// The unit type used for specifying a managed scaling policy. Valid Values: `InstanceFleetUnits` | `Instances` | `VCPU`
	UnitType pulumi.StringInput `pulumi:"unitType"`
}

func (ManagedScalingPolicyComputeLimitArgs) ElementType added in v3.3.0 

func (ManagedScalingPolicyComputeLimitArgs) ElementType() reflect.Type

func (ManagedScalingPolicyComputeLimitArgs) ToManagedScalingPolicyComputeLimitOutput added in v3.3.0 

func (i ManagedScalingPolicyComputeLimitArgs) ToManagedScalingPolicyComputeLimitOutput() ManagedScalingPolicyComputeLimitOutput

func (ManagedScalingPolicyComputeLimitArgs) ToManagedScalingPolicyComputeLimitOutputWithContext added in v3.3.0 

func (i ManagedScalingPolicyComputeLimitArgs) ToManagedScalingPolicyComputeLimitOutputWithContext(ctx context.Context) ManagedScalingPolicyComputeLimitOutput

type ManagedScalingPolicyComputeLimitArray added in v3.3.0 

type ManagedScalingPolicyComputeLimitArray []ManagedScalingPolicyComputeLimitInput

func (ManagedScalingPolicyComputeLimitArray) ElementType added in v3.3.0 

func (ManagedScalingPolicyComputeLimitArray) ElementType() reflect.Type

func (ManagedScalingPolicyComputeLimitArray) ToManagedScalingPolicyComputeLimitArrayOutput added in v3.3.0 

func (i ManagedScalingPolicyComputeLimitArray) ToManagedScalingPolicyComputeLimitArrayOutput() ManagedScalingPolicyComputeLimitArrayOutput

func (ManagedScalingPolicyComputeLimitArray) ToManagedScalingPolicyComputeLimitArrayOutputWithContext added in v3.3.0 

func (i ManagedScalingPolicyComputeLimitArray) ToManagedScalingPolicyComputeLimitArrayOutputWithContext(ctx context.Context) ManagedScalingPolicyComputeLimitArrayOutput

type ManagedScalingPolicyComputeLimitArrayInput added in v3.3.0 

type ManagedScalingPolicyComputeLimitArrayInput interface {
	pulumi.Input

	ToManagedScalingPolicyComputeLimitArrayOutput() ManagedScalingPolicyComputeLimitArrayOutput
	ToManagedScalingPolicyComputeLimitArrayOutputWithContext(context.Context) ManagedScalingPolicyComputeLimitArrayOutput
}

ManagedScalingPolicyComputeLimitArrayInput is an input type that accepts ManagedScalingPolicyComputeLimitArray and ManagedScalingPolicyComputeLimitArrayOutput values. You can construct a concrete instance of `ManagedScalingPolicyComputeLimitArrayInput` via: 

ManagedScalingPolicyComputeLimitArray{ ManagedScalingPolicyComputeLimitArgs{...} }

type ManagedScalingPolicyComputeLimitArrayOutput added in v3.3.0 

type ManagedScalingPolicyComputeLimitArrayOutput struct{ *pulumi.OutputState }

func (ManagedScalingPolicyComputeLimitArrayOutput) ElementType added in v3.3.0 

func (ManagedScalingPolicyComputeLimitArrayOutput) ElementType() reflect.Type

func (ManagedScalingPolicyComputeLimitArrayOutput) Index added in v3.3.0 

func (o ManagedScalingPolicyComputeLimitArrayOutput) Index(i pulumi.IntInput) ManagedScalingPolicyComputeLimitOutput

func (ManagedScalingPolicyComputeLimitArrayOutput) ToManagedScalingPolicyComputeLimitArrayOutput added in v3.3.0 

func (o ManagedScalingPolicyComputeLimitArrayOutput) ToManagedScalingPolicyComputeLimitArrayOutput() ManagedScalingPolicyComputeLimitArrayOutput

func (ManagedScalingPolicyComputeLimitArrayOutput) ToManagedScalingPolicyComputeLimitArrayOutputWithContext added in v3.3.0 

func (o ManagedScalingPolicyComputeLimitArrayOutput) ToManagedScalingPolicyComputeLimitArrayOutputWithContext(ctx context.Context) ManagedScalingPolicyComputeLimitArrayOutput

type ManagedScalingPolicyComputeLimitInput added in v3.3.0 

type ManagedScalingPolicyComputeLimitInput interface {
	pulumi.Input

	ToManagedScalingPolicyComputeLimitOutput() ManagedScalingPolicyComputeLimitOutput
	ToManagedScalingPolicyComputeLimitOutputWithContext(context.Context) ManagedScalingPolicyComputeLimitOutput
}

ManagedScalingPolicyComputeLimitInput is an input type that accepts ManagedScalingPolicyComputeLimitArgs and ManagedScalingPolicyComputeLimitOutput values. You can construct a concrete instance of `ManagedScalingPolicyComputeLimitInput` via: 

ManagedScalingPolicyComputeLimitArgs{...}

type ManagedScalingPolicyComputeLimitOutput added in v3.3.0 

type ManagedScalingPolicyComputeLimitOutput struct{ *pulumi.OutputState }

func (ManagedScalingPolicyComputeLimitOutput) ElementType added in v3.3.0 

func (ManagedScalingPolicyComputeLimitOutput) ElementType() reflect.Type

func (ManagedScalingPolicyComputeLimitOutput) MaximumCapacityUnits added in v3.3.0 

func (o ManagedScalingPolicyComputeLimitOutput) MaximumCapacityUnits() pulumi.IntOutput

The upper boundary of EC2 units. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. Managed scaling activities are not allowed beyond this boundary. The limit only applies to the core and task nodes. The master node cannot be scaled after initial configuration.

func (ManagedScalingPolicyComputeLimitOutput) MaximumCoreCapacityUnits added in v3.3.0 

func (o ManagedScalingPolicyComputeLimitOutput) MaximumCoreCapacityUnits() pulumi.IntPtrOutput

The upper boundary of EC2 units for core node type in a cluster. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. The core units are not allowed to scale beyond this boundary. The parameter is used to split capacity allocation between core and task nodes.

func (ManagedScalingPolicyComputeLimitOutput) MaximumOndemandCapacityUnits added in v3.3.0 

func (o ManagedScalingPolicyComputeLimitOutput) MaximumOndemandCapacityUnits() pulumi.IntPtrOutput

The upper boundary of On-Demand EC2 units. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. The On-Demand units are not allowed to scale beyond this boundary. The parameter is used to split capacity allocation between On-Demand and Spot instances.

func (ManagedScalingPolicyComputeLimitOutput) MinimumCapacityUnits added in v3.3.0 

func (o ManagedScalingPolicyComputeLimitOutput) MinimumCapacityUnits() pulumi.IntOutput

The lower boundary of EC2 units. It is measured through VCPU cores or instances for instance groups and measured through units for instance fleets. Managed scaling activities are not allowed beyond this boundary. The limit only applies to the core and task nodes. The master node cannot be scaled after initial configuration.

func (ManagedScalingPolicyComputeLimitOutput) ToManagedScalingPolicyComputeLimitOutput added in v3.3.0 

func (o ManagedScalingPolicyComputeLimitOutput) ToManagedScalingPolicyComputeLimitOutput() ManagedScalingPolicyComputeLimitOutput

func (ManagedScalingPolicyComputeLimitOutput) ToManagedScalingPolicyComputeLimitOutputWithContext added in v3.3.0 

func (o ManagedScalingPolicyComputeLimitOutput) ToManagedScalingPolicyComputeLimitOutputWithContext(ctx context.Context) ManagedScalingPolicyComputeLimitOutput

func (ManagedScalingPolicyComputeLimitOutput) UnitType added in v3.3.0 

func (o ManagedScalingPolicyComputeLimitOutput) UnitType() pulumi.StringOutput

The unit type used for specifying a managed scaling policy. Valid Values: `InstanceFleetUnits` | `Instances` | `VCPU`

type ManagedScalingPolicyInput added in v3.13.0 

type ManagedScalingPolicyInput interface {
	pulumi.Input

	ToManagedScalingPolicyOutput() ManagedScalingPolicyOutput
	ToManagedScalingPolicyOutputWithContext(ctx context.Context) ManagedScalingPolicyOutput
}

type ManagedScalingPolicyMap added in v3.25.0 

type ManagedScalingPolicyMap map[string]ManagedScalingPolicyInput

func (ManagedScalingPolicyMap) ElementType added in v3.25.0 

func (ManagedScalingPolicyMap) ElementType() reflect.Type

func (ManagedScalingPolicyMap) ToManagedScalingPolicyMapOutput added in v3.25.0 

func (i ManagedScalingPolicyMap) ToManagedScalingPolicyMapOutput() ManagedScalingPolicyMapOutput

func (ManagedScalingPolicyMap) ToManagedScalingPolicyMapOutputWithContext added in v3.25.0 

func (i ManagedScalingPolicyMap) ToManagedScalingPolicyMapOutputWithContext(ctx context.Context) ManagedScalingPolicyMapOutput

type ManagedScalingPolicyMapInput added in v3.25.0 

type ManagedScalingPolicyMapInput interface {
	pulumi.Input

	ToManagedScalingPolicyMapOutput() ManagedScalingPolicyMapOutput
	ToManagedScalingPolicyMapOutputWithContext(context.Context) ManagedScalingPolicyMapOutput
}

ManagedScalingPolicyMapInput is an input type that accepts ManagedScalingPolicyMap and ManagedScalingPolicyMapOutput values. You can construct a concrete instance of `ManagedScalingPolicyMapInput` via: 

ManagedScalingPolicyMap{ "key": ManagedScalingPolicyArgs{...} }

type ManagedScalingPolicyMapOutput added in v3.25.0 

type ManagedScalingPolicyMapOutput struct{ *pulumi.OutputState }

func (ManagedScalingPolicyMapOutput) ElementType added in v3.25.0 

func (ManagedScalingPolicyMapOutput) ElementType() reflect.Type

func (ManagedScalingPolicyMapOutput) MapIndex added in v3.25.0 

func (o ManagedScalingPolicyMapOutput) MapIndex(k pulumi.StringInput) ManagedScalingPolicyOutput

func (ManagedScalingPolicyMapOutput) ToManagedScalingPolicyMapOutput added in v3.25.0 

func (o ManagedScalingPolicyMapOutput) ToManagedScalingPolicyMapOutput() ManagedScalingPolicyMapOutput

func (ManagedScalingPolicyMapOutput) ToManagedScalingPolicyMapOutputWithContext added in v3.25.0 

func (o ManagedScalingPolicyMapOutput) ToManagedScalingPolicyMapOutputWithContext(ctx context.Context) ManagedScalingPolicyMapOutput

type ManagedScalingPolicyOutput added in v3.13.0 

type ManagedScalingPolicyOutput struct {
	*pulumi.OutputState
}

func (ManagedScalingPolicyOutput) ElementType added in v3.13.0 

func (ManagedScalingPolicyOutput) ElementType() reflect.Type

func (ManagedScalingPolicyOutput) ToManagedScalingPolicyOutput added in v3.13.0 

func (o ManagedScalingPolicyOutput) ToManagedScalingPolicyOutput() ManagedScalingPolicyOutput

func (ManagedScalingPolicyOutput) ToManagedScalingPolicyOutputWithContext added in v3.13.0 

func (o ManagedScalingPolicyOutput) ToManagedScalingPolicyOutputWithContext(ctx context.Context) ManagedScalingPolicyOutput

func (ManagedScalingPolicyOutput) ToManagedScalingPolicyPtrOutput added in v3.25.0 

func (o ManagedScalingPolicyOutput) ToManagedScalingPolicyPtrOutput() ManagedScalingPolicyPtrOutput

func (ManagedScalingPolicyOutput) ToManagedScalingPolicyPtrOutputWithContext added in v3.25.0 

func (o ManagedScalingPolicyOutput) ToManagedScalingPolicyPtrOutputWithContext(ctx context.Context) ManagedScalingPolicyPtrOutput

type ManagedScalingPolicyPtrInput added in v3.25.0 

type ManagedScalingPolicyPtrInput interface {
	pulumi.Input

	ToManagedScalingPolicyPtrOutput() ManagedScalingPolicyPtrOutput
	ToManagedScalingPolicyPtrOutputWithContext(ctx context.Context) ManagedScalingPolicyPtrOutput
}

type ManagedScalingPolicyPtrOutput added in v3.25.0 

type ManagedScalingPolicyPtrOutput struct {
	*pulumi.OutputState
}

func (ManagedScalingPolicyPtrOutput) ElementType added in v3.25.0 

func (ManagedScalingPolicyPtrOutput) ElementType() reflect.Type

func (ManagedScalingPolicyPtrOutput) ToManagedScalingPolicyPtrOutput added in v3.25.0 

func (o ManagedScalingPolicyPtrOutput) ToManagedScalingPolicyPtrOutput() ManagedScalingPolicyPtrOutput

func (ManagedScalingPolicyPtrOutput) ToManagedScalingPolicyPtrOutputWithContext added in v3.25.0 

func (o ManagedScalingPolicyPtrOutput) ToManagedScalingPolicyPtrOutputWithContext(ctx context.Context) ManagedScalingPolicyPtrOutput

type ManagedScalingPolicyState added in v3.3.0 

type ManagedScalingPolicyState struct {
	// The id of the EMR cluster
	ClusterId pulumi.StringPtrInput
	// Configuration block with compute limit settings. Described below.
	ComputeLimits ManagedScalingPolicyComputeLimitArrayInput
}

func (ManagedScalingPolicyState) ElementType added in v3.3.0 

func (ManagedScalingPolicyState) ElementType() reflect.Type

type SecurityConfiguration 

type SecurityConfiguration struct {
	pulumi.CustomResourceState

	// A JSON formatted Security Configuration
	Configuration pulumi.StringOutput `pulumi:"configuration"`
	// Date the Security Configuration was created
	CreationDate pulumi.StringOutput `pulumi:"creationDate"`
	// The name of the EMR Security Configuration. By default generated by this provider.
	Name pulumi.StringOutput `pulumi:"name"`
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrOutput `pulumi:"namePrefix"`
}

Provides a resource to manage AWS EMR Security Configurations

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/emr"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := emr.NewSecurityConfiguration(ctx, "foo", &emr.SecurityConfigurationArgs{
			Configuration: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"EncryptionConfiguration\": {\n", "    \"AtRestEncryptionConfiguration\": {\n", "      \"S3EncryptionConfiguration\": {\n", "        \"EncryptionMode\": \"SSE-S3\"\n", "      },\n", "      \"LocalDiskEncryptionConfiguration\": {\n", "        \"EncryptionKeyProviderType\": \"AwsKms\",\n", "        \"AwsKmsKey\": \"arn:aws:kms:us-west-2:187416307283:alias/tf_emr_test_key\"\n", "      }\n", "    },\n", "    \"EnableInTransitEncryption\": false,\n", "    \"EnableAtRestEncryption\": true\n", "  }\n", "}\n", "\n")),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

EMR Security Configurations can be imported using the `name`, e.g.

```sh 

$ pulumi import aws:emr/securityConfiguration:SecurityConfiguration sc example-sc-name

```

func GetSecurityConfiguration 

func GetSecurityConfiguration(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *SecurityConfigurationState, opts ...pulumi.ResourceOption) (*SecurityConfiguration, error)

GetSecurityConfiguration gets an existing SecurityConfiguration resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewSecurityConfiguration 

func NewSecurityConfiguration(ctx *pulumi.Context,
	name string, args *SecurityConfigurationArgs, opts ...pulumi.ResourceOption) (*SecurityConfiguration, error)

NewSecurityConfiguration registers a new resource with the given unique name, arguments, and options.

func (*SecurityConfiguration) ElementType added in v3.13.0 

func (*SecurityConfiguration) ElementType() reflect.Type

func (*SecurityConfiguration) ToSecurityConfigurationOutput added in v3.13.0 

func (i *SecurityConfiguration) ToSecurityConfigurationOutput() SecurityConfigurationOutput

func (*SecurityConfiguration) ToSecurityConfigurationOutputWithContext added in v3.13.0 

func (i *SecurityConfiguration) ToSecurityConfigurationOutputWithContext(ctx context.Context) SecurityConfigurationOutput

func (*SecurityConfiguration) ToSecurityConfigurationPtrOutput added in v3.25.0 

func (i *SecurityConfiguration) ToSecurityConfigurationPtrOutput() SecurityConfigurationPtrOutput

func (*SecurityConfiguration) ToSecurityConfigurationPtrOutputWithContext added in v3.25.0 

func (i *SecurityConfiguration) ToSecurityConfigurationPtrOutputWithContext(ctx context.Context) SecurityConfigurationPtrOutput

type SecurityConfigurationArgs 

type SecurityConfigurationArgs struct {
	// A JSON formatted Security Configuration
	Configuration pulumi.StringInput
	// The name of the EMR Security Configuration. By default generated by this provider.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
}

The set of arguments for constructing a SecurityConfiguration resource.

func (SecurityConfigurationArgs) ElementType 

func (SecurityConfigurationArgs) ElementType() reflect.Type

type SecurityConfigurationArray added in v3.25.0 

type SecurityConfigurationArray []SecurityConfigurationInput

func (SecurityConfigurationArray) ElementType added in v3.25.0 

func (SecurityConfigurationArray) ElementType() reflect.Type

func (SecurityConfigurationArray) ToSecurityConfigurationArrayOutput added in v3.25.0 

func (i SecurityConfigurationArray) ToSecurityConfigurationArrayOutput() SecurityConfigurationArrayOutput

func (SecurityConfigurationArray) ToSecurityConfigurationArrayOutputWithContext added in v3.25.0 

func (i SecurityConfigurationArray) ToSecurityConfigurationArrayOutputWithContext(ctx context.Context) SecurityConfigurationArrayOutput

type SecurityConfigurationArrayInput added in v3.25.0 

type SecurityConfigurationArrayInput interface {
	pulumi.Input

	ToSecurityConfigurationArrayOutput() SecurityConfigurationArrayOutput
	ToSecurityConfigurationArrayOutputWithContext(context.Context) SecurityConfigurationArrayOutput
}

SecurityConfigurationArrayInput is an input type that accepts SecurityConfigurationArray and SecurityConfigurationArrayOutput values. You can construct a concrete instance of `SecurityConfigurationArrayInput` via: 

SecurityConfigurationArray{ SecurityConfigurationArgs{...} }

type SecurityConfigurationArrayOutput added in v3.25.0 

type SecurityConfigurationArrayOutput struct{ *pulumi.OutputState }

func (SecurityConfigurationArrayOutput) ElementType added in v3.25.0 

func (SecurityConfigurationArrayOutput) ElementType() reflect.Type

func (SecurityConfigurationArrayOutput) Index added in v3.25.0 

func (o SecurityConfigurationArrayOutput) Index(i pulumi.IntInput) SecurityConfigurationOutput

func (SecurityConfigurationArrayOutput) ToSecurityConfigurationArrayOutput added in v3.25.0 

func (o SecurityConfigurationArrayOutput) ToSecurityConfigurationArrayOutput() SecurityConfigurationArrayOutput

func (SecurityConfigurationArrayOutput) ToSecurityConfigurationArrayOutputWithContext added in v3.25.0 

func (o SecurityConfigurationArrayOutput) ToSecurityConfigurationArrayOutputWithContext(ctx context.Context) SecurityConfigurationArrayOutput

type SecurityConfigurationInput added in v3.13.0 

type SecurityConfigurationInput interface {
	pulumi.Input

	ToSecurityConfigurationOutput() SecurityConfigurationOutput
	ToSecurityConfigurationOutputWithContext(ctx context.Context) SecurityConfigurationOutput
}

type SecurityConfigurationMap added in v3.25.0 

type SecurityConfigurationMap map[string]SecurityConfigurationInput

func (SecurityConfigurationMap) ElementType added in v3.25.0 

func (SecurityConfigurationMap) ElementType() reflect.Type

func (SecurityConfigurationMap) ToSecurityConfigurationMapOutput added in v3.25.0 

func (i SecurityConfigurationMap) ToSecurityConfigurationMapOutput() SecurityConfigurationMapOutput

func (SecurityConfigurationMap) ToSecurityConfigurationMapOutputWithContext added in v3.25.0 

func (i SecurityConfigurationMap) ToSecurityConfigurationMapOutputWithContext(ctx context.Context) SecurityConfigurationMapOutput

type SecurityConfigurationMapInput added in v3.25.0 

type SecurityConfigurationMapInput interface {
	pulumi.Input

	ToSecurityConfigurationMapOutput() SecurityConfigurationMapOutput
	ToSecurityConfigurationMapOutputWithContext(context.Context) SecurityConfigurationMapOutput
}

SecurityConfigurationMapInput is an input type that accepts SecurityConfigurationMap and SecurityConfigurationMapOutput values. You can construct a concrete instance of `SecurityConfigurationMapInput` via: 

SecurityConfigurationMap{ "key": SecurityConfigurationArgs{...} }

type SecurityConfigurationMapOutput added in v3.25.0 

type SecurityConfigurationMapOutput struct{ *pulumi.OutputState }

func (SecurityConfigurationMapOutput) ElementType added in v3.25.0 

func (SecurityConfigurationMapOutput) ElementType() reflect.Type

func (SecurityConfigurationMapOutput) MapIndex added in v3.25.0 

func (o SecurityConfigurationMapOutput) MapIndex(k pulumi.StringInput) SecurityConfigurationOutput

func (SecurityConfigurationMapOutput) ToSecurityConfigurationMapOutput added in v3.25.0 

func (o SecurityConfigurationMapOutput) ToSecurityConfigurationMapOutput() SecurityConfigurationMapOutput

func (SecurityConfigurationMapOutput) ToSecurityConfigurationMapOutputWithContext added in v3.25.0 

func (o SecurityConfigurationMapOutput) ToSecurityConfigurationMapOutputWithContext(ctx context.Context) SecurityConfigurationMapOutput

type SecurityConfigurationOutput added in v3.13.0 

type SecurityConfigurationOutput struct {
	*pulumi.OutputState
}

func (SecurityConfigurationOutput) ElementType added in v3.13.0 

func (SecurityConfigurationOutput) ElementType() reflect.Type

func (SecurityConfigurationOutput) ToSecurityConfigurationOutput added in v3.13.0 

func (o SecurityConfigurationOutput) ToSecurityConfigurationOutput() SecurityConfigurationOutput

func (SecurityConfigurationOutput) ToSecurityConfigurationOutputWithContext added in v3.13.0 

func (o SecurityConfigurationOutput) ToSecurityConfigurationOutputWithContext(ctx context.Context) SecurityConfigurationOutput

func (SecurityConfigurationOutput) ToSecurityConfigurationPtrOutput added in v3.25.0 

func (o SecurityConfigurationOutput) ToSecurityConfigurationPtrOutput() SecurityConfigurationPtrOutput

func (SecurityConfigurationOutput) ToSecurityConfigurationPtrOutputWithContext added in v3.25.0 

func (o SecurityConfigurationOutput) ToSecurityConfigurationPtrOutputWithContext(ctx context.Context) SecurityConfigurationPtrOutput

type SecurityConfigurationPtrInput added in v3.25.0 

type SecurityConfigurationPtrInput interface {
	pulumi.Input

	ToSecurityConfigurationPtrOutput() SecurityConfigurationPtrOutput
	ToSecurityConfigurationPtrOutputWithContext(ctx context.Context) SecurityConfigurationPtrOutput
}

type SecurityConfigurationPtrOutput added in v3.25.0 

type SecurityConfigurationPtrOutput struct {
	*pulumi.OutputState
}

func (SecurityConfigurationPtrOutput) ElementType added in v3.25.0 

func (SecurityConfigurationPtrOutput) ElementType() reflect.Type

func (SecurityConfigurationPtrOutput) ToSecurityConfigurationPtrOutput added in v3.25.0 

func (o SecurityConfigurationPtrOutput) ToSecurityConfigurationPtrOutput() SecurityConfigurationPtrOutput

func (SecurityConfigurationPtrOutput) ToSecurityConfigurationPtrOutputWithContext added in v3.25.0 

func (o SecurityConfigurationPtrOutput) ToSecurityConfigurationPtrOutputWithContext(ctx context.Context) SecurityConfigurationPtrOutput

type SecurityConfigurationState 

type SecurityConfigurationState struct {
	// A JSON formatted Security Configuration
	Configuration pulumi.StringPtrInput
	// Date the Security Configuration was created
	CreationDate pulumi.StringPtrInput
	// The name of the EMR Security Configuration. By default generated by this provider.
	Name pulumi.StringPtrInput
	// Creates a unique name beginning with the specified
	// prefix. Conflicts with `name`.
	NamePrefix pulumi.StringPtrInput
}

func (SecurityConfigurationState) ElementType 

func (SecurityConfigurationState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.