pulumi-aws-kotlin/com.pulumi.aws.fsx.kotlin/WindowsFileSystemArgs

WindowsFileSystemArgs

data class WindowsFileSystemArgs(val activeDirectoryId: Output<String>? = null, val aliases: Output<List<String>>? = null, val auditLogConfiguration: Output<WindowsFileSystemAuditLogConfigurationArgs>? = null, val automaticBackupRetentionDays: Output<Int>? = null, val backupId: Output<String>? = null, val copyTagsToBackups: Output<Boolean>? = null, val dailyAutomaticBackupStartTime: Output<String>? = null, val deploymentType: Output<String>? = null, val diskIopsConfiguration: Output<WindowsFileSystemDiskIopsConfigurationArgs>? = null, val kmsKeyId: Output<String>? = null, val preferredSubnetId: Output<String>? = null, val securityGroupIds: Output<List<String>>? = null, val selfManagedActiveDirectory: Output<WindowsFileSystemSelfManagedActiveDirectoryArgs>? = null, val skipFinalBackup: Output<Boolean>? = null, val storageCapacity: Output<Int>? = null, val storageType: Output<String>? = null, val subnetIds: Output<List<String>>? = null, val tags: Output<Map<String, String>>? = null, val throughputCapacity: Output<Int>? = null, val weeklyMaintenanceStartTime: Output<String>? = null) : ConvertibleToJava<WindowsFileSystemArgs>

Manages a FSx Windows File System. See the FSx Windows Guide for more information.

NOTE: Either the active_directory_id argument or self_managed_active_directory configuration block must be specified.

Example Usage

Using AWS Directory Service

Additional information for using AWS Directory Service with Windows File Systems can be found in the FSx Windows Guide.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.fsx.WindowsFileSystem("example", {
    activeDirectoryId: exampleAwsDirectoryServiceDirectory.id,
    kmsKeyId: exampleAwsKmsKey.arn,
    storageCapacity: 300,
    subnetIds: [exampleAwsSubnet&#46;id],
    throughputCapacity: 1024,
});

import pulumi
import pulumi_aws as aws
example = aws.fsx.WindowsFileSystem("example",
    active_directory_id=example_aws_directory_service_directory["id"],
    kms_key_id=example_aws_kms_key["arn"],
    storage_capacity=300,
    subnet_ids=[example_aws_subnet["id"]],
    throughput_capacity=1024)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Fsx.WindowsFileSystem("example", new()
    {
        ActiveDirectoryId = exampleAwsDirectoryServiceDirectory.Id,
        KmsKeyId = exampleAwsKmsKey.Arn,
        StorageCapacity = 300,
        SubnetIds = new[]
        {
            exampleAwsSubnet.Id,
        },
        ThroughputCapacity = 1024,
    });
});

package main
import (
	"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.NewWindowsFileSystem(ctx, "example", &fsx.WindowsFileSystemArgs{
			ActiveDirectoryId: pulumi.Any(exampleAwsDirectoryServiceDirectory.Id),
			KmsKeyId:          pulumi.Any(exampleAwsKmsKey.Arn),
			StorageCapacity:   pulumi.Int(300),
			SubnetIds: pulumi.StringArray{
				exampleAwsSubnet.Id,
			},
			ThroughputCapacity: pulumi.Int(1024),
		})
		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.fsx.WindowsFileSystem;
import com.pulumi.aws.fsx.WindowsFileSystemArgs;
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 WindowsFileSystem("example", WindowsFileSystemArgs.builder()
            .activeDirectoryId(exampleAwsDirectoryServiceDirectory.id())
            .kmsKeyId(exampleAwsKmsKey.arn())
            .storageCapacity(300)
            .subnetIds(exampleAwsSubnet.id())
            .throughputCapacity(1024)
            .build());
    }
}

resources:
  example:
    type: aws:fsx:WindowsFileSystem
    properties:
      activeDirectoryId: ${exampleAwsDirectoryServiceDirectory.id}
      kmsKeyId: ${exampleAwsKmsKey.arn}
      storageCapacity: 300
      subnetIds:
        - ${exampleAwsSubnet.id}
      throughputCapacity: 1024

Using a Self-Managed Microsoft Active Directory

