pulumi-aws-kotlin/com.pulumi.aws.emr.kotlin/InstanceFleetArgs

InstanceFleetArgs

data class InstanceFleetArgs(val clusterId: Output<String>? = null, val instanceTypeConfigs: Output<List<InstanceFleetInstanceTypeConfigArgs>>? = null, val launchSpecifications: Output<InstanceFleetLaunchSpecificationsArgs>? = null, val name: Output<String>? = null, val targetOnDemandCapacity: Output<Int>? = null, val targetSpotCapacity: Output<Int>? = null) : ConvertibleToJava<InstanceFleetArgs>

Provides an Elastic MapReduce Cluster Instance Fleet configuration. See Amazon Elastic MapReduce Documentation 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

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const task = new aws.emr.InstanceFleet("task", {
    clusterId: cluster.id,
    instanceTypeConfigs: [
        {
            bidPriceAsPercentageOfOnDemandPrice: 100,
            ebsConfigs: [{
                size: 100,
                type: "gp2",
                volumesPerInstance: 1,
            }],
            instanceType: "m4.xlarge",
            weightedCapacity: 1,
        },
        {
            bidPriceAsPercentageOfOnDemandPrice: 100,
            ebsConfigs: [{
                size: 100,
                type: "gp2",
                volumesPerInstance: 1,
            }],
            instanceType: "m4.2xlarge",
            weightedCapacity: 2,
        },
    ],
    launchSpecifications: {
        spotSpecifications: [{
            allocationStrategy: "capacity-optimized",
            blockDurationMinutes: 0,
            timeoutAction: "TERMINATE_CLUSTER",
            timeoutDurationMinutes: 10,
        }],
    },
    name: "task fleet",
    targetOnDemandCapacity: 1,
    targetSpotCapacity: 1,
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
task = aws.emr.InstanceFleet("task",
    cluster_id=cluster["id"],
    instance_type_configs=[
        {
            "bid_price_as_percentage_of_on_demand_price": 100,
            "ebs_configs": [{
                "size": 100,
                "type": "gp2",
                "volumes_per_instance": 1,
            }],
            "instance_type": "m4.xlarge",
            "weighted_capacity": 1,
        },
        {
            "bid_price_as_percentage_of_on_demand_price": 100,
            "ebs_configs": [{
                "size": 100,
                "type": "gp2",
                "volumes_per_instance": 1,
            }],
            "instance_type": "m4.2xlarge",
            "weighted_capacity": 2,
        },
    ],
    launch_specifications={
        "spot_specifications": [{
            "allocation_strategy": "capacity-optimized",
            "block_duration_minutes": 0,
            "timeout_action": "TERMINATE_CLUSTER",
            "timeout_duration_minutes": 10,
        }],
    },
    name="task fleet",
    target_on_demand_capacity=1,
    target_spot_capacity=1)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var task = new Aws.Emr.InstanceFleet("task", new()
    {
        ClusterId = cluster.Id,
        InstanceTypeConfigs = new[]
        {
            new Aws.Emr.Inputs.InstanceFleetInstanceTypeConfigArgs
            {
                BidPriceAsPercentageOfOnDemandPrice = 100,
                EbsConfigs = new[]
                {
                    new Aws.Emr.Inputs.InstanceFleetInstanceTypeConfigEbsConfigArgs
                    {
                        Size = 100,
                        Type = "gp2",
                        VolumesPerInstance = 1,
                    },
                },
                InstanceType = "m4.xlarge",
                WeightedCapacity = 1,
            },
            new Aws.Emr.Inputs.InstanceFleetInstanceTypeConfigArgs
            {
                BidPriceAsPercentageOfOnDemandPrice = 100,
                EbsConfigs = new[]
                {
                    new Aws.Emr.Inputs.InstanceFleetInstanceTypeConfigEbsConfigArgs
                    {
                        Size = 100,
                        Type = "gp2",
                        VolumesPerInstance = 1,
                    },
                },
                InstanceType = "m4.2xlarge",
                WeightedCapacity = 2,
            },
        },
        LaunchSpecifications = new Aws.Emr.Inputs.InstanceFleetLaunchSpecificationsArgs
        {
            SpotSpecifications = new[]
            {
                new Aws.Emr.Inputs.InstanceFleetLaunchSpecificationsSpotSpecificationArgs
                {
                    AllocationStrategy = "capacity-optimized",
                    BlockDurationMinutes = 0,
                    TimeoutAction = "TERMINATE_CLUSTER",
                    TimeoutDurationMinutes = 10,
                },
            },
        },
        Name = "task fleet",
        TargetOnDemandCapacity = 1,
        TargetSpotCapacity = 1,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/emr"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := emr.NewInstanceFleet(ctx, "task", &emr.InstanceFleetArgs{
			ClusterId: pulumi.Any(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),
					},
				},
			},
			Name:                   pulumi.String("task fleet"),
			TargetOnDemandCapacity: pulumi.Int(1),
			TargetSpotCapacity:     pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.emr.InstanceFleet;
import com.pulumi.aws.emr.InstanceFleetArgs;
import com.pulumi.aws.emr.inputs.InstanceFleetInstanceTypeConfigArgs;
import com.pulumi.aws.emr.inputs.InstanceFleetLaunchSpecificationsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var task = new InstanceFleet("task", InstanceFleetArgs.builder()
            .clusterId(cluster.id())
            .instanceTypeConfigs(
                InstanceFleetInstanceTypeConfigArgs.builder()
                    .bidPriceAsPercentageOfOnDemandPrice(100.0)
                    .ebsConfigs(InstanceFleetInstanceTypeConfigEbsConfigArgs.builder()
                        .size(100)
                        .type("gp2")
                        .volumesPerInstance(1)
                        .build())
                    .instanceType("m4.xlarge")
                    .weightedCapacity(1)
                    .build(),
                InstanceFleetInstanceTypeConfigArgs.builder()
                    .bidPriceAsPercentageOfOnDemandPrice(100.0)
                    .ebsConfigs(InstanceFleetInstanceTypeConfigEbsConfigArgs.builder()
                        .size(100)
                        .type("gp2")
                        .volumesPerInstance(1)
                        .build())
                    .instanceType("m4.2xlarge")
                    .weightedCapacity(2)
                    .build())
            .launchSpecifications(InstanceFleetLaunchSpecificationsArgs.builder()
                .spotSpecifications(InstanceFleetLaunchSpecificationsSpotSpecificationArgs.builder()
                    .allocationStrategy("capacity-optimized")
                    .blockDurationMinutes(0)
                    .timeoutAction("TERMINATE_CLUSTER")
                    .timeoutDurationMinutes(10)
                    .build())
                .build())
            .name("task fleet")
            .targetOnDemandCapacity(1)
            .targetSpotCapacity(1)
            .build());
    }
}
Content copied to clipboard
resources:
  task:
    type: aws:emr:InstanceFleet
    properties:
      clusterId: ${cluster.id}
      instanceTypeConfigs:
        - bidPriceAsPercentageOfOnDemandPrice: 100
          ebsConfigs:
            - size: 100
              type: gp2
              volumesPerInstance: 1
          instanceType: m4.xlarge
          weightedCapacity: 1
        - bidPriceAsPercentageOfOnDemandPrice: 100
          ebsConfigs:
            - size: 100
              type: gp2
              volumesPerInstance: 1
          instanceType: m4.2xlarge
          weightedCapacity: 2
      launchSpecifications:
        spotSpecifications:
          - allocationStrategy: capacity-optimized
            blockDurationMinutes: 0
            timeoutAction: TERMINATE_CLUSTER
            timeoutDurationMinutes: 10
      name: task fleet
      targetOnDemandCapacity: 1
      targetSpotCapacity: 1
