Illustrative end-to-end AWS DevOps CI/CD architecture using GitHub, CodePipeline, CodeBuild, Docker, ECR, ECS Fargate, Terraform and CloudWatch.
Explore an illustrative AWS DevOps pipeline in which GitHub commits trigger CodePipeline, CodeBuild builds a Docker image, Amazon ECR stores it and Amazon ECS Fargate deploys the containerized application. Terraform is used conceptually for infrastructure provisioning and CloudWatch provides monitoring.
This is a conceptual learning project for the TechTrivandrum website. It does not claim that the application or infrastructure has been built, deployed or tested.
Illustrative project only
This package describes an educational AWS DevOps architecture. It is not presented as a deployed, tested or production-ready implementation.
The goal is to demonstrate how modern DevOps services on AWS work together: source control, CI/CD orchestration, container image creation, registry publishing, container deployment, infrastructure as code, and monitoring.
The diagram shows the journey from a developer push in GitHub to a load-balanced application running on Amazon ECS Fargate. It also highlights VPC networking, IAM roles, secret management and CloudWatch observability.
A realistic DevOps pipeline needs visibility into build success, image publishing, deployment progress, service health and operational metrics. The sample dashboard visualizes those concepts in a clean educational format.
from flask import Flask
app = Flask(__name__)
@app.get("/")
def index():
return "Hello from TechTrivandrum illustrative AWS CI/CD demo!"
@app.get("/health")
def health():
return {"status": "ok"}
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
EXPOSE 8080
CMD ["gunicorn", "--bind", "0.0.0.0:8080", "app:app"]
CodeBuild can build a Docker image and output imagedefinitions.json for the standard ECS deployment action in CodePipeline. Environment variables and IAM permissions must be configured separately in a real setup.
version: 0.2
phases:
pre_build:
commands:
- export REPOSITORY_URI="$AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/$IMAGE_REPO_NAME"
- export IMAGE_TAG="${CODEBUILD_RESOLVED_SOURCE_VERSION:0:12}"
- aws ecr get-login-password --region "$AWS_DEFAULT_REGION" | docker login --username AWS --password-stdin "$AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com"
build:
commands:
- docker build -t "$REPOSITORY_URI:$IMAGE_TAG" .
post_build:
commands:
- docker push "$REPOSITORY_URI:$IMAGE_TAG"
- printf "[{\"name\":\"web\",\"imageUri\":\"%s\"}]" "$REPOSITORY_URI:$IMAGE_TAG" > imagedefinitions.json
artifacts:
files:
- imagedefinitions.json
terraform {
required_providers { aws = { source = "hashicorp/aws", version = "~> 5.0" } }
}
provider "aws" { region = var.aws_region }
variable "aws_region" { type = string }
resource "aws_ecr_repository" "app" {
name = "techtrivandrum-cicd-demo"
image_tag_mutability = "IMMUTABLE"
image_scanning_configuration { scan_on_push = true }
}
| Area | Illustrative idea |
|---|---|
| Source control | GitHub repository containing application code and CI/CD definitions |
| Pipeline orchestration | AWS CodePipeline coordinates the build and deployment stages |
| Container build | AWS CodeBuild creates and tags the Docker image |
| Image registry | Amazon ECR stores versioned container images |
| Runtime | Amazon ECS Fargate runs the containerized application |
| Traffic management | Application Load Balancer routes requests and performs health checks |
| Observability | Amazon CloudWatch provides logs, metrics and alarms |
| Infrastructure as Code | Terraform conceptually provisions the main AWS resources |
Explore a Raspberry Pi IoT concept for monitoring soil moisture, temperature, light and tank level, with proposed automatic irrigation and a plant-care dashboard.
Illustrative Raspberry Pi IoT monitoring concept for server rooms, combining environmental sensors, door and power status, dashboard visualizations, historical records and configurable alerts.
A complete CI/CD pipeline that takes a WordPress application from a developer's local Docker environment to an Amazon EKS cluster in production.