Metadata-Version: 2.1
Name: aws-cdk.aws-fsx
Version: 1.60.0
Summary: The CDK Construct Library for AWS::FSx
Home-page: https://github.com/aws/aws-cdk
Author: Amazon Web Services
License: Apache-2.0
Project-URL: Source, https://github.com/aws/aws-cdk.git
Description: ## Amazon FSx Construct Library
        
        <!--BEGIN STABILITY BANNER-->---
        
        
        ![cfn-resources: Stable](https://img.shields.io/badge/cfn--resources-stable-success.svg?style=for-the-badge)
        
        > All classes with the `Cfn` prefix in this module ([CFN Resources](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_lib)) are always stable and safe to use.
        
        ![cdk-constructs: Experimental](https://img.shields.io/badge/cdk--constructs-experimental-important.svg?style=for-the-badge)
        
        > The APIs of higher level constructs in this module are experimental and under active development. They are subject to non-backward compatible changes or removal in any future version. These are not subject to the [Semantic Versioning](https://semver.org/) model and breaking changes will be announced in the release notes. This means that while you may use them, you may need to update your source code when upgrading to a newer version of this package.
        
        ---
        <!--END STABILITY BANNER-->
        
        [Amazon FSx](https://docs.aws.amazon.com/fsx/?id=docs_gateway) provides fully managed third-party file systems with the
        native compatibility and feature sets for workloads such as Microsoft Windows–based storage, high-performance computing,
        machine learning, and electronic design automation.
        
        Amazon FSx supports two file system types: [Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/index.html) and
        [Windows](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/index.html) File Server.
        
        ## FSx for Lustre
        
        Amazon FSx for Lustre makes it easy and cost-effective to launch and run the popular, high-performance Lustre file
        system. You use Lustre for workloads where speed matters, such as machine learning, high performance computing (HPC),
        video processing, and financial modeling.
        
        The open-source Lustre file system is designed for applications that require fast storage—where you want your storage
        to keep up with your compute. Lustre was built to solve the problem of quickly and cheaply processing the world's
        ever-growing datasets. It's a widely used file system designed for the fastest computers in the world. It provides
        submillisecond latencies, up to hundreds of GBps of throughput, and up to millions of IOPS. For more information on
        Lustre, see the [Lustre website](http://lustre.org/).
        
        As a fully managed service, Amazon FSx makes it easier for you to use Lustre for workloads where storage speed matters.
        Amazon FSx for Lustre eliminates the traditional complexity of setting up and managing Lustre file systems, enabling
        you to spin up and run a battle-tested high-performance file system in minutes. It also provides multiple deployment
        options so you can optimize cost for your needs.
        
        Amazon FSx for Lustre is POSIX-compliant, so you can use your current Linux-based applications without having to make
        any changes. Amazon FSx for Lustre provides a native file system interface and works as any file system does with your
        Linux operating system. It also provides read-after-write consistency and supports file locking.
        
        ### Installation
        
        Import to your project:
        
        ```python
        # Example automatically generated. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_fsx as fsx
        ```
        
        ### Basic Usage
        
        Setup required properties and create:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        stack = Stack(app, "Stack")
        vpc = Vpc(stack, "VPC")
        
        file_system = LustreFileSystem(stack, "FsxLustreFileSystem",
            lustre_configuration={"deployment_type": LustreDeploymentType.SCRATCH_2},
            storage_capacity_gi_b=1200,
            vpc=vpc,
            vpc_subnet=vpc.privateSubnets[0]
        )
        ```
        
        ### Connecting
        
        To control who can access the file system, use the `.connections` attribute. FSx has a fixed default port, so you don't
        need to specify the port. This example allows an EC2 instance to connect to a file system:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        file_system.connections.allow_default_port_from(instance)
        ```
        
        ### Mounting
        
        The LustreFileSystem Construct exposes both the DNS name of the file system as well as its mount name, which can be
        used to mount the file system on an EC2 instance. The following example shows how to bring up a file system and EC2
        instance, and then use User Data to mount the file system on the instance at start-up:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        app = App()
        stack = Stack(app, "AwsCdkFsxLustre")
        vpc = Vpc(stack, "VPC")
        
        lustre_configuration = {
            "deployment_type": LustreDeploymentType.SCRATCH_2
        }
        fs = LustreFileSystem(stack, "FsxLustreFileSystem",
            lustre_configuration=lustre_configuration,
            storage_capacity_gi_b=1200,
            vpc=vpc,
            vpc_subnet=vpc.privateSubnets[0]
        )
        
        inst = Instance(stack, "inst",
            instance_type=InstanceType.of(InstanceClass.T2, InstanceSize.LARGE),
            machine_image=AmazonLinuxImage(
                generation=AmazonLinuxGeneration.AMAZON_LINUX_2
            ),
            vpc=vpc,
            vpc_subnets={
                "subnet_type": SubnetType.PUBLIC
            }
        )
        fs.connections.allow_default_port_from(inst)
        
        # Need to give the instance access to read information about FSx to determine the file system's mount name.
        inst.role.add_managed_policy(ManagedPolicy.from_aws_managed_policy_name("AmazonFSxReadOnlyAccess"))
        
        mount_path = "/mnt/fsx"
        dns_name = fs.dns_name
        mount_name = fs.mount_name
        
        inst.user_data.add_commands("set -eux", "yum update -y", "amazon-linux-extras install -y lustre2.10", f"mkdir -p {mountPath}", f"chmod 777 {mountPath}", f"chown ec2-user:ec2-user {mountPath}", f"echo \"{dnsName}@tcp:/{mountName} {mountPath} lustre defaults,noatime,flock,_netdev 0 0\" >> /etc/fstab", "mount -a")
        ```
        
        ### Importing
        
        An FSx for Lustre file system can be imported with `fromLustreFileSystemAttributes(stack, id, attributes)`. The
        following example lays out how you could import the SecurityGroup a file system belongs to, use that to import the file
        system, and then also import the VPC the file system is in and add an EC2 instance to it, giving it access to the file
        system.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        app = App()
        stack = Stack(app, "AwsCdkFsxLustreImport")
        
        sg = SecurityGroup.from_security_group_id(stack, "FsxSecurityGroup", "{SECURITY-GROUP-ID}")
        fs = LustreFileSystem.from_lustre_file_system_attributes(stack, "FsxLustreFileSystem",
            dns_name="{FILE-SYSTEM-DNS-NAME}",
            file_system_id="{FILE-SYSTEM-ID}",
            security_group=sg
        )
        
        vpc = Vpc.from_vpc_attributes(stack, "Vpc",
            availability_zones=["us-west-2a", "us-west-2b"],
            public_subnet_ids=["{US-WEST-2A-SUBNET-ID}", "{US-WEST-2B-SUBNET-ID}"],
            vpc_id="{VPC-ID}"
        )
        inst = Instance(stack, "inst",
            instance_type=InstanceType.of(InstanceClass.T2, InstanceSize.LARGE),
            machine_image=AmazonLinuxImage(
                generation=AmazonLinuxGeneration.AMAZON_LINUX_2
            ),
            vpc=vpc,
            vpc_subnets={
                "subnet_type": SubnetType.PUBLIC
            }
        )
        fs.connections.allow_default_port_from(inst)
        ```
        
        ## FSx for Windows File Server
        
        The L2 construct for the FSx for Windows File Server has not yet been implemented. To instantiate an FSx for Windows
        file system, the L1 constructs can be used as defined by CloudFormation.
        
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: JavaScript
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Typing :: Typed
Classifier: Development Status :: 4 - Beta
Classifier: License :: OSI Approved
Requires-Python: >=3.6
Description-Content-Type: text/markdown
