Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
@file:Suppress("NAME_SHADOWING", "DEPRECATION")
package com.pulumi.aws.fsx.kotlin
import com.pulumi.aws.fsx.kotlin.outputs.LustreFileSystemLogConfiguration
import com.pulumi.aws.fsx.kotlin.outputs.LustreFileSystemMetadataConfiguration
import com.pulumi.aws.fsx.kotlin.outputs.LustreFileSystemRootSquashConfiguration
import com.pulumi.core.Output
import com.pulumi.kotlin.KotlinCustomResource
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.ResourceMapper
import com.pulumi.kotlin.options.CustomResourceOptions
import com.pulumi.kotlin.options.CustomResourceOptionsBuilder
import com.pulumi.resources.Resource
import kotlin.Boolean
import kotlin.Deprecated
import kotlin.Int
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import com.pulumi.aws.fsx.kotlin.outputs.LustreFileSystemLogConfiguration.Companion.toKotlin as lustreFileSystemLogConfigurationToKotlin
import com.pulumi.aws.fsx.kotlin.outputs.LustreFileSystemMetadataConfiguration.Companion.toKotlin as lustreFileSystemMetadataConfigurationToKotlin
import com.pulumi.aws.fsx.kotlin.outputs.LustreFileSystemRootSquashConfiguration.Companion.toKotlin as lustreFileSystemRootSquashConfigurationToKotlin
/**
* Builder for [LustreFileSystem].
*/
@PulumiTagMarker
public class LustreFileSystemResourceBuilder internal constructor() {
public var name: String? = null
public var args: LustreFileSystemArgs = LustreFileSystemArgs()
public var opts: CustomResourceOptions = CustomResourceOptions()
/**
* @param name The _unique_ name of the resulting resource.
*/
public fun name(`value`: String) {
this.name = value
}
/**
* @param block The arguments to use to populate this resource's properties.
*/
public suspend fun args(block: suspend LustreFileSystemArgsBuilder.() -> Unit) {
val builder = LustreFileSystemArgsBuilder()
block(builder)
this.args = builder.build()
}
/**
* @param block A bag of options that control this resource's behavior.
*/
public suspend fun opts(block: suspend CustomResourceOptionsBuilder.() -> Unit) {
this.opts = com.pulumi.kotlin.options.CustomResourceOptions.opts(block)
}
internal fun build(): LustreFileSystem {
val builtJavaResource = com.pulumi.aws.fsx.LustreFileSystem(
this.name,
this.args.toJava(),
this.opts.toJava(),
)
return LustreFileSystem(builtJavaResource)
}
}
/**
* Manages a FSx Lustre File System. See the [FSx Lustre Guide](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) for more information.
* > **NOTE:** `auto_import_policy`, `export_path`, `import_path` and `imported_file_chunk_size` are not supported with the `PERSISTENT_2` deployment type. Use `aws.fsx.DataRepositoryAssociation` instead.
* ## Example Usage
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as aws from "@pulumi/aws";
* const example = new aws.fsx.LustreFileSystem("example", {
* importPath: `s3://${exampleAwsS3Bucket.bucket}`,
* storageCapacity: 1200,
* subnetIds: exampleAwsSubnet.id,
* });
* ```
* ```python
* import pulumi
* import pulumi_aws as aws
* example = aws.fsx.LustreFileSystem("example",
* import_path=f"s3://{example_aws_s3_bucket['bucket']}",
* storage_capacity=1200,
* subnet_ids=example_aws_subnet["id"])
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Aws = Pulumi.Aws;
* return await Deployment.RunAsync(() =>
* {
* var example = new Aws.Fsx.LustreFileSystem("example", new()
* {
* ImportPath = $"s3://{exampleAwsS3Bucket.Bucket}",
* StorageCapacity = 1200,
* SubnetIds = exampleAwsSubnet.Id,
* });
* });
* ```
* ```go
* package main
* import (
* "fmt"
* "github.com/pulumi/pulumi-aws/sdk/v6/go/aws/fsx"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* _, err := fsx.NewLustreFileSystem(ctx, "example", &fsx.LustreFileSystemArgs{
* ImportPath: pulumi.Sprintf("s3://%v", exampleAwsS3Bucket.Bucket),
* StorageCapacity: pulumi.Int(1200),
* SubnetIds: pulumi.Any(exampleAwsSubnet.Id),
* })
* if err != nil {
* return err
* }
* return nil
* })
* }
* ```
* ```java
* package generated_program;
* import com.pulumi.Context;
* import com.pulumi.Pulumi;
* import com.pulumi.core.Output;
* import com.pulumi.aws.fsx.LustreFileSystem;
* import com.pulumi.aws.fsx.LustreFileSystemArgs;
* 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 LustreFileSystem("example", LustreFileSystemArgs.builder()
* .importPath(String.format("s3://%s", exampleAwsS3Bucket.bucket()))
* .storageCapacity(1200)
* .subnetIds(exampleAwsSubnet.id())
* .build());
* }
* }
* ```
* ```yaml
* resources:
* example:
* type: aws:fsx:LustreFileSystem
* properties:
* importPath: s3://${exampleAwsS3Bucket.bucket}
* storageCapacity: 1200
* subnetIds: ${exampleAwsSubnet.id}
* ```
*
* ## Import
* Using `pulumi import`, import FSx File Systems using the `id`. For example:
* ```sh
* $ pulumi import aws:fsx/lustreFileSystem:LustreFileSystem example fs-543ab12b1ca672f33
* ```
* Certain resource arguments, like `security_group_ids`, do not have a FSx API method for reading the information after creation. If the argument is set in the Pulumi program on an imported resource, Pulumi will always show a difference. To workaround this behavior, either omit the argument from the Pulumi program or use `ignore_changes` to hide the difference. For example:
*/
public class LustreFileSystem internal constructor(
override val javaResource: com.pulumi.aws.fsx.LustreFileSystem,
) : KotlinCustomResource(javaResource, LustreFileSystemMapper) {
/**
* Amazon Resource Name of the file system.
*/
public val arn: Output
get() = javaResource.arn().applyValue({ args0 -> args0 })
/**
* How Amazon FSx keeps your file and directory listings up to date as you add or modify objects in your linked S3 bucket. see [Auto Import Data Repo](https://docs.aws.amazon.com/fsx/latest/LustreGuide/autoimport-data-repo.html) for more details. Only supported on `PERSISTENT_1` deployment types.
*/
public val autoImportPolicy: Output
get() = javaResource.autoImportPolicy().applyValue({ args0 -> args0 })
/**
* The number of days to retain automatic backups. Setting this to 0 disables automatic backups. You can retain automatic backups for a maximum of 90 days. only valid for `PERSISTENT_1` and `PERSISTENT_2` deployment_type.
*/
public val automaticBackupRetentionDays: Output
get() = javaResource.automaticBackupRetentionDays().applyValue({ args0 -> args0 })
/**
* The ID of the source backup to create the filesystem from.
*/
public val backupId: Output?
get() = javaResource.backupId().applyValue({ args0 -> args0.map({ args0 -> args0 }).orElse(null) })
/**
* A boolean flag indicating whether tags for the file system should be copied to backups. Applicable for `PERSISTENT_1` and `PERSISTENT_2` deployment_type. The default value is false.
*/
public val copyTagsToBackups: Output?
get() = javaResource.copyTagsToBackups().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* A recurring daily time, in the format HH:MM. HH is the zero-padded hour of the day (0-23), and MM is the zero-padded minute of the hour. For example, 05:00 specifies 5 AM daily. only valid for `PERSISTENT_1` and `PERSISTENT_2` deployment_type. Requires `automatic_backup_retention_days` to be set.
*/
public val dailyAutomaticBackupStartTime: Output
get() = javaResource.dailyAutomaticBackupStartTime().applyValue({ args0 -> args0 })
/**
* Sets the data compression configuration for the file system. Valid values are `LZ4` and `NONE`. Default value is `NONE`. Unsetting this value reverts the compression type back to `NONE`.
*/
public val dataCompressionType: Output?
get() = javaResource.dataCompressionType().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The filesystem deployment type. One of: `SCRATCH_1`, `SCRATCH_2`, `PERSISTENT_1`, `PERSISTENT_2`.
*/
public val deploymentType: Output?
get() = javaResource.deploymentType().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* DNS name for the file system, e.g., `fs-12345678.fsx.us-west-2.amazonaws.com`
*/
public val dnsName: Output
get() = javaResource.dnsName().applyValue({ args0 -> args0 })
/**
* The type of drive cache used by `PERSISTENT_1` filesystems that are provisioned with `HDD` storage_type. Required for `HDD` storage_type, set to either `READ` or `NONE`.
*/
public val driveCacheType: Output?
get() = javaResource.driveCacheType().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* S3 URI (with optional prefix) where the root of your Amazon FSx file system is exported. Can only be specified with `import_path` argument and the path must use the same Amazon S3 bucket as specified in `import_path`. Set equal to `import_path` to overwrite files on export. Defaults to `s3://{IMPORT BUCKET}/FSxLustre{CREATION TIMESTAMP}`. Only supported on `PERSISTENT_1` deployment types.
*/
public val exportPath: Output
get() = javaResource.exportPath().applyValue({ args0 -> args0 })
/**
* Sets the Lustre version for the file system that you're creating. Valid values are 2.10 for `SCRATCH_1`, `SCRATCH_2` and `PERSISTENT_1` deployment types. Valid values for 2.12 include all deployment types.
*/
public val fileSystemTypeVersion: Output
get() = javaResource.fileSystemTypeVersion().applyValue({ args0 -> args0 })
/**
* A map of tags to apply to the file system's final backup.
* **Note:** If the filesystem uses a Scratch deployment type, final backup during delete will always be skipped and this argument will not be used even when set.
*/
public val finalBackupTags: Output>?
get() = javaResource.finalBackupTags().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 -> args0.key.to(args0.value) }).toMap()
}).orElse(null)
})
/**
* S3 URI (with optional prefix) that you're using as the data repository for your FSx for Lustre file system. For example, `s3://example-bucket/optional-prefix/`. Only supported on `PERSISTENT_1` deployment types.
*/
public val importPath: Output?
get() = javaResource.importPath().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* For files imported from a data repository, this value determines the stripe count and maximum amount of data per file (in MiB) stored on a single physical disk. Can only be specified with `import_path` argument. Defaults to `1024`. Minimum of `1` and maximum of `512000`. Only supported on `PERSISTENT_1` deployment types.
*/
public val importedFileChunkSize: Output
get() = javaResource.importedFileChunkSize().applyValue({ args0 -> args0 })
/**
* ARN for the KMS Key to encrypt the file system at rest, applicable for `PERSISTENT_1` and `PERSISTENT_2` deployment_type. Defaults to an AWS managed KMS Key.
*/
public val kmsKeyId: Output
get() = javaResource.kmsKeyId().applyValue({ args0 -> args0 })
/**
* The Lustre logging configuration used when creating an Amazon FSx for Lustre file system. When logging is enabled, Lustre logs error and warning events for data repositories associated with your file system to Amazon CloudWatch Logs. See `log_configuration` Block for details.
*/
public val logConfiguration: Output
get() = javaResource.logConfiguration().applyValue({ args0 ->
args0.let({ args0 ->
lustreFileSystemLogConfigurationToKotlin(args0)
})
})
/**
* The Lustre metadata configuration used when creating an Amazon FSx for Lustre file system. This can be used to specify a user provisioned metadata scale. This is only supported when `deployment_type` is set to `PERSISTENT_2`. See `metadata_configuration` Block for details.
*/
public val metadataConfiguration: Output
get() = javaResource.metadataConfiguration().applyValue({ args0 ->
args0.let({ args0 ->
lustreFileSystemMetadataConfigurationToKotlin(args0)
})
})
/**
* The value to be used when mounting the filesystem.
*/
public val mountName: Output
get() = javaResource.mountName().applyValue({ args0 -> args0 })
/**
* Set of Elastic Network Interface identifiers from which the file system is accessible. As explained in the [documentation](https://docs.aws.amazon.com/fsx/latest/LustreGuide/mounting-on-premises.html), the first network interface returned is the primary network interface.
*/
public val networkInterfaceIds: Output>
get() = javaResource.networkInterfaceIds().applyValue({ args0 -> args0.map({ args0 -> args0 }) })
/**
* AWS account identifier that created the file system.
*/
public val ownerId: Output
get() = javaResource.ownerId().applyValue({ args0 -> args0 })
/**
* Describes the amount of read and write throughput for each 1 tebibyte of storage, in MB/s/TiB, required for the `PERSISTENT_1` and `PERSISTENT_2` deployment_type. Valid values for `PERSISTENT_1` deployment_type and `SSD` storage_type are 50, 100, 200. Valid values for `PERSISTENT_1` deployment_type and `HDD` storage_type are 12, 40. Valid values for `PERSISTENT_2` deployment_type and ` SSD` storage_type are 125, 250, 500, 1000.
*/
public val perUnitStorageThroughput: Output?
get() = javaResource.perUnitStorageThroughput().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The Lustre root squash configuration used when creating an Amazon FSx for Lustre file system. When enabled, root squash restricts root-level access from clients that try to access your file system as a root user. See `root_squash_configuration` Block for details.
*/
public val rootSquashConfiguration: Output?
get() = javaResource.rootSquashConfiguration().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 ->
lustreFileSystemRootSquashConfigurationToKotlin(args0)
})
}).orElse(null)
})
/**
* A list of IDs for the security groups that apply to the specified network interfaces created for file system access. These security groups will apply to all network interfaces.
*/
public val securityGroupIds: Output>?
get() = javaResource.securityGroupIds().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 -> args0 })
}).orElse(null)
})
/**
* When enabled, will skip the default final backup taken when the file system is deleted. This configuration must be applied separately before attempting to delete the resource to have the desired behavior. Defaults to `true`.
* **Note:** If the filesystem uses a Scratch deployment type, final backup during delete will always be skipped and this argument will not be used even when set.
*/
public val skipFinalBackup: Output?
get() = javaResource.skipFinalBackup().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The storage capacity (GiB) of the file system. Minimum of `1200`. See more details at [Allowed values for Fsx storage capacity](https://docs.aws.amazon.com/fsx/latest/APIReference/API_CreateFileSystem.html#FSx-CreateFileSystem-request-StorageCapacity). Update is allowed only for `SCRATCH_2`, `PERSISTENT_1` and `PERSISTENT_2` deployment types, See more details at [Fsx Storage Capacity Update](https://docs.aws.amazon.com/fsx/latest/APIReference/API_UpdateFileSystem.html#FSx-UpdateFileSystem-request-StorageCapacity). Required when not creating filesystem for a backup.
*/
public val storageCapacity: Output?
get() = javaResource.storageCapacity().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The filesystem storage type. Either `SSD` or `HDD`, defaults to `SSD`. `HDD` is only supported on `PERSISTENT_1` deployment types.
*/
public val storageType: Output?
get() = javaResource.storageType().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* A list of IDs for the subnets that the file system will be accessible from. File systems currently support only one subnet. The file server is also launched in that subnet's Availability Zone.
* The following arguments are optional:
*/
public val subnetIds: Output
get() = javaResource.subnetIds().applyValue({ args0 -> args0 })
/**
* A map of tags to assign to the file system. .If configured with a provider `default_tags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
*/
public val tags: Output>?
get() = javaResource.tags().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 ->
args0.key.to(args0.value)
}).toMap()
}).orElse(null)
})
/**
* A map of tags assigned to the resource, including those inherited from the provider `default_tags` configuration block.
*/
@Deprecated(
message = """
Please use `tags` instead.
""",
)
public val tagsAll: Output>
get() = javaResource.tagsAll().applyValue({ args0 ->
args0.map({ args0 ->
args0.key.to(args0.value)
}).toMap()
})
/**
* Identifier of the Virtual Private Cloud for the file system.
*/
public val vpcId: Output
get() = javaResource.vpcId().applyValue({ args0 -> args0 })
/**
* The preferred start time (in `d:HH:MM` format) to perform weekly maintenance, in the UTC time zone.
*/
public val weeklyMaintenanceStartTime: Output
get() = javaResource.weeklyMaintenanceStartTime().applyValue({ args0 -> args0 })
}
public object LustreFileSystemMapper : ResourceMapper {
override fun supportsMappingOfType(javaResource: Resource): Boolean =
com.pulumi.aws.fsx.LustreFileSystem::class == javaResource::class
override fun map(javaResource: Resource): LustreFileSystem = LustreFileSystem(
javaResource as
com.pulumi.aws.fsx.LustreFileSystem,
)
}
/**
* @see [LustreFileSystem].
* @param name The _unique_ name of the resulting resource.
* @param block Builder for [LustreFileSystem].
*/
public suspend fun lustreFileSystem(
name: String,
block: suspend LustreFileSystemResourceBuilder.() -> Unit,
): LustreFileSystem {
val builder = LustreFileSystemResourceBuilder()
builder.name(name)
block(builder)
return builder.build()
}
/**
* @see [LustreFileSystem].
* @param name The _unique_ name of the resulting resource.
*/
public fun lustreFileSystem(name: String): LustreFileSystem {
val builder = LustreFileSystemResourceBuilder()
builder.name(name)
return builder.build()
}
