pulumi-aws-kotlin/com.pulumi.aws.efs.kotlin/FileSystemArgs

FileSystemArgs

data class FileSystemArgs(val availabilityZoneName: Output<String>? = null, val creationToken: Output<String>? = null, val encrypted: Output<Boolean>? = null, val kmsKeyId: Output<String>? = null, val lifecyclePolicies: Output<List<FileSystemLifecyclePolicyArgs>>? = null, val performanceMode: Output<String>? = null, val protection: Output<FileSystemProtectionArgs>? = null, val provisionedThroughputInMibps: Output<Double>? = null, val tags: Output<Map<String, String>>? = null, val throughputMode: Output<String>? = null) : ConvertibleToJava<FileSystemArgs>

Provides an Elastic File System (EFS) File System resource.

Example Usage

EFS File System w/ tags

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const foo = new aws.efs.FileSystem("foo", {
    creationToken: "my-product",
    tags: {
        Name: "MyProduct",
    },
});

import pulumi
import pulumi_aws as aws
foo = aws.efs.FileSystem("foo",
    creation_token="my-product",
    tags={
        "Name": "MyProduct",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var foo = new Aws.Efs.FileSystem("foo", new()
    {
        CreationToken = "my-product",
        Tags =
        {
            { "Name", "MyProduct" },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/efs"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := efs.NewFileSystem(ctx, "foo", &efs.FileSystemArgs{
			CreationToken: pulumi.String("my-product"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("MyProduct"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.efs.FileSystem;
import com.pulumi.aws.efs.FileSystemArgs;
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 foo = new FileSystem("foo", FileSystemArgs.builder()
            .creationToken("my-product")
            .tags(Map.of("Name", "MyProduct"))
            .build());
    }
}

resources:
  foo:
    type: aws:efs:FileSystem
    properties:
      creationToken: my-product
      tags:
        Name: MyProduct

Using lifecycle policy

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const fooWithLifecylePolicy = new aws.efs.FileSystem("foo_with_lifecyle_policy", {
    creationToken: "my-product",
    lifecyclePolicies: [{
        transitionToIa: "AFTER_30_DAYS",
    }],
});

import pulumi
import pulumi_aws as aws
foo_with_lifecyle_policy = aws.efs.FileSystem("foo_with_lifecyle_policy",
    creation_token="my-product",
    lifecycle_policies=[aws.efs.FileSystemLifecyclePolicyArgs(
        transition_to_ia="AFTER_30_DAYS",
    )])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var fooWithLifecylePolicy = new Aws.Efs.FileSystem("foo_with_lifecyle_policy", new()
    {
        CreationToken = "my-product",
        LifecyclePolicies = new[]
        {
            new Aws.Efs.Inputs.FileSystemLifecyclePolicyArgs
            {
                TransitionToIa = "AFTER_30_DAYS",
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/efs"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := efs.NewFileSystem(ctx, "foo_with_lifecyle_policy", &efs.FileSystemArgs{
			CreationToken: pulumi.String("my-product"),
			LifecyclePolicies: efs.FileSystemLifecyclePolicyArray{
				&efs.FileSystemLifecyclePolicyArgs{
					TransitionToIa: pulumi.String("AFTER_30_DAYS"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.efs.FileSystem;
import com.pulumi.aws.efs.FileSystemArgs;
import com.pulumi.aws.efs.inputs.FileSystemLifecyclePolicyArgs;
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 fooWithLifecylePolicy = new FileSystem("fooWithLifecylePolicy", FileSystemArgs.builder()
            .creationToken("my-product")
            .lifecyclePolicies(FileSystemLifecyclePolicyArgs.builder()
                .transitionToIa("AFTER_30_DAYS")
                .build())
            .build());
    }
}

resources:
  fooWithLifecylePolicy:
    type: aws:efs:FileSystem
    name: foo_with_lifecyle_policy
    properties:
      creationToken: my-product
      lifecyclePolicies:
        - transitionToIa: AFTER_30_DAYS

Import

Using pulumi import, import the EFS file systems using the id. For example:

$ pulumi import aws:efs/fileSystem:FileSystem foo fs-6fa144c6

Constructors

FileSystemArgs

fun FileSystemArgs(availabilityZoneName: Output<String>? = null, creationToken: Output<String>? = null, encrypted: Output<Boolean>? = null, kmsKeyId: Output<String>? = null, lifecyclePolicies: Output<List<FileSystemLifecyclePolicyArgs>>? = null, performanceMode: Output<String>? = null, protection: Output<FileSystemProtectionArgs>? = null, provisionedThroughputInMibps: Output<Double>? = null, tags: Output<Map<String, String>>? = null, throughputMode: Output<String>? = null)

Functions

toJava

open override fun toJava(): FileSystemArgs

Properties

availabilityZoneName

val availabilityZoneName: Output<String>? = null

the AWS Availability Zone in which to create the file system. Used to create a file system that uses One Zone storage classes. See user guide for more information.

creationToken

val creationToken: Output<String>? = null

A unique name (a maximum of 64 characters are allowed) used as reference when creating the Elastic File System to ensure idempotent file system creation. By default generated by this provider. See Elastic File System user guide for more information.

encrypted

val encrypted: Output<Boolean>? = null

If true, the disk will be encrypted.

kmsKeyId

val kmsKeyId: Output<String>? = null

The ARN for the KMS encryption key. When specifying kms_key_id, encrypted needs to be set to true.

lifecyclePolicies

val lifecyclePolicies: Output<List<FileSystemLifecyclePolicyArgs>>? = null

A file system lifecycle policy object. See lifecycle_policy block below for details.

performanceMode

val performanceMode: Output<String>? = null

The file system performance mode. Can be either "generalPurpose" or "maxIO" (Default: "generalPurpose").

protection

val protection: Output<FileSystemProtectionArgs>? = null

A file system protection object. See protection block below for details.

provisionedThroughputInMibps

val provisionedThroughputInMibps: Output<Double>? = null

The throughput, measured in MiB/s, that you want to provision for the file system. Only applicable with throughput_mode set to provisioned.