OntapVolume class

Manages a FSx ONTAP Volume. See the FSx ONTAP User Guide for more information.

Example Usage

Basic Usage

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

const test = new aws.fsx.OntapVolume("test", {
    name: "test",
    junctionPath: "/test",
    sizeInMegabytes: 1024,
    storageEfficiencyEnabled: true,
    storageVirtualMachineId: testAwsFsxOntapStorageVirtualMachine.id,
});
import pulumi
import pulumi_aws as aws

test = aws.fsx.OntapVolume("test",
    name="test",
    junction_path="/test",
    size_in_megabytes=1024,
    storage_efficiency_enabled=True,
    storage_virtual_machine_id=test_aws_fsx_ontap_storage_virtual_machine["id"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var test = new Aws.Fsx.OntapVolume("test", new()
    {
        Name = "test",
        JunctionPath = "/test",
        SizeInMegabytes = 1024,
        StorageEfficiencyEnabled = true,
        StorageVirtualMachineId = testAwsFsxOntapStorageVirtualMachine.Id,
    });

});
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.NewOntapVolume(ctx, "test", &fsx.OntapVolumeArgs{
			Name:                     pulumi.String("test"),
			JunctionPath:             pulumi.String("/test"),
			SizeInMegabytes:          pulumi.Int(1024),
			StorageEfficiencyEnabled: pulumi.Bool(true),
			StorageVirtualMachineId:  pulumi.Any(testAwsFsxOntapStorageVirtualMachine.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_fsx_ontapvolume" "test" {
  name                       = "test"
  junction_path              = "/test"
  size_in_megabytes          = 1024
  storage_efficiency_enabled = true
  storage_virtual_machine_id = testAwsFsxOntapStorageVirtualMachine.id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.fsx.OntapVolume;
import com.pulumi.aws.fsx.OntapVolumeArgs;
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 test = new OntapVolume("test", OntapVolumeArgs.builder()
            .name("test")
            .junctionPath("/test")
            .sizeInMegabytes(1024)
            .storageEfficiencyEnabled(true)
            .storageVirtualMachineId(testAwsFsxOntapStorageVirtualMachine.id())
            .build());

    }
}
resources:
  test:
    type: aws:fsx:OntapVolume
    properties:
      name: test
      junctionPath: /test
      sizeInMegabytes: 1024
      storageEfficiencyEnabled: true
      storageVirtualMachineId: ${testAwsFsxOntapStorageVirtualMachine.id}

Using Tiering Policy

Additional information on tiering policy with ONTAP Volumes can be found in the FSx ONTAP Guide.

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

const test = new aws.fsx.OntapVolume("test", {
    tieringPolicy: {
        name: "AUTO",
        coolingPeriod: 31,
    },
    name: "test",
    junctionPath: "/test",
    sizeInMegabytes: 1024,
    storageEfficiencyEnabled: true,
    storageVirtualMachineId: testAwsFsxOntapStorageVirtualMachine.id,
});
import pulumi
import pulumi_aws as aws

test = aws.fsx.OntapVolume("test",
    tiering_policy={
        "name": "AUTO",
        "cooling_period": 31,
    },
    name="test",
    junction_path="/test",
    size_in_megabytes=1024,
    storage_efficiency_enabled=True,
    storage_virtual_machine_id=test_aws_fsx_ontap_storage_virtual_machine["id"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var test = new Aws.Fsx.OntapVolume("test", new()
    {
        TieringPolicy = new Aws.Fsx.Inputs.OntapVolumeTieringPolicyArgs
        {
            Name = "AUTO",
            CoolingPeriod = 31,
        },
        Name = "test",
        JunctionPath = "/test",
        SizeInMegabytes = 1024,
        StorageEfficiencyEnabled = true,
        StorageVirtualMachineId = testAwsFsxOntapStorageVirtualMachine.Id,
    });

});
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.NewOntapVolume(ctx, "test", &fsx.OntapVolumeArgs{
			TieringPolicy: &fsx.OntapVolumeTieringPolicyArgs{
				Name:          pulumi.String("AUTO"),
				CoolingPeriod: pulumi.Int(31),
			},
			Name:                     pulumi.String("test"),
			JunctionPath:             pulumi.String("/test"),
			SizeInMegabytes:          pulumi.Int(1024),
			StorageEfficiencyEnabled: pulumi.Bool(true),
			StorageVirtualMachineId:  pulumi.Any(testAwsFsxOntapStorageVirtualMachine.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_fsx_ontapvolume" "test" {
  tiering_policy = {
    name           = "AUTO"
    cooling_period = 31
  }
  name                       = "test"
  junction_path              = "/test"
  size_in_megabytes          = 1024
  storage_efficiency_enabled = true
  storage_virtual_machine_id = testAwsFsxOntapStorageVirtualMachine.id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.fsx.OntapVolume;
import com.pulumi.aws.fsx.OntapVolumeArgs;
import com.pulumi.aws.fsx.inputs.OntapVolumeTieringPolicyArgs;
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 test = new OntapVolume("test", OntapVolumeArgs.builder()
            .tieringPolicy(OntapVolumeTieringPolicyArgs.builder()
                .name("AUTO")
                .coolingPeriod(31)
                .build())
            .name("test")
            .junctionPath("/test")
            .sizeInMegabytes(1024)
            .storageEfficiencyEnabled(true)
            .storageVirtualMachineId(testAwsFsxOntapStorageVirtualMachine.id())
            .build());

    }
}
resources:
  test:
    type: aws:fsx:OntapVolume
    properties:
      tieringPolicy:
        name: AUTO
        coolingPeriod: 31
      name: test
      junctionPath: /test
      sizeInMegabytes: 1024
      storageEfficiencyEnabled: true
      storageVirtualMachineId: ${testAwsFsxOntapStorageVirtualMachine.id}

Import

Using pulumi import, import FSx ONTAP volume using the id. For example:

$ pulumi import aws:fsx/ontapVolume:OntapVolume example fsvol-12345678abcdef123

Constructors

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

Properties

aggregateConfiguration ↔ Output<OntapVolumeAggregateConfiguration?>
Aggregate configuration only applies to FLEXGROUP volumes. See `aggregateConfiguration` Block for details.
latefinal
arn ↔ Output<String>
ARN of the volune.
latefinal
bypassSnaplockEnterpriseRetention ↔ Output<bool?>
Whether to allow a SnapLock administrator to delete an FSx for ONTAP SnapLock Enterprise volume with unexpired write once, read many (WORM) files. This configuration must be applied separately before attempting to delete the resource to have the desired behavior. Defaults to false.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
copyTagsToBackups ↔ Output<bool?>
Whether tags for the volume should be copied to backups. This value defaults to false.
latefinal
fileSystemId ↔ Output<String>
File system for the volume, e.g. fs-12345679
latefinal
finalBackupTags ↔ Output<Map<String, String>?>
Map of tags to apply to the volume's final backup.
latefinal
flexcacheEndpointType ↔ Output<String>
FlexCache endpoint type of the volume, Valid values are NONE, ORIGIN, CACHE. Default value is NONE. These can be set by the ONTAP CLI or API and are use with FlexCache feature.
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
junctionPath ↔ Output<String?>
Location in the storage virtual machine's namespace where the volume is mounted. The junctionPath must have a leading forward slash, such as /vol3
latefinal
name ↔ Output<String>
Name of the Volume. You can use a maximum of 203 alphanumeric characters, plus the underscore (_) special character.
latefinal
ontapVolumeType ↔ Output<String>
Type of volume, valid values are RW, DP. Default value is RW. These can be set by the ONTAP CLI or API. This setting is used as part of migration and replication Migrating to Amazon FSx for NetApp ONTAP
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
securityStyle ↔ Output<String>
Volume security style, Valid values are UNIX, NTFS, and MIXED.
latefinal
sizeInBytes ↔ Output<String>
Size of the volume, in megabytes (MB), that you are creating. Can be used for any size but required for volumes over 2 PB. Either sizeInBytes or sizeInMegabytes must be specified. Minimum size for FLEXGROUP volumes are 100GiB per constituent.
latefinal
sizeInMegabytes ↔ Output<int>
Size of the volume, in megabytes (MB), that you are creating. Supported when creating volumes under 2 PB. Either sizeInBytes or sizeInMegabytes must be specified. Minimum size for FLEXGROUP volumes are 100GiB per constituent.
latefinal
skipFinalBackup ↔ Output<bool?>
Whether to skip the default final backup taken when the volume is deleted. This configuration must be applied separately before attempting to delete the resource to have the desired behavior. Defaults to false.
latefinal
snaplockConfiguration ↔ Output<OntapVolumeSnaplockConfiguration?>
SnapLock configuration for an FSx for ONTAP volume. See snaplockConfiguration Block for details.
latefinal
snapshotPolicy ↔ Output<String>
Snapshot policy for the volume. See snapshot policies in the Amazon FSx ONTAP User Guide
latefinal
storageEfficiencyEnabled ↔ Output<bool?>
Whether to enable deduplication, compression, and compaction storage efficiency features on the volume.
latefinal
storageVirtualMachineId ↔ Output<String>
Storage virtual machine in which to create the volume.
latefinal
tags ↔ Output<Map<String, String>?>
Map of tags to assign to the volume. 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
tieringPolicy ↔ Output<OntapVolumeTieringPolicy?>
Data tiering policy for an FSx for ONTAP volume. See tieringPolicy Block for details.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
uuid ↔ Output<String>
Volume's UUID (universally unique identifier).
latefinal
volumeStyle ↔ Output<String>
Styles of volume, valid values are FLEXVOL, FLEXGROUP. Default value is FLEXVOL. FLEXGROUPS have a larger minimum and maximum size. See Volume Styles for more details. Volume Styles
latefinal
volumeType ↔ Output<String?>
Type of volume, currently the only valid value is ONTAP.
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, {OntapVolumeState? state, CustomResourceOptions? options}) → OntapVolume
Gets an existing OntapVolume resource's state with the given name and id.