aws-cdk-lib.aws_batch.EfsVolume

EfsVolume Class

A Volume that uses an AWS Elastic File System (EFS);

this volume can grow and shrink as needed

EcsVolume›EfsVolume

Source

aws-batch/lib/ecs-container-definition.ts

Type last changed

v2.96.0 · 13 Sep 2023

Example

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import { aws_batch as batch } from 'aws-cdk-lib';
import { aws_efs as interfaces_efs } from 'aws-cdk-lib/interfaces';

declare const fileSystemRef: interfaces_efs.IFileSystemRef;
const efsVolume = new batch.EfsVolume({
  containerPath: 'containerPath',
  fileSystem: fileSystemRef,
  name: 'name',

  // the properties below are optional
  accessPointId: 'accessPointId',
  enableTransitEncryption: false,
  readonly: false,
  rootDirectory: 'rootDirectory',
  transitEncryptionPort: 123,
  useJobRole: false,
});

# The code below shows an example of how to instantiate this type.
# The values are placeholders you should change.
from aws_cdk import aws_batch as batch
from aws_cdk.interfaces import aws_efs as interfaces_efs

# file_system_ref: interfaces_efs.IFileSystemRef

efs_volume = batch.EfsVolume(
    container_path="containerPath",
    file_system=file_system_ref,
    name="name",

    # the properties below are optional
    access_point_id="accessPointId",
    enable_transit_encryption=False,
    readonly=False,
    root_directory="rootDirectory",
    transit_encryption_port=123,
    use_job_role=False
)

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import software.amazon.awscdk.services.batch.*;
import software.amazon.awscdk.interfaces.efs.*;

IFileSystemRef fileSystemRef;

EfsVolume efsVolume = EfsVolume.Builder.create()
        .containerPath("containerPath")
        .fileSystem(fileSystemRef)
        .name("name")

        // the properties below are optional
        .accessPointId("accessPointId")
        .enableTransitEncryption(false)
        .readonly(false)
        .rootDirectory("rootDirectory")
        .transitEncryptionPort(123)
        .useJobRole(false)
        .build();

// Install: dotnet add package Amazon.CDK.Lib
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
using Amazon.CDK.AWS.Batch;
using Amazon.CDK.Interfaces.EFS;

IFileSystemRef fileSystemRef;

var efsVolume = new EfsVolume(new EfsVolumeOptions {
    ContainerPath = "containerPath",
    FileSystem = fileSystemRef,
    Name = "name",

    // the properties below are optional
    AccessPointId = "accessPointId",
    EnableTransitEncryption = false,
    Readonly = false,
    RootDirectory = "rootDirectory",
    TransitEncryptionPort = 123,
    UseJobRole = false
});

// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var fileSystemRef IFileSystemRef

efsVolume := awscdk.Aws_batch.NewEfsVolume(&EfsVolumeOptions{
	ContainerPath: jsii.String("containerPath"),
	FileSystem: fileSystemRef,
	Name: jsii.String("name"),

	// the properties below are optional
	AccessPointId: jsii.String("accessPointId"),
	EnableTransitEncryption: jsii.Boolean(false),
	Readonly: jsii.Boolean(false),
	RootDirectory: jsii.String("rootDirectory"),
	TransitEncryptionPort: jsii.Number(123),
	UseJobRole: jsii.Boolean(false),
})

Initializer

new EfsVolume(options: EfsVolumeOptions)

EfsVolume(options: EfsVolumeOptions)

new EfsVolume(EfsVolumeOptions options)

new EfsVolume(EfsVolumeOptions options)

NewEfsVolume(Options EfsVolumeOptions)

Properties

accessPointId?may be undefinedstringaccess_point_id?may be undefinedstraccessPointId?may be undefinedStringAccessPointId?may be undefinedstringAccessPointId?may be undefined*string#

The Amazon EFS access point ID to use.

Default: no accessPointId

If an access point is specified, rootDirectory must either be omitted or set to / which enforces the path set on the EFS access point. If an access point is used, enableTransitEncryption must be true.

containerPathstringcontainer_pathstrcontainerPathStringContainerPathstringContainerPath*string#

The path on the container that this volume will be mounted to.

enableTransitEncryption?may be undefinedbooleanenable_transit_encryption?may be undefinedboolenableTransitEncryption?may be undefinedBooleanEnableTransitEncryption?may be undefinedboolEnableTransitEncryption?may be undefined*bool= false#

Enables encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server.

fileSystemIFileSystemfile_systemIFileSystemfileSystemIFileSystemFileSystemIFileSystemFileSystemIFileSystem#

The EFS File System that supports this volume.

namestringnamestrnameStringNamestringName*string#

The name of this volume.

readonly?may be undefinedbooleanreadonly?may be undefinedboolreadonly?may be undefinedBooleanReadonly?may be undefinedboolReadonly?may be undefined*bool= false#

Whether or not the container has readonly access to this volume.

rootDirectory?may be undefinedstringroot_directory?may be undefinedstrrootDirectory?may be undefinedStringRootDirectory?may be undefinedstringRootDirectory?may be undefined*string#

The directory within the Amazon EFS file system to mount as the root directory inside the host.

Default: root of the EFS File System

If this parameter is omitted, the root of the Amazon EFS volume is used instead. Specifying / has the same effect as omitting this parameter. The maximum length is 4,096 characters.

transitEncryptionPort?may be undefinednumbertransit_encryption_port?may be undefinedint | floattransitEncryptionPort?may be undefinedNumberTransitEncryptionPort?may be undefineddoubleTransitEncryptionPort?may be undefined*float64#

The port to use when sending encrypted data between the Amazon ECS host and the Amazon EFS server.

Default: chosen by the EFS Mount Helper

The value must be between 0 and 65,535.

useJobRole?may be undefinedbooleanuse_job_role?may be undefinedbooluseJobRole?may be undefinedBooleanUseJobRole?may be undefinedboolUseJobRole?may be undefined*bool= false#

Whether or not to use the AWS Batch job IAM role defined in a job definition when mounting the Amazon EFS file system.

If specified, enableTransitEncryption must be true.

Methods

efs(options: EfsVolumeOptions): EfsVolume // chainable@staticmethod def efs(options: EfsVolumeOptions) -> EfsVolumepublic static EfsVolume efs(EfsVolumeOptions options)public static EfsVolume Efs(EfsVolumeOptions options)func Efs(Options EfsVolumeOptions) EfsVolumestatic#

Creates a Volume that uses an AWS Elastic File System (EFS);

this volume can grow and shrink as needed

host(options: HostVolumeOptions): HostVolume@staticmethod def host(options: HostVolumeOptions) -> HostVolumepublic static HostVolume host(HostVolumeOptions options)public static HostVolume Host(HostVolumeOptions options)func Host(Options HostVolumeOptions) HostVolumestatic#

Creates a Host volume.

This volume will persist on the host at the specified hostPath. If the hostPath is not specified, Docker will choose the host path. In this case, the data may not persist after the containers that use it stop running.

isEfsVolume(x: any): boolean@staticmethod def is_efs_volume(x: Any) -> boolpublic static Boolean isEfsVolume(Object x)public static bool IsEfsVolume(object x)func IsEfsVolume(X interface{}) *boolstatic#

Returns true if x is an EfsVolume, false otherwise.