Additional information for using AWS Directory Service with Windows File Systems can be found in the FSx Windows Guide.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.fsx.WindowsFileSystem("example", {
    kmsKeyId: exampleAwsKmsKey.arn,
    storageCapacity: 300,
    subnetIds: [exampleAwsSubnet&#46;id],
    throughputCapacity: 1024,
    selfManagedActiveDirectory: {
        dnsIps: [
            "10.0.0.111",
            "10.0.0.222",
        ],
        domainName: "corp.example.com",
        password: "avoid-plaintext-passwords",
        username: "Admin",
    },
});

import pulumi
import pulumi_aws as aws
example = aws.fsx.WindowsFileSystem("example",
    kms_key_id=example_aws_kms_key["arn"],
    storage_capacity=300,
    subnet_ids=[example_aws_subnet["id"]],
    throughput_capacity=1024,
    self_managed_active_directory=aws.fsx.WindowsFileSystemSelfManagedActiveDirectoryArgs(
        dns_ips=[
            "10.0.0.111",
            "10.0.0.222",
        ],
        domain_name="corp.example.com",
        password="avoid-plaintext-passwords",
        username="Admin",
    ))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Fsx.WindowsFileSystem("example", new()
    {
        KmsKeyId = exampleAwsKmsKey.Arn,
        StorageCapacity = 300,
        SubnetIds = new[]
        {
            exampleAwsSubnet.Id,
        },
        ThroughputCapacity = 1024,
        SelfManagedActiveDirectory = new Aws.Fsx.Inputs.WindowsFileSystemSelfManagedActiveDirectoryArgs
        {
            DnsIps = new[]
            {
                "10.0.0.111",
                "10.0.0.222",
            },
            DomainName = "corp.example.com",
            Password = "avoid-plaintext-passwords",
            Username = "Admin",
        },
    });
});

package main
import (
	"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.NewWindowsFileSystem(ctx, "example", &fsx.WindowsFileSystemArgs{
			KmsKeyId:        pulumi.Any(exampleAwsKmsKey.Arn),
			StorageCapacity: pulumi.Int(300),
			SubnetIds: pulumi.StringArray{
				exampleAwsSubnet.Id,
			},
			ThroughputCapacity: pulumi.Int(1024),
			SelfManagedActiveDirectory: &fsx.WindowsFileSystemSelfManagedActiveDirectoryArgs{
				DnsIps: pulumi.StringArray{
					pulumi.String("10.0.0.111"),
					pulumi.String("10.0.0.222"),
				},
				DomainName: pulumi.String("corp.example.com"),
				Password:   pulumi.String("avoid-plaintext-passwords"),
				Username:   pulumi.String("Admin"),
			},
		})
		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.fsx.WindowsFileSystem;
import com.pulumi.aws.fsx.WindowsFileSystemArgs;
import com.pulumi.aws.fsx.inputs.WindowsFileSystemSelfManagedActiveDirectoryArgs;
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 WindowsFileSystem("example", WindowsFileSystemArgs.builder()
            .kmsKeyId(exampleAwsKmsKey.arn())
            .storageCapacity(300)
            .subnetIds(exampleAwsSubnet.id())
            .throughputCapacity(1024)
            .selfManagedActiveDirectory(WindowsFileSystemSelfManagedActiveDirectoryArgs.builder()
                .dnsIps(
                    "10.0.0.111",
                    "10.0.0.222")
                .domainName("corp.example.com")
                .password("avoid-plaintext-passwords")
                .username("Admin")
                .build())
            .build());
    }
}

resources:
  example:
    type: aws:fsx:WindowsFileSystem
    properties:
      kmsKeyId: ${exampleAwsKmsKey.arn}
      storageCapacity: 300
      subnetIds:
        - ${exampleAwsSubnet.id}
      throughputCapacity: 1024
      selfManagedActiveDirectory:
        dnsIps:
          - 10.0.0.111
          - 10.0.0.222
        domainName: corp.example.com
        password: avoid-plaintext-passwords
        username: Admin

Import

Using pulumi import, import FSx File Systems using the id. For example:

$ pulumi import aws:fsx/windowsFileSystem:WindowsFileSystem example fs-543ab12b1ca672f33

Certain resource arguments, like security_group_ids and the self_managed_active_directory configuation block password, do not have a FSx API method for reading the information after creation. If these arguments are 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:

Constructors

WindowsFileSystemArgs

