🚀 Deploying a Spring Boot Application on AWS EC2 with CI/CD Using GitHub Actions & Docker..

We recently deployed our Spring Boot backend on an AWS EC2 instance and set up a CI/CD pipeline using GitHub Actions and Docker. In this post, I'll walk through the architecture, flow, and key concepts behind our deployment pipeline.

📌 Tech Stack

• Backend: Spring Boot
• Cloud: AWS EC2
• Containerization: Docker
• CI/CD: GitHub Actions
• Version Control: GitHub
• Server Access: SSH

🧠 Why CI/CD?

Before CI/CD:

• Manual builds and server access
• Error-prone deployments
• Time-consuming updates

After CI/CD:

• Automatic builds on every push
• Consistent, reliable deployments
• Faster iteration cycles
• Production-ready workflow

🏗️ High-Level Architecture

Git Push
   ↓
GitHub Actions (CI/CD)
   ↓
Build Spring Boot App
   ↓
Create Docker Image
   ↓
Push Image to Docker Hub
   ↓
SSH into EC2
   ↓
Pull Latest Image
   ↓
Run Docker Container

🧩 Step 1: Prepare the Spring Boot Application

Project Structure

spring-boot-app/
├── src/
├── target/
├── Dockerfile
├── .dockerignore
├── .env
├── pom.xml

🐳 Step 2: Dockerize the Spring Boot Application

Dockerfile

Create a Dockerfile in your project root:

FROM openjdk:17-jdk-slim

WORKDIR /app

COPY target/*.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

This Dockerfile:

• Uses Java 17
• Copies the built JAR
• Exposes port 8080
• Runs the Spring Boot app

🔐 Step 3: Environment Variables (.env)

Create a .env file (do NOT push this to GitHub):

SPRING_DATASOURCE_URL=jdbc:mysql://localhost:3306/db
SPRING_DATASOURCE_USERNAME=root
SPRING_DATASOURCE_PASSWORD=password
JWT_SECRET=your-secret-key

In application.properties:

spring.config.import=optional:file:.env[.properties]

☁️ Step 4: Set Up AWS EC2

1️⃣ Launch EC2 Instance

• OS: Ubuntu
• Instance Type: t2.micro (free tier)
• Open ports:
  • 22 (SSH)
  • 8080 (Spring Boot)

2️⃣ Connect to EC2 via SSH

ssh -i key.pem ubuntu@<EC2_PUBLIC_IP>

3️⃣ Install Docker on EC2

sudo apt update
sudo apt install docker.io -y
sudo systemctl start docker
sudo systemctl enable docker
sudo usermod -aG docker ubuntu

Log out and log back in for Docker permissions to take effect.

🐳 Step 5: Set Up Docker Hub

• Create a Docker Hub account
• Create a repository (example: username/spring-backend)

Log in from EC2 if needed:

docker login

⚙️ Step 6: GitHub Actions CI/CD Pipeline

Workflow File Location

.github/workflows/deploy.yml

GitHub Secrets Required

Add these in GitHub → Settings → Secrets → Actions:

• DOCKER_USERNAME
• DOCKER_PASSWORD
• EC2_HOST
• EC2_USER
• EC2_SSH_KEY

GitHub Actions Workflow (deploy.yml)

name: Spring Boot CI/CD

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Code
        uses: actions/checkout@v3

      - name: Set up JDK
        uses: actions/setup-java@v3
        with:
          java-version: '17'

      - name: Build with Maven
        run: mvn clean package -DskipTests

      - name: Docker Login
        run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin

      - name: Build Docker Image
        run: docker build -t ${{ secrets.DOCKER_USERNAME }}/spring-backend:latest .

      - name: Push Docker Image
        run: docker push ${{ secrets.DOCKER_USERNAME }}/spring-backend:latest

      - name: Deploy to EC2
        run: |
          echo "${{ secrets.EC2_SSH_KEY }}" > key.pem
          chmod 600 key.pem

          ssh -o StrictHostKeyChecking=no -i key.pem ${{ secrets.EC2_USER }}@${{ secrets.EC2_HOST }} << EOF
            docker pull ${{ secrets.DOCKER_USERNAME }}/spring-backend:latest
            docker stop backend || true
            docker rm backend || true
            docker run -d -p 8080:8080 --env-file .env --name backend ${{ secrets.DOCKER_USERNAME }}/spring-backend:latest
          EOF

🔐 Step 7: How SSH Deployment Works

• GitHub Actions connects to EC2 via SSH
• Pulls the latest Docker image
• Stops the old container
• Removes the old container
• Runs the new version

This ensures zero manual deployment.

🔄 Step 8: What Happens on Every Push?

git push origin main

Automatically:

1. CI pipeline starts
2. Spring Boot app builds
3. Docker image is created
4. Image is pushed to Docker Hub
5. EC2 pulls the latest image
6. Backend is redeployed

🧹 Optional: Clean Old Docker Images on EC2

docker image prune -f

This prevents disk space issues.

✅ Benefits of This Setup

• Fully automated deployment
• Consistent environment across builds
• No manual server access needed
• Faster development cycle
• Production-ready backend

🎯 Final Thoughts

This CI/CD pipeline transformed our Spring Boot backend into a scalable, professional system.

With GitHub Actions, Docker, and AWS EC2, we achieved reliable deployments with minimal effort.

If you're building backend applications, CI/CD isn't optional—it's essential.