pulumi-aws-kotlin/com.pulumi.aws.emrserverless.kotlin/Application

Application

class Application : KotlinCustomResource

Manages an EMR Serverless Application.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.emrserverless.Application("example", {
    name: "example",
    releaseLabel: "emr-6.6.0",
    type: "hive",
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.emrserverless.Application("example",
    name="example",
    release_label="emr-6.6.0",
    type="hive")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.EmrServerless.Application("example", new()
    {
        Name = "example",
        ReleaseLabel = "emr-6.6.0",
        Type = "hive",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/emrserverless"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := emrserverless.NewApplication(ctx, "example", &emrserverless.ApplicationArgs{
			Name:         pulumi.String("example"),
			ReleaseLabel: pulumi.String("emr-6.6.0"),
			Type:         pulumi.String("hive"),
		})
		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.emrserverless.Application;
import com.pulumi.aws.emrserverless.ApplicationArgs;
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 example = new Application("example", ApplicationArgs.builder()
            .name("example")
            .releaseLabel("emr-6.6.0")
            .type("hive")
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:emrserverless:Application
    properties:
      name: example
      releaseLabel: emr-6.6.0
      type: hive
Content copied to clipboard

Initial Capacity Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.emrserverless.Application("example", {
    name: "example",
    releaseLabel: "emr-6.6.0",
    type: "hive",
    initialCapacities: [{
        initialCapacityType: "HiveDriver",
        initialCapacityConfig: {
            workerCount: 1,
            workerConfiguration: {
                cpu: "2 vCPU",
                memory: "10 GB",
            },
        },
    }],
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.emrserverless.Application("example",
    name="example",
    release_label="emr-6.6.0",
    type="hive",
    initial_capacities=[{
        "initial_capacity_type": "HiveDriver",
        "initial_capacity_config": {
            "worker_count": 1,
            "worker_configuration": {
                "cpu": "2 vCPU",
                "memory": "10 GB",
            },
        },
    }])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.EmrServerless.Application("example", new()
    {
        Name = "example",
        ReleaseLabel = "emr-6.6.0",
        Type = "hive",
        InitialCapacities = new[]
        {
            new Aws.EmrServerless.Inputs.ApplicationInitialCapacityArgs
            {
                InitialCapacityType = "HiveDriver",
                InitialCapacityConfig = new Aws.EmrServerless.Inputs.ApplicationInitialCapacityInitialCapacityConfigArgs
                {
                    WorkerCount = 1,
                    WorkerConfiguration = new Aws.EmrServerless.Inputs.ApplicationInitialCapacityInitialCapacityConfigWorkerConfigurationArgs
                    {
                        Cpu = "2 vCPU",
                        Memory = "10 GB",
                    },
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/emrserverless"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := emrserverless.NewApplication(ctx, "example", &emrserverless.ApplicationArgs{
			Name:         pulumi.String("example"),
			ReleaseLabel: pulumi.String("emr-6.6.0"),
			Type:         pulumi.String("hive"),
			InitialCapacities: emrserverless.ApplicationInitialCapacityArray{
				&emrserverless.ApplicationInitialCapacityArgs{
					InitialCapacityType: pulumi.String("HiveDriver"),
					InitialCapacityConfig: &emrserverless.ApplicationInitialCapacityInitialCapacityConfigArgs{
						WorkerCount: pulumi.Int(1),
						WorkerConfiguration: &emrserverless.ApplicationInitialCapacityInitialCapacityConfigWorkerConfigurationArgs{
							Cpu:    pulumi.String("2 vCPU"),
							Memory: pulumi.String("10 GB"),
						},
					},
				},
			},
		})
		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.emrserverless.Application;
import com.pulumi.aws.emrserverless.ApplicationArgs;
import com.pulumi.aws.emrserverless.inputs.ApplicationInitialCapacityArgs;
import com.pulumi.aws.emrserverless.inputs.ApplicationInitialCapacityInitialCapacityConfigArgs;
import com.pulumi.aws.emrserverless.inputs.ApplicationInitialCapacityInitialCapacityConfigWorkerConfigurationArgs;
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 example = new Application("example", ApplicationArgs.builder()
            .name("example")
            .releaseLabel("emr-6.6.0")
            .type("hive")
            .initialCapacities(ApplicationInitialCapacityArgs.builder()
                .initialCapacityType("HiveDriver")
                .initialCapacityConfig(ApplicationInitialCapacityInitialCapacityConfigArgs.builder()
                    .workerCount(1)
                    .workerConfiguration(ApplicationInitialCapacityInitialCapacityConfigWorkerConfigurationArgs.builder()
                        .cpu("2 vCPU")
                        .memory("10 GB")
                        .build())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:emrserverless:Application
    properties:
      name: example
      releaseLabel: emr-6.6.0
      type: hive
      initialCapacities:
        - initialCapacityType: HiveDriver
          initialCapacityConfig:
            workerCount: 1
            workerConfiguration:
              cpu: 2 vCPU
              memory: 10 GB
Content copied to clipboard

Maximum Capacity Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.emrserverless.Application("example", {
    name: "example",
    releaseLabel: "emr-6.6.0",
    type: "hive",
    maximumCapacity: {
        cpu: "2 vCPU",
        memory: "10 GB",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.emrserverless.Application("example",
    name="example",
    release_label="emr-6.6.0",
    type="hive",
    maximum_capacity={
        "cpu": "2 vCPU",
        "memory": "10 GB",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.EmrServerless.Application("example", new()
    {
        Name = "example",
        ReleaseLabel = "emr-6.6.0",
        Type = "hive",
        MaximumCapacity = new Aws.EmrServerless.Inputs.ApplicationMaximumCapacityArgs
        {
            Cpu = "2 vCPU",
            Memory = "10 GB",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/emrserverless"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := emrserverless.NewApplication(ctx, "example", &emrserverless.ApplicationArgs{
			Name:         pulumi.String("example"),
			ReleaseLabel: pulumi.String("emr-6.6.0"),
			Type:         pulumi.String("hive"),
			MaximumCapacity: &emrserverless.ApplicationMaximumCapacityArgs{
				Cpu:    pulumi.String("2 vCPU"),
				Memory: pulumi.String("10 GB"),
			},
		})
		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.emrserverless.Application;
import com.pulumi.aws.emrserverless.ApplicationArgs;
import com.pulumi.aws.emrserverless.inputs.ApplicationMaximumCapacityArgs;
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 example = new Application("example", ApplicationArgs.builder()
            .name("example")
            .releaseLabel("emr-6.6.0")
            .type("hive")
            .maximumCapacity(ApplicationMaximumCapacityArgs.builder()
                .cpu("2 vCPU")
                .memory("10 GB")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:emrserverless:Application
    properties:
      name: example
      releaseLabel: emr-6.6.0
      type: hive
      maximumCapacity:
        cpu: 2 vCPU
        memory: 10 GB
Content copied to clipboard

Import

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

$ pulumi import aws:emrserverless/application:Application example id
Content copied to clipboard

Properties

Link copied to clipboard
val architecture: Output<String>?

The CPU architecture of an application. Valid values are ARM64 or X86_64. Default value is X86_64.

Link copied to clipboard
val arn: Output<String>

ARN of the cluster.

Link copied to clipboard
val autoStartConfiguration: Output<ApplicationAutoStartConfiguration>

The configuration for an application to automatically start on job submission.

Link copied to clipboard
val autoStopConfiguration: Output<ApplicationAutoStopConfiguration>

The configuration for an application to automatically stop after a certain amount of time being idle.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val imageConfiguration: Output<ApplicationImageConfiguration>

The image configuration applied to all worker types.

Link copied to clipboard
val initialCapacities: Output<List<ApplicationInitialCapacity>>?

The capacity to initialize when the application is created.

Link copied to clipboard
val interactiveConfiguration: Output<ApplicationInteractiveConfiguration>

Enables the interactive use cases to use when running an application.

Link copied to clipboard
val maximumCapacity: Output<ApplicationMaximumCapacity>

The maximum capacity to allocate when the application is created. This is cumulative across all workers at any given point in time, not just when an application is created. No new resources will be created once any one of the defined limits is hit.

Link copied to clipboard
val name: Output<String>

The name of the application.

Link copied to clipboard
val networkConfiguration: Output<ApplicationNetworkConfiguration>?

The network configuration for customer VPC connectivity.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val releaseLabel: Output<String>

The EMR release version associated with the application.

Link copied to clipboard
val tags: Output<Map<String, String>>?

Key-value mapping of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Link copied to clipboard
val tagsAll: Output<Map<String, String>>

Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

Link copied to clipboard
val type: Output<String>

The type of application you want to start, such as spark or hive.

Link copied to clipboard
val urn: Output<String>