feat: add typescript example of a Fargate service with efs mount

README.md

@@ -49,6 +49,7 @@ $ cdk destroy
 | [ecs-service-with-logging](https://github.com/aws-samples/aws-cdk-examples/tree/master/typescript/ecs/ecs-service-with-logging/) | Starting a container fronted by a load balancer on ECS |
 | [fargate-service-with-logging](https://github.com/aws-samples/aws-cdk-examples/tree/master/typescript/ecs/fargate-service-with-logging/) | Starting a container fronted by a load balancer on Fargate |
 | [custom-logical-names](https://github.com/aws-samples/aws-cdk-examples/tree/master/typescript/custom-logical-names/) | Example of how to override logical name allocation |
+| [fargate-service-with-efs](https://github.com/aws-samples/aws-cdk-examples/tree/master/typescript/ecs/fargate-service-with-efs/) | Starting a container fronted by an application load balancer on Fargate with an EFS Mount |
 
 ## Java examples <a name="Java"></a>
 

typescript/ecs/fargate-service-with-efs/README.md

@@ -0,0 +1,34 @@
+# Fargate Service using EFS
+This example creates a Public Facing load balanced Fargate service with an EFS Filesystem mount to demo the
+recently added feature to Fargate.
+
+Is based on this blog post: https://aws.amazon.com/blogs/aws/amazon-ecs-supports-efs/
+
+Also gives examples of using the following:
+
+* AWS SDK Api call Custom resource to create Efs Access Point (not currently supported by cfn)
+* Lambda Custom Resource to create ECS TaskDefinition with EFS Mount (not currently supported by cfn) & initiate an update of the service
+* Cfn property override to set Fargate Service' PlatformVersion' to '1.4.0' (not currently tagged as Latest)
+
+
+## Build
+
+To build this app, you need to be in this example's root folder. Then run the following:
+
+```bash
+npm install -g aws-cdk
+npm install
+npm run build
+```
+
+This will install the necessary CDK, then this example's dependencies, and then build your TypeScript files and your CloudFormation template.
+
+## Deploy
+
+Run `cdk deploy`. This will deploy / redeploy your Stack to your AWS Account.
+
+After the deployment you will see the API's URL, which represents the url you can then use.
+
+## Synthesize Cloudformation Template
+
+To see the Cloudformation template generated by the CDK, run `cdk synth`, then check the output file in the "cdk.out" directory.

typescript/ecs/fargate-service-with-efs/cdk.json

@@ -0,0 +1,3 @@
+{
+  "app": "node index"
+}

typescript/ecs/fargate-service-with-efs/efs-mount-fargate-cr.ts

@@ -0,0 +1,51 @@
+import * as lambda from '@aws-cdk/aws-lambda';
+import * as cdk from '@aws-cdk/core';
+import * as iam from '@aws-cdk/aws-iam';
+import * as cr from '@aws-cdk/custom-resources';
+import fs = require('fs');
+
+
+export interface FargateEfsCustomResourceProps {
+  /**
+   * Custom Resource Properties
+   */
+  TaskDefinition: string;
+  EcsService: string;
+  EcsCluster: string;
+  EfsFileSystemId: string;
+  EfsMountName: string
+}
+
+
+export class FargateEfsCustomResource extends cdk.Construct {
+  public readonly response: string;
+
+  constructor(scope: cdk.Construct, id: string, props: FargateEfsCustomResourceProps) {
+    super(scope, id);
+
+    const onEvent = new lambda.SingletonFunction(this, 'Singleton', {
+      uuid: 'f7d4f730-4ee1-11e8-9c2d-fa7ae01bbebc',
+      code: new lambda.InlineCode(fs.readFileSync('lambda.js', { encoding: 'utf-8' })),
+      handler: 'index.handler',
+      timeout: cdk.Duration.seconds(300),
+      runtime: lambda.Runtime.NODEJS_12_X,
+      initialPolicy:[
+        new iam.PolicyStatement({
+          actions: [ 'ecs:UpdateService', 'ecs:RegisterTaskDefinition', 'ecs:DescribeTaskDefinition', 'iam:PassRole', 'iam:GetRole' ],
+          resources: [ '*' ]
+        })
+      ]
+    });
+
+    const myProvider = new cr.Provider(this, 'MyProvider', {
+      onEventHandler: onEvent
+    });
+
+    const resource = new cdk.CustomResource(this, 'Resource1', {
+      serviceToken: myProvider.serviceToken,
+      properties: props
+    });
+
+    this.response = resource.getAtt('Response').toString();
+  }
+}

typescript/ecs/fargate-service-with-efs/index.ts

@@ -0,0 +1,105 @@
+import * as cdk from '@aws-cdk/core';
+import * as ec2 from '@aws-cdk/aws-ec2';
+import * as ecs from '@aws-cdk/aws-ecs';
+import * as ecs_patterns from '@aws-cdk/aws-ecs-patterns';
+import * as efs from '@aws-cdk/aws-efs';
+import * as cr from '@aws-cdk/custom-resources';
+import {FargateEfsCustomResource} from "./efs-mount-fargate-cr";
+
+
+
+class FargateEfs extends cdk.Stack {
+  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    const vpc = new ec2.Vpc(this, 'DefaultVpc', { maxAzs: 2});
+    const ecsCluster = new ecs.Cluster(this, 'DefaultEcsCluster', {vpc: vpc});
+
+    const fileSystem = new efs.FileSystem(this, 'MyEfsFileSystem', {
+      vpc: vpc,
+      encrypted: true,
+      lifecyclePolicy: efs.LifecyclePolicy.AFTER_14_DAYS,
+      performanceMode: efs.PerformanceMode.GENERAL_PURPOSE,
+      throughputMode: efs.ThroughputMode.BURSTING
+    });
+
+
+     const params = {
+      FileSystemId: fileSystem.fileSystemId,
+      PosixUser: {
+        Gid: 1000,
+        Uid: 1000
+      },
+      RootDirectory: {
+        CreationInfo: {
+          OwnerGid: 1000,
+          OwnerUid: 1000,
+          Permissions: '755'
+        },
+        Path: '/uploads'
+      },
+      Tags: [
+        {
+          Key: 'Name',
+          Value: 'ecsuploads'
+        }
+      ]
+    };
+
+    const efsAccessPoint = new cr.AwsCustomResource(this, 'EfsAccessPoint', {
+       onUpdate: {
+           service: 'EFS',
+           action: 'createAccessPoint',
+           parameters: params,
+           physicalResourceId: cr.PhysicalResourceId.of('12121212121'),
+       },
+       policy: cr.AwsCustomResourcePolicy.fromSdkCalls({resources: cr.AwsCustomResourcePolicy.ANY_RESOURCE})
+    });
+
+    efsAccessPoint.node.addDependency(fileSystem);
+
+    const taskDef = new ecs.FargateTaskDefinition(this, "MyTaskDefinition", {
+      memoryLimitMiB: 512,
+      cpu: 256,
+    });
+
+    const containerDef = new ecs.ContainerDefinition(this, "MyContainerDefinition", {
+      image: ecs.ContainerImage.fromRegistry("coderaiser/cloudcmd"),
+      taskDefinition: taskDef
+    });
+
+    containerDef.addPortMappings({
+      containerPort: 8000
+    });
+
+    const albFargateService = new ecs_patterns.ApplicationLoadBalancedFargateService(this, 'Service01', {
+      cluster: ecsCluster,
+      taskDefinition: taskDef,
+      desiredCount: 2
+    });
+
+    albFargateService.targetGroup.setAttribute('deregistration_delay.timeout_seconds', '30');
+
+    // Override Platform version (until Latest = 1.4.0)
+    const albFargateServiceResource = albFargateService.service.node.findChild('Service') as ecs.CfnService;
+    albFargateServiceResource.addPropertyOverride('PlatformVersion', '1.4.0')
+
+    // Allow access to EFS from Fargate ECS
+    fileSystem.connections.allowDefaultPortFrom(albFargateService.service.connections);
+
+    //Custom Resource to add EFS Mount to Task Definition
+    const resource = new FargateEfsCustomResource(this, 'FargateEfsCustomResource', {
+        TaskDefinition: taskDef.taskDefinitionArn,
+        EcsService: albFargateService.service.serviceName,
+        EcsCluster: ecsCluster.clusterName,
+        EfsFileSystemId: fileSystem.fileSystemId,
+        EfsMountName: 'uploads'
+    });
+
+    resource.node.addDependency(albFargateService);
+  }
+}
+
+const app = new cdk.App();
+new FargateEfs(app, 'FargateEfsDemo01');
+app.synth();

typescript/ecs/fargate-service-with-efs/lambda.js

@@ -0,0 +1,120 @@
+var AWS = require('aws-sdk');
+var ecs = new AWS.ECS();
+
+exports.handler = function(event, context, callback) {
+
+    var taskDefParams = {
+        taskDefinition: event["ResourceProperties"]["TaskDefinition"],
+    };
+
+    var ecsParams = {
+        service: event["ResourceProperties"]["EcsService"],
+        cluster: event["ResourceProperties"]["EcsCluster"]
+    };
+
+    var volume = {
+      name: event["ResourceProperties"]["EfsMountName"],
+      efsVolumeConfiguration: { fileSystemId: event["ResourceProperties"]["EfsFileSystemId"], rootDirectory: '/' }
+    };
+
+    var mountPoint =  {
+        sourceVolume: event["ResourceProperties"]["EfsMountName"],
+        containerPath: '/' + event["ResourceProperties"]["EfsMountName"],
+        readOnly: false
+    };
+
+    console.log(event);
+    console.log(event["ResourceProperties"]);
+    try {
+        console.log("Getting Task Definition");
+        ecs.describeTaskDefinition(taskDefParams, function(err, data) {
+          if (err)
+            console.log(err, err.stack);
+          else
+            data['taskDefinition']['volumes'].push(volume);
+            data['taskDefinition']['containerDefinitions'][0]['mountPoints'].push(mountPoint);
+            delete data['taskDefinition']['taskDefinitionArn'];
+            delete data['taskDefinition']['revision'];
+            delete data['taskDefinition']['status'];
+            delete data['taskDefinition']['requiresAttributes'];
+            delete data['taskDefinition']['compatibilities'];
+
+            console.log("Register New Task Definition");
+            ecs.registerTaskDefinition(data['taskDefinition'], function(err, data) {
+              if (err)
+                console.log(err, err.stack);
+              else
+                console.log(data);
+                console.log("Update Service");
+                ecs.updateService({
+                      service: ecsParams['service'],
+                      cluster: ecsParams['cluster'],
+                      taskDefinition: data['taskDefinition']['taskDefinitionArn'],
+
+                    },
+                    function (err, data) {
+                  if (err)
+                      console.log(err, err.stack);
+                  else
+                      console.log(data);
+                      sendResponse(event, context, 'SUCCESS', { 'Message': 'Resource creation successful!' });
+                });
+                console.log(data);
+            });
+        });
+    } catch (e) {
+        console.log('Errors' + e);
+        sendResponse(event, context, 'FAILED')
+    }
+};
+
+
+// Send response to the pre-signed S3 URL
+function sendResponse (event, context, responseStatus, responseData) {
+  console.log('Sending response ' + responseStatus);
+  var responseBody = JSON.stringify({
+    Status: responseStatus,
+    Reason: 'See the details in CloudWatch Log Stream: ' + context.logStreamName,
+    PhysicalResourceId: context.logStreamName,
+    StackId: event.StackId,
+    RequestId: event.RequestId,
+    LogicalResourceId: event.LogicalResourceId,
+    Data: responseData
+  });
+
+  console.log('RESPONSE BODY:\n', responseBody);
+
+  var https = require('https');
+  var url = require('url');
+
+  var parsedUrl = url.parse(event.ResponseURL);
+  var options = {
+    hostname: parsedUrl.hostname,
+    port: 443,
+    path: parsedUrl.path,
+    method: 'PUT',
+    headers: {
+      'content-type': '',
+      'content-length': responseBody.length
+    }
+  };
+
+  console.log('SENDING RESPONSE...\n');
+
+  var request = https.request(options, function (response) {
+    console.log('STATUS: ' + response.statusCode);
+    console.log('HEADERS: ' + JSON.stringify(response.headers));
+    // Tell AWS Lambda that the function execution is done
+    context.done()
+  });
+
+  request.on('error', function (error) {
+    console.log('sendResponse Error:' + error);
+    // Tell AWS Lambda that the function execution is done
+    context.done()
+  });
+
+  // write data to request body
+  request.write(responseBody);
+  request.end()
+}

typescript/ecs/fargate-service-with-efs/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "fargate-service-with-efs",
+  "version": "1.0.0",
+  "description": "Running a load balanced service on ECS with EFS",
+  "private": true,
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "cdk": "cdk"
+  },
+  "author": {
+    "name": "Amazon Web Services",
+    "url": "https://aws.amazon.com",
+    "organization": true
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/node": "^8.10.38",
+    "typescript": "^3.9.5"
+  },
+  "dependencies": {
+    "@aws-cdk/aws-ec2": "*",
+    "@aws-cdk/aws-ecs": "*",
+    "@aws-cdk/aws-ecs-patterns": "*",
+    "@aws-cdk/aws-efs": "*",
+    "@aws-cdk/core": "*",
+    "@aws-cdk/custom-resources": "*"
+  }
+}

typescript/ecs/fargate-service-with-efs/tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "target":"ES2018",
+        "module": "commonjs",
+        "lib": ["es2016", "es2017.object", "es2017.string"],
+        "strict": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "noImplicitThis": true,
+        "alwaysStrict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noImplicitReturns": true,
+        "noFallthroughCasesInSwitch": false,
+        "inlineSourceMap": true,
+        "inlineSources": true,
+        "experimentalDecorators": true,
+        "strictPropertyInitialization":false
+    }
+}
+