WindowsFileSystem class

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

> NOTE: Either the activeDirectoryId argument or selfManagedActiveDirectory 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: 32,
    subnetIds: [exampleAwsSubnet.id],
    throughputCapacity: 32,
});
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=32,
    subnet_ids=[example_aws_subnet["id"]],
    throughput_capacity=32)
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 = 32,
        SubnetIds = new[]
        {
            exampleAwsSubnet.Id,
        },
        ThroughputCapacity = 32,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/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(32),
			SubnetIds: pulumi.StringArray{
				exampleAwsSubnet.Id,
			},
			ThroughputCapacity: pulumi.Int(32),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_fsx_windowsfilesystem" "example" {
  active_directory_id = exampleAwsDirectoryServiceDirectory.id
  kms_key_id          = exampleAwsKmsKey.arn
  storage_capacity    = 32
  subnet_ids          = [exampleAwsSubnet.id]
  throughput_capacity = 32
}
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.ArrayList;
import java.util.Arrays;
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(32)
            .subnetIds(exampleAwsSubnet.id())
            .throughputCapacity(32)
            .build());

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

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", {
    selfManagedActiveDirectory: {
        dnsIps: [
            "10.0.0.111",
            "10.0.0.222",
        ],
        domainName: "corp.example.com",
        password: "avoid-plaintext-passwords",
        username: "Admin",
    },
    kmsKeyId: exampleAwsKmsKey.arn,
    storageCapacity: 32,
    subnetIds: [exampleAwsSubnet.id],
    throughputCapacity: 32,
});
import pulumi
import pulumi_aws as aws

example = aws.fsx.WindowsFileSystem("example",
    self_managed_active_directory={
        "dns_ips": [
            "10.0.0.111",
            "10.0.0.222",
        ],
        "domain_name": "corp.example.com",
        "password": "avoid-plaintext-passwords",
        "username": "Admin",
    },
    kms_key_id=example_aws_kms_key["arn"],
    storage_capacity=32,
    subnet_ids=[example_aws_subnet["id"]],
    throughput_capacity=32)
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()
    {
        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",
        },
        KmsKeyId = exampleAwsKmsKey.Arn,
        StorageCapacity = 32,
        SubnetIds = new[]
        {
            exampleAwsSubnet.Id,
        },
        ThroughputCapacity = 32,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/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{
			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"),
			},
			KmsKeyId:        pulumi.Any(exampleAwsKmsKey.Arn),
			StorageCapacity: pulumi.Int(32),
			SubnetIds: pulumi.StringArray{
				exampleAwsSubnet.Id,
			},
			ThroughputCapacity: pulumi.Int(32),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_fsx_windowsfilesystem" "example" {
  self_managed_active_directory = {
    dns_ips     = ["10.0.0.111", "10.0.0.222"]
    domain_name = "corp.example.com"
    password    = "avoid-plaintext-passwords"
    username    = "Admin"
  }
  kms_key_id          = exampleAwsKmsKey.arn
  storage_capacity    = 32
  subnet_ids          = [exampleAwsSubnet.id]
  throughput_capacity = 32
}
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.ArrayList;
import java.util.Arrays;
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()
            .selfManagedActiveDirectory(WindowsFileSystemSelfManagedActiveDirectoryArgs.builder()
                .dnsIps(
                    "10.0.0.111",
                    "10.0.0.222")
                .domainName("corp.example.com")
                .password("avoid-plaintext-passwords")
                .username("Admin")
                .build())
            .kmsKeyId(exampleAwsKmsKey.arn())
            .storageCapacity(32)
            .subnetIds(exampleAwsSubnet.id())
            .throughputCapacity(32)
            .build());

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

Using a Self-Managed Microsoft Active Directory with Secrets Manager

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.fsx.WindowsFileSystem("example", {
    selfManagedActiveDirectory: {
        dnsIps: [
            "10.0.0.111",
            "10.0.0.222",
        ],
        domainName: "corp.example.com",
        domainJoinServiceAccountSecret: exampleAwsSecretsmanagerSecret.arn,
    },
    kmsKeyId: exampleAwsKmsKey.arn,
    storageCapacity: 32,
    subnetIds: [exampleAwsSubnet.id],
    throughputCapacity: 32,
});
import pulumi
import pulumi_aws as aws

