DevOps · 2025
Container Delivery
From application source to a reproducible container.
My contribution
I built the Express service, Docker image and AWS bootstrap path across ECR, ECS, IAM, networking and logs.
Evidence
Repository and an uncut local build, container start and live endpoint recording.
Scope & limitations
The GitHub Actions workflow is not committed, npm test is a placeholder and the Node 18 runtime is end-of-life.
- Node.js
- Express
- Docker
- ECR
- ECS Fargate
- CloudWatch
See it in action.
00:36 · Local recordingAbout this demonstration
This is an uncut local run from the repository: npm executes, Docker builds the image, a container starts on port 3001, and the live /health and /api/info endpoints return their runtime JSON.
npm test -> Docker build -> container start -> live health and information responses.
The problem & approach
The problem
I wanted to understand everything around the container, not just the image. I had to prepare the registry, permissions, network access, task definition, service and logs consistently before the application could run on AWS.
The approach
I combined a small Express service, a Docker image and a nine-stage AWS setup script. I exposed a home page, health contract and information endpoint, then prepared the registry, runtime identity, cluster, networking, logging and Fargate service around them.
How it works
- 01Express service
- 02Docker image
- 03Amazon ECR
- 04ECS task definition
- 05Fargate service
- 06CloudWatch logs
- I built an Express application with /, /health and /api/info routes plus environment and container identity output.
- I created a Node 18 Alpine image that installs the application, exposes port 3001 and starts it through npm.
- I wrote an AWS CLI setup script that stops on errors and verifies the active AWS identity before provisioning.
- I prepared an ECR repository with scan-on-push, an ECS execution role, an ECS cluster and a CloudWatch log group.
- I defined a Fargate task and service on the default VPC with a port 3001 security rule and public IP assignment.
- I created a dedicated IAM user and documented the repository-secret handoff for the planned GitHub automation path.
Technical decisions & lessons
Express
I kept the service small while still exposing runtime and health information.
Docker
I used it to turn the application and Node runtime into one repeatable deployment unit.
ECR
I used it to store versioned container images inside the AWS delivery path.
ECS Fargate
I used it to run the workload without managing EC2 hosts directly.
CloudWatch
I used it for runtime logs and deployment investigation.
Challenges
- I had to align IAM, ECR, the default VPC, port 3001 access, the task definition and CloudWatch before the service could settle.
- I documented a GitHub Actions test-build-deploy flow, but the current main branch does not contain that workflow file; adding and verifying it remains my clearest next implementation step.
- The current npm test command is a placeholder, so I still need real endpoint tests before I would call the pipeline production-ready.
What I learned
- I learned how application code, a container image, a registry and a managed runtime form one delivery path.
- I learned why a stable health endpoint is the simplest contract between an application and deployment tooling.
- I learned how IAM, network access and centralized logs surround the visible application deployment.
- I learned to evaluate documented automation separately from committed, executable automation.
Runtime contract · http
GET /health
{
status: "healthy",
environment: process.env.ENVIRONMENT
}