##### Description
This project implements an end-to-end Jenkins CI/CD pipeline for a Java web application, automating the journey from source code validation to staging deployment and controlled production promotion on AWS ECS Fargate. The pipeline integrates automated testing, code quality analysis, artifact management, Docker image publishing, and cloud deployment.
The project is designed around two pipelines: a Stage pipeline responsible for building, testing, analyzing, containerizing, and deploying the application to staging, and a Prod pipeline that promotes the same tested Docker image to production.
##### Key Features
- Automated CI/CD Pipeline: Configured Jenkins to automatically trigger builds through a GitHub webhook when changes are pushed to the jenkins-cicd branch.
- Automated Testing: Integrated Maven to build the Java application and execute unit tests before deployment.
- Code Quality & Quality Gates: Integrated Checkstyle and SonarQube to analyze code quality and prevent the pipeline from progressing when the Quality Gate fails.
- Artifact Management: Configured Nexus Repository to manage and store versioned Maven build artifacts.
- Docker Containerization: Implemented a multi-stage Docker build that separates the Maven build environment from the lightweight Tomcat runtime.
- Amazon ECR Integration: Built and published versioned Docker images to Amazon ECR using Jenkins build numbers for release traceability.
- Staging Deployment: Automatically deployed successfully validated images to an AWS ECS Fargate staging environment.
- Production Promotion: Implemented a controlled promotion process where the same Docker image tested in staging is deployed to production without rebuilding or retesting.
- Slack Notifications: Integrated Slack notifications to provide build and deployment status for every pipeline execution.
##### CI/CD Pipeline
GitHub
→ Jenkins
→ Maven Build & Test
→ Checkstyle
→ SonarQube Quality Gate
→ Nexus
→ Docker Build
→ Amazon ECR
→ Staging ECS
→ Production ECS
##### AWS Infrastructure
- Amazon ECR: Used as the private Docker container registry for application images.
- Amazon ECS Fargate: Used to run the containerized Java application without managing servers.
- Application Load Balancer: Used to route application traffic to the ECS service.
- AWS IAM: Used to provide the required permissions for Jenkins and AWS resources.
- Separate Environments: Configured separate ECS environments for staging and production deployments.
##### Technologies Used
- CI/CD: Jenkins, GitHub Webhooks
- Build & Testing: Maven, JDK
- Code Quality: Checkstyle, SonarQube
- Artifact Management: Nexus Repository
- Containerization: Docker
- Container Registry: Amazon ECR
- Cloud Deployment: Amazon ECS Fargate
- Cloud Services: AWS IAM, Application Load Balancer
- Notifications: Slack
- Application: Java, Tomcat
##### Security & Reliability
- Sensitive credentials are managed through Jenkins Credentials instead of being stored directly in the pipeline configuration.
- Docker images are tagged with Jenkins build numbers to provide traceability between pipeline executions and deployed releases.
- Production deployments use the same Docker image that was successfully validated in staging.
- A manual promotion process provides an additional control before deploying changes to production.
##### Project Outcome
The project demonstrates a complete Jenkins-based DevOps workflow for delivering a containerized Java application to AWS. It combines automated testing, code quality validation, artifact management, Docker containerization, AWS ECR, ECS Fargate, staging deployment, and controlled production promotion into a repeatable CI/CD process.