example = aws.fsx.WindowsFileSystem("example",
    self_managed_active_directory={
        "dns_ips": [
            "10.0.0.111",
            "10.0.0.222",
        ],
        "domain_name": "corp.example.com",
        "domain_join_service_account_secret": example_aws_secretsmanager_secret["arn"],
    },
    kms_key_id=example_aws_kms_key["arn"],
    storage_capacity=32,
    subnet_ids=[example_aws_subnet["id"]],
    throughput_capacity=32)
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()
    {
        SelfManagedActiveDirectory = new Aws.Fsx.Inputs.WindowsFileSystemSelfManagedActiveDirectoryArgs
        {
            DnsIps = new[]
            {
                "10.0.0.111",
                "10.0.0.222",
            },
            DomainName = "corp.example.com",
            DomainJoinServiceAccountSecret = exampleAwsSecretsmanagerSecret.Arn,
        },
        KmsKeyId = exampleAwsKmsKey.Arn,
        StorageCapacity = 32,
        SubnetIds = new[]
        {
            exampleAwsSubnet.Id,
        },
        ThroughputCapacity = 32,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/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{
			SelfManagedActiveDirectory: &fsx.WindowsFileSystemSelfManagedActiveDirectoryArgs{
				DnsIps: pulumi.StringArray{
					pulumi.String("10.0.0.111"),
					pulumi.String("10.0.0.222"),
				},
				DomainName:                     pulumi.String("corp.example.com"),
				DomainJoinServiceAccountSecret: pulumi.Any(exampleAwsSecretsmanagerSecret.Arn),
			},
			KmsKeyId:        pulumi.Any(exampleAwsKmsKey.Arn),
			StorageCapacity: pulumi.Int(32),
			SubnetIds: pulumi.StringArray{
				exampleAwsSubnet.Id,
			},
			ThroughputCapacity: pulumi.Int(32),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_fsx_windowsfilesystem" "example" {
  self_managed_active_directory = {
    dns_ips                            = ["10.0.0.111", "10.0.0.222"]
    domain_name                        = "corp.example.com"
    domain_join_service_account_secret = exampleAwsSecretsmanagerSecret.arn
  }
  kms_key_id          = exampleAwsKmsKey.arn
  storage_capacity    = 32
  subnet_ids          = [exampleAwsSubnet.id]
  throughput_capacity = 32
}
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.ArrayList;
import java.util.Arrays;
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()
            .selfManagedActiveDirectory(WindowsFileSystemSelfManagedActiveDirectoryArgs.builder()
                .dnsIps(
                    "10.0.0.111",
                    "10.0.0.222")
                .domainName("corp.example.com")
                .domainJoinServiceAccountSecret(exampleAwsSecretsmanagerSecret.arn())
                .build())
            .kmsKeyId(exampleAwsKmsKey.arn())
            .storageCapacity(32)
            .subnetIds(exampleAwsSubnet.id())
            .throughputCapacity(32)
            .build());

    }
}
resources:
  example:
    type: aws:fsx:WindowsFileSystem
    properties:
      selfManagedActiveDirectory:
        dnsIps:
          - 10.0.0.111
          - 10.0.0.222
        domainName: corp.example.com
        domainJoinServiceAccountSecret: ${exampleAwsSecretsmanagerSecret.arn}
      kmsKeyId: ${exampleAwsKmsKey.arn}
      storageCapacity: 32
      subnetIds:
        - ${exampleAwsSubnet.id}
      throughputCapacity: 32

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 securityGroupIds and the selfManagedActiveDirectory 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 ignoreChanges to hide the difference. For example:

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.fsx.WindowsFileSystem("example", {securityGroupIds: [exampleAwsSecurityGroup.id]}, {
    ignoreChanges: ["securityGroupIds"],
});
import pulumi
import pulumi_aws as aws

example = aws.fsx.WindowsFileSystem("example", security_group_ids=[example_aws_security_group["id"]],
opts = pulumi.ResourceOptions(ignore_changes=["securityGroupIds"]))
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()
    {
        SecurityGroupIds = new[]
        {
            exampleAwsSecurityGroup.Id,
        },
    }, new CustomResourceOptions
    {
        IgnoreChanges =
        {
            "securityGroupIds",
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/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{
			SecurityGroupIds: pulumi.StringArray{
				exampleAwsSecurityGroup.Id,
			},
		}, pulumi.IgnoreChanges([]string{
			"securityGroupIds",
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_fsx_windowsfilesystem" "example" {
  lifecycle {
    ignore_changes = [securityGroupIds]
  }
  security_group_ids = [exampleAwsSecurityGroup.id]
}
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.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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()
            .securityGroupIds(exampleAwsSecurityGroup.id())
            .build(), CustomResourceOptions.builder()
                .ignoreChanges("securityGroupIds")
                .build());

    }
}
resources:
  example:
    type: aws:fsx:WindowsFileSystem
    properties:
      securityGroupIds:
        - ${exampleAwsSecurityGroup.id}
    options:
      ignoreChanges:
        - securityGroupIds

