Metadata-Version: 2.1
Name: aws-cdk.aws-efs
Version: 1.84.0
Summary: The CDK Construct Library for AWS::EFS
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 Elastic File System 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 Elastic File System](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html) (Amazon EFS) provides a simple, scalable,
        fully managed elastic NFS file system for use with AWS Cloud services and on-premises resources.
        Amazon EFS provides file storage in the AWS Cloud. With Amazon EFS, you can create a file system,
        mount the file system on an Amazon EC2 instance, and then read and write data to and from your file system.
        
        This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) project.
        
        ## File Systems
        
        Amazon EFS provides elastic, shared file storage that is POSIX-compliant. The file system you create
        supports concurrent read and write access from multiple Amazon EC2 instances and is accessible from
        all of the Availability Zones in the AWS Region where it is created. Learn more about [EFS file systems](https://docs.aws.amazon.com/efs/latest/ug/creating-using.html)
        
        ### Create an Amazon EFS file system
        
        A Virtual Private Cloud (VPC) is required to create an Amazon EFS file system.
        The following example creates a file system that is encrypted at rest, running in `General Purpose`
        performance mode, and `Bursting` throughput mode and does not transition files to the Infrequent
        Access (IA) storage class.
        
        ```python
        # Example automatically generated. See https://github.com/aws/jsii/issues/826
        file_system = efs.FileSystem(self, "MyEfsFileSystem",
            vpc=ec2.Vpc(self, "VPC"),
            encrypted=True, # file system is not encrypted by default
            lifecycle_policy=efs.LifecyclePolicy.AFTER_14_DAYS, # files are not transitioned to infrequent access (IA) storage by default
            performance_mode=efs.PerformanceMode.GENERAL_PURPOSE
        )
        ```
        
        ⚠️ An Amazon EFS file system's performance mode can't be changed after the file system has been created.
        Updating this property will replace the file system.
        
        ### Access Point
        
        An access point is an application-specific view into an EFS file system that applies an operating
        system user and group, and a file system path, to any file system request made through the access
        point. The operating system user and group override any identity information provided by the NFS
        client. The file system path is exposed as the access point's root directory. Applications using
        the access point can only access data in its own directory and below. To learn more, see [Mounting a File System Using EFS Access Points](https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html).
        
        Use the `addAccessPoint` API to create an access point from a fileSystem.
        
        ```python
        # Example automatically generated. See https://github.com/aws/jsii/issues/826
        file_system.add_access_point("AccessPoint")
        ```
        
        By default, when you create an access point, the root(`/`) directory is exposed to the client
        connecting to the access point. You can specify a custom path with the `path` property.
        
        If `path` does not exist, it will be created with the settings defined in the `creationInfo`.
        See [Creating Access Points](https://docs.aws.amazon.com/efs/latest/ug/create-access-point.html) for more details.
        
        Any access point that has been created outside the stack can be imported into your CDK app.
        
        Use the `fromAccessPointAttributes()` API to import an existing access point.
        
        ```python
        # Example automatically generated. See https://github.com/aws/jsii/issues/826
        efs.AccessPoint.from_access_point_attributes(self, "ap",
            access_point_id="fsap-1293c4d9832fo0912",
            file_system=efs.FileSystem.from_file_system_attributes(self, "efs",
                file_system_id="fs-099d3e2f",
                security_group=ec2.SecurityGroup.from_security_group_id(self, "sg", "sg-51530134")
            )
        )
        ```
        
        ⚠️ Notice: When importing an Access Point using `fromAccessPointAttributes()`, you must make sure
        the mount targets are deployed and their lifecycle state is `available`. Otherwise, you may encounter
        the following error when deploying:
        
        > EFS file system <ARN of efs> referenced by access point <ARN of access point of EFS> has
        > mount targets created in all availability zones the function will execute in, but not all
        > are in the available life cycle state yet. Please wait for them to become available and
        > try the request again.
        
        ### Connecting
        
        To control who can access the EFS, use the `.connections` attribute. EFS has
        a fixed default port, so you don't need to specify the port:
        
        ```python
        # Example automatically generated. See https://github.com/aws/jsii/issues/826
        file_system.connections.allow_default_port_from(instance)
        ```
        
        Learn more about [managing file system network accessibility](https://docs.aws.amazon.com/efs/latest/ug/manage-fs-access.html)
        
        ### Mounting the file system using User Data
        
        After you create a file system, you can create mount targets. Then you can mount the file system on
        EC2 instances, containers, and Lambda functions in your virtual private cloud (VPC).
        
        The following example automatically mounts a file system during instance launch.
        
        ```python
        # Example automatically generated. See https://github.com/aws/jsii/issues/826
        file_system.connections.allow_default_port_from(instance)
        
        instance.user_data.add_commands("yum check-update -y", "yum upgrade -y", "yum install -y amazon-efs-utils", "yum install -y nfs-utils", "file_system_id_1=" + file_system.file_system_id, "efs_mount_point_1=/mnt/efs/fs1", "mkdir -p \"${efs_mount_point_1}\"", "test -f \"/sbin/mount.efs\" && echo \"${file_system_id_1}:/ ${efs_mount_point_1} efs defaults,_netdev\" >> /etc/fstab || " + "echo \"${file_system_id_1}.efs." + Stack.of(self).region + ".amazonaws.com:/ ${efs_mount_point_1} nfs4 nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport,_netdev 0 0\" >> /etc/fstab", "mount -a -t efs,nfs4 defaults")
        ```
        
        Learn more about [mounting EFS file systems](https://docs.aws.amazon.com/efs/latest/ug/mounting-fs.html)
        
        ### Deleting
        
        Since file systems are stateful resources, by default the file system will not be deleted when your
        stack is deleted.
        
        You can configure the file system to be destroyed on stack deletion by setting a `removalPolicy`
        
        ```python
        # Example automatically generated. See https://github.com/aws/jsii/issues/826
        file_system = efs.FileSystem(self, "EfsFileSystem",
            vpc=ec2.Vpc(self, "VPC"),
            removal_policy=RemovalPolicy.DESTROY
        )
        ```
        
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: Programming Language :: Python :: 3.9
Classifier: Typing :: Typed
Classifier: Development Status :: 4 - Beta
Classifier: License :: OSI Approved
Classifier: Framework :: AWS CDK
Classifier: Framework :: AWS CDK :: 1
Requires-Python: >=3.6
Description-Content-Type: text/markdown