fun WindowsFileSystemArgs(activeDirectoryId: Output<String>? = null, aliases: Output<List<String>>? = null, auditLogConfiguration: Output<WindowsFileSystemAuditLogConfigurationArgs>? = null, automaticBackupRetentionDays: Output<Int>? = null, backupId: Output<String>? = null, copyTagsToBackups: Output<Boolean>? = null, dailyAutomaticBackupStartTime: Output<String>? = null, deploymentType: Output<String>? = null, diskIopsConfiguration: Output<WindowsFileSystemDiskIopsConfigurationArgs>? = null, kmsKeyId: Output<String>? = null, preferredSubnetId: Output<String>? = null, securityGroupIds: Output<List<String>>? = null, selfManagedActiveDirectory: Output<WindowsFileSystemSelfManagedActiveDirectoryArgs>? = null, skipFinalBackup: Output<Boolean>? = null, storageCapacity: Output<Int>? = null, storageType: Output<String>? = null, subnetIds: Output<List<String>>? = null, tags: Output<Map<String, String>>? = null, throughputCapacity: Output<Int>? = null, weeklyMaintenanceStartTime: Output<String>? = null)

Functions

toJava

open override fun toJava(): WindowsFileSystemArgs

Properties

activeDirectoryId

val activeDirectoryId: Output<String>? = null

The ID for an existing Microsoft Active Directory instance that the file system should join when it's created. Cannot be specified with self_managed_active_directory.

aliases

val aliases: Output<List<String>>? = null

An array DNS alias names that you want to associate with the Amazon FSx file system. For more information, see Working with DNS Aliases

auditLogConfiguration

val auditLogConfiguration: Output<WindowsFileSystemAuditLogConfigurationArgs>? = null

The configuration that Amazon FSx for Windows File Server uses to audit and log user accesses of files, folders, and file shares on the Amazon FSx for Windows File Server file system. See Audit Log Configuration below.

automaticBackupRetentionDays

val automaticBackupRetentionDays: Output<Int>? = null

The number of days to retain automatic backups. Minimum of 0 and maximum of 90. Defaults to 7. Set to 0 to disable.

backupId

val backupId: Output<String>? = null

The ID of the source backup to create the filesystem from.

copyTagsToBackups

val copyTagsToBackups: Output<Boolean>? = null

A boolean flag indicating whether tags on the file system should be copied to backups. Defaults to false.

dailyAutomaticBackupStartTime

val dailyAutomaticBackupStartTime: Output<String>? = null

The preferred time (in HH:MM format) to take daily automatic backups, in the UTC time zone.

deploymentType

val deploymentType: Output<String>? = null

Specifies the file system deployment type, valid values are MULTI_AZ_1, SINGLE_AZ_1 and SINGLE_AZ_2. Default value is SINGLE_AZ_1.

diskIopsConfiguration

val diskIopsConfiguration: Output<WindowsFileSystemDiskIopsConfigurationArgs>? = null

The SSD IOPS configuration for the Amazon FSx for Windows File Server file system. See Disk Iops Configuration below.

kmsKeyId

val kmsKeyId: Output<String>? = null

ARN for the KMS Key to encrypt the file system at rest. Defaults to an AWS managed KMS Key.

preferredSubnetId

val preferredSubnetId: Output<String>? = null

Specifies the subnet in which you want the preferred file server to be located. Required for when deployment type is MULTI_AZ_1.

securityGroupIds

val securityGroupIds: Output<List<String>>? = 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.

selfManagedActiveDirectory

val selfManagedActiveDirectory: Output<WindowsFileSystemSelfManagedActiveDirectoryArgs>? = null

Configuration block that Amazon FSx uses to join the Windows File Server instance to your self-managed (including on-premises) Microsoft Active Directory (AD) directory. Cannot be specified with active_directory_id. See Self-Managed Active Directory below.

skipFinalBackup

val skipFinalBackup: Output<Boolean>? = 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 false.

storageCapacity

val storageCapacity: Output<Int>? = null

Storage capacity (GiB) of the file system. Minimum of 32 and maximum of 65536. If the storage type is set to HDD the minimum value is 2000. Required when not creating filesystem for a backup.

storageType

val storageType: Output<String>? = null

Specifies the storage type, Valid values are SSD and HDD. HDD is supported on SINGLE_AZ_2 and MULTI_AZ_1 Windows file system deployment types. Default value is SSD.

subnetIds

val subnetIds: Output<List<String>>? = null

A list of IDs for the subnets that the file system will be accessible from. To specify more than a single subnet set deployment_type to MULTI_AZ_1.