Content copied to clipboard

Import

Using pulumi import, import EMR Instance Fleet using the EMR Cluster identifier and Instance Fleet identifier separated by a forward slash (/). For example:

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

Constructors

Link copied to clipboard
constructor(clusterId: Output<String>? = null, instanceTypeConfigs: Output<List<InstanceFleetInstanceTypeConfigArgs>>? = null, launchSpecifications: Output<InstanceFleetLaunchSpecificationsArgs>? = null, name: Output<String>? = null, targetOnDemandCapacity: Output<Int>? = null, targetSpotCapacity: Output<Int>? = null)

Properties

Link copied to clipboard
val clusterId: Output<String>? = null

ID of the EMR Cluster to attach to. Changing this forces a new resource to be created.

Link copied to clipboard
val instanceTypeConfigs: Output<List<InstanceFleetInstanceTypeConfigArgs>>? = null

Configuration block for instance fleet

Link copied to clipboard
val launchSpecifications: Output<InstanceFleetLaunchSpecificationsArgs>? = null

Configuration block for launch specification

Link copied to clipboard
val name: Output<String>? = null

Friendly name given to the instance fleet.

Link copied to clipboard
val targetOnDemandCapacity: Output<Int>? = null

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

Link copied to clipboard
val targetSpotCapacity: Output<Int>? = null

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

Functions

Link copied to clipboard
open override fun toJava(): InstanceFleetArgs