Constructors

WindowsFileSystem(String name, {WindowsFileSystemArgs? args, CustomResourceOptions? options})
Creates a new WindowsFileSystem. name The Pulumi resource name. args Arguments used to configure this WindowsFileSystem. The set of arguments for WindowsFileSystem. options Resource options controlling this resource's behavior.
WindowsFileSystem.reference(String urn)
Creates a typed reference to an existing WindowsFileSystem resource.

Properties

activeDirectoryId ↔ Output<String?>
ID for an existing Microsoft Active Directory instance that the file system should join when it's created. Cannot be specified with selfManagedActiveDirectory.
latefinal
aliases ↔ Output<List<String>?>
Array DNS alias names that you want to associate with the Amazon FSx file system. For more information, see Working with DNS Aliases
latefinal
arn ↔ Output<String>
ARN of the file system.
latefinal
auditLogConfiguration ↔ Output<WindowsFileSystemAuditLogConfiguration>
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 auditLogConfiguration Block for details.
latefinal
automaticBackupRetentionDays ↔ Output<int?>
Number of days to retain automatic backups. Minimum of 0 and maximum of 90. Defaults to 7. Set to 0 to disable.
latefinal
backupId ↔ Output<String?>
ID of the source backup to create the filesystem from.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
copyTagsToBackups ↔ Output<bool?>
Whether to copy tags on the file system to backups. Defaults to false.
latefinal
dailyAutomaticBackupStartTime ↔ Output<String>
Preferred time (in HH:MM format) to take daily automatic backups, in the UTC time zone.
latefinal
deploymentType ↔ Output<String?>
File system deployment type. Valid values are MULTI_AZ_1, SINGLE_AZ_1 and SINGLE_AZ_2. Default value is SINGLE_AZ_1.
latefinal
diskIopsConfiguration ↔ Output<WindowsFileSystemDiskIopsConfiguration>
SSD IOPS configuration for the Amazon FSx for Windows File Server file system. See diskIopsConfiguration Block for details.
latefinal
dnsName ↔ Output<String>
DNS name for the file system, e.g., fs-12345678.corp.example.com (domain name matching the Active Directory domain name)
latefinal
finalBackupTags ↔ Output<Map<String, String>?>
Map of tags to apply to the file system's final backup.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
kmsKeyId ↔ Output<String>
ARN for the KMS Key to encrypt the file system at rest. Defaults to an AWS managed KMS Key.
latefinal
networkInterfaceIds ↔ Output<List<String>>
Set of Elastic Network Interface identifiers from which the file system is accessible.
latefinal
networkType ↔ Output<String>
Network type. Valid values are IPV4 and DUAL. Default value is IPV4.
latefinal
ownerId ↔ Output<String>
AWS account identifier that created the file system.
latefinal
preferredFileServerIp ↔ Output<String>
IP address of the primary, or preferred, file server.
latefinal
preferredSubnetId ↔ Output<String>
Subnet in which you want the preferred file server to be located. Required for when deployment type is MULTI_AZ_1.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
remoteAdministrationEndpoint ↔ Output<String>
For MULTI_AZ_1 deployment types, use this endpoint when performing administrative tasks on the file system using Amazon FSx Remote PowerShell. For SINGLE_AZ_1 deployment types, this is the DNS name of the file system.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
securityGroupIds ↔ Output<List<String>?>
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.
latefinal
selfManagedActiveDirectory ↔ Output<WindowsFileSystemSelfManagedActiveDirectory?>
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 activeDirectoryId. See selfManagedActiveDirectory Block for details.
latefinal
skipFinalBackup ↔ Output<bool?>
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.
latefinal
storageCapacity ↔ Output<int>
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.
latefinal
storageType ↔ Output<String?>
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.
latefinal
subnetIds ↔ Output<List<String>>
List of IDs for the subnets that the file system will be accessible from. To specify more than a single subnet set deploymentType to MULTI_AZ_1.
latefinal
tags ↔ Output<Map<String, String>?>
Map of tags to assign to the file system. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
throughputCapacity ↔ Output<int>
Throughput (megabytes per second) of the file system. For valid values, refer to the AWS documentation.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
vpcId ↔ Output<String>
Identifier of the VPC for the file system.
latefinal
weeklyMaintenanceStartTime ↔ Output<String>
Preferred start time (in d:HH:MM format) to perform weekly maintenance, in the UTC time zone.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {WindowsFileSystemState? state, CustomResourceOptions? options}) → WindowsFileSystem
Gets an existing WindowsFileSystem resource's state with the given name and id.