Ecs code mounting (#7)

* initial setup

* get it working

* remove useless files

* Fix remote debugger configuration and instructions

* Review README file

---------

Co-authored-by: HarshCasper <erbeusgriffincasper@gmail.com>
Co-authored-by: Bart Szydlowski <bart.szydlowski@localstack.cloud>

Author: bartsdev

Makefile

@@ -46,7 +46,7 @@ start-localstack:
 	cd devops-tooling && docker compose -p $(APP_NAME) up
 
 stop-localstack:
-	cd devops-tooling && docker compose down
+	cd devops-tooling && docker compose -p $(APP_NAME) down
 
 
 PKG_SUB_DIRS := $(dir $(shell find . -type d -name node_modules -prune -o -type d -name "venv*" -prune -o -type f -name package.json -print))

README.md

@@ -65,7 +65,7 @@ make install
 Start the LocalStack server using the following command:
 
 ```bash
-export LOCALSTACK_API_KEY=<YOUR_API_KEY>
+export LOCALSTACK_AUTH_TOKEN=<YOUR_AUTH_TOKEN>
 make start-localstack
 ```
 
@@ -166,12 +166,8 @@ Node.js applications. 🛠️🔍
 
 1️⃣ **Configure LocalStack for remote Node.js debugging** 🛠️
 
-First, we need to configure LocalStack to enable remote debugging of Node.js applications. To do so, we need to set
-the `ECS_DOCKER_FLAGS` to enable the debugger using `NODE_OPTIONS`:
+First, we need to configure LocalStack to enable remote debugging of Node.js applications. In devops-tooling/docker-compose.yml file, uncomment **ECS_DOCKER_FLAGS** line to enable required configuration for remote debugging. 
 
-   ```bash
-    export ECS_DOCKER_FLAGS="-e NODE_OPTIONS=--inspect-brk=0.0.0.0:9229 -p 9229:9229"
-  ```
 
 2️⃣ **Adding a Task to Wait for Remote Debugger Server** 🕰️
 
@@ -205,7 +201,7 @@ existing one from the *Run and Debug* tab, then add the following configuration.
       "localRoot": "${workspaceFolder}",
       "name": "Attach to Remote Node.js",
       "port": 9229,
-      "remoteRoot": "/var/task/",
+      "remoteRoot": "/app",
       "request": "attach",
       "type": "node",
       "preLaunchTask": "Wait Remote Debugger Server"
@@ -214,7 +210,16 @@ existing one from the *Run and Debug* tab, then add the following configuration.
 }
    ```
 
-4️⃣ **Running the Debugger** 🏃
+4️⃣ **Start LocalStack**
+
+Start the LocalStack server using the following command:
+
+```bash
+export LOCALSTACK_AUTH_TOKEN=<YOUR_AUTH_TOKEN>
+make start-localstack
+```
+
+5️⃣ **Running the Debugger** 🏃
 
 Finally, run the debugger by selecting the *Attach to Remote Node.js* configuration from the *Run and Debug* tab. You
 can now set breakpoints and debug your Node.js application running in a Docker container. 🐳

devops-tooling/docker-compose.yml

@@ -14,7 +14,7 @@ services:
       - ENFORCE_IAM=${ENFORCE_IAM-0} # Enable IAM policy evaluation and enforcement
       - LAMBDA_RUNTIME_ENVIRONMENT_TIMEOUT=90
       - PERSIST_ALL=${PERSIST_ALL-false}
-      - LOCALSTACK_API_KEY=${LOCALSTACK_API_KEY-}
       - LOCALSTACK_AUTH_TOKEN=${LOCALSTACK_AUTH_TOKEN-}
+      # - ECS_DOCKER_FLAGS=-e NODE_OPTIONS=--inspect-brk=0.0.0.0:9229 -p 9229:9229  # Optional flag required for remote debugging
     volumes:
       - /var/run/docker.sock:/var/run/docker.sock  # Mount the Docker socket into the container

iac/awscdk/lib/repo-stack.ts

@@ -1,57 +1,72 @@
-import * as cdk from 'aws-cdk-lib'
-import {DockerImageAsset, Platform} from 'aws-cdk-lib/aws-ecr-assets'
-import {Construct} from 'constructs'
-// import * as sqs from 'aws-cdk-lib/aws-sqs';
-import * as ec2 from "aws-cdk-lib/aws-ec2"
-import * as ecs from "aws-cdk-lib/aws-ecs"
-import * as ecs_patterns from "aws-cdk-lib/aws-ecs-patterns"
+import * as cdk from 'aws-cdk-lib';
+import { DockerImageAsset, Platform } from 'aws-cdk-lib/aws-ecr-assets';
+import { Construct } from 'constructs';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as ecs_patterns from 'aws-cdk-lib/aws-ecs-patterns';
 
-const path = require('path')
+const path = require('path');
 
 export class RepoStack extends cdk.Stack {
-    /**
-     *
-     * @param {Construct} scope
-     * @param {string} id
-     * @param {StackProps=} props
-     */
     constructor(scope: Construct, id: string, props?: cdk.StackProps) {
-        super(scope, id, props)
+        super(scope, id, props);
 
-        // base infrastructure
-        const vpc = new ec2.Vpc(this, 'VPC', {maxAzs: 2})
+        const vpc = new ec2.Vpc(this, 'VPC', {maxAzs: 2});
         const cluster = new ecs.Cluster(this, 'Cluster', {
             clusterName: 'Services',
             vpc: vpc
-        })
+        });
 
         const asset = new DockerImageAsset(this, 'service1', {
             directory: path.join(__dirname, '../../../src'),
             platform: Platform.LINUX_AMD64,
-        })
+        });
+
+        const taskDefinition = new ecs.FargateTaskDefinition(this, "MyFargateTask", {
+            cpu: 512,
+            memoryLimitMiB: 2048,
+        });
+
+        taskDefinition.addVolume({
+            name: 'local-src',
+            host: {
+                sourcePath: path.join(__dirname, '../../../src/app')
+            }
+        });
+
+        const container = taskDefinition.addContainer("MyFargateContainer", {
+            image: ecs.ContainerImage.fromDockerImageAsset(asset),
+            logging: new ecs.AwsLogDriver({streamPrefix: "MyApp"}),
+            memoryLimitMiB: 2048,
+            cpu: 512
+        });
+
+        container.addPortMappings({
+            containerPort: 3000
+        });
+
+        // Match the container path with the Dockerfile WORKDIR
+        container.addMountPoints({
+            containerPath: '/app',
+            sourceVolume: 'local-src',
+            readOnly: false
+        });
 
-        // task definition
-        // Create a load-balanced Fargate service and make it public
         const albfs = new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
-            cluster: cluster, // Required
-            cpu: 512, // Default is 256
-            desiredCount: 2, // Default is 1
-            taskImageOptions: {
-                image: ecs.ContainerImage.fromDockerImageAsset(asset),
-                containerPort: 3000,
-            },
-            memoryLimitMiB: 2048, // Default is 512
+            cluster: cluster,
+            desiredCount: 1,
+            taskDefinition: taskDefinition,
             listenerPort: 80,
-            publicLoadBalancer: true // Default is true
-        })
+            publicLoadBalancer: true
+        });
 
         new cdk.CfnOutput(this, 'serviceslb', {
             value: albfs.loadBalancer.loadBalancerDnsName,
-        })
+        });
         new cdk.CfnOutput(this, 'localstackserviceslb', {
             value: `${albfs.loadBalancer.loadBalancerDnsName}:4566`,
-        })
+        });
     }
 }
 
-module.exports = {RepoStack}
+module.exports = {RepoStack};