Automated Container Deployment with CD Pipelines

1. Preparing the Cloud Environment: AWS Elastic Beanstalk

AWS Elastic Beanstalk (EB) is a service that makes it easy to deploy and scale web applications. It manages the servers, load balancers, and scaling for you. We will create an EB environment that is configured to run Docker containers.

Once this process is complete, you will have a running environment in AWS waiting for our application code.

2. Granting Secure Access to AWS

For GitHub Actions to deploy code to your AWS account, it needs permissions. Hardcoding credentials is a major security risk. The standard practice is to create a dedicated service account (an IAM User in AWS) with restricted permissions and provide its credentials to GitHub securely.

1. Create an IAM User: This user will represent our GitHub Actions workflow. It will be granted programmatic access only.
2. Assign Permissions: We will grant this user the necessary permissions to interact with Elastic Beanstalk.
3. Generate Access Keys: We will generate an Access Key ID and a Secret Access Key for this user.
4. Store Keys in GitHub Secrets: We will store these keys in your GitHub repository's secrets, where our workflow can access them securely without exposing them in the code.

The next video segment walks through this entire process.

With this setup, your workflow can authenticate with AWS without ever exposing your secret keys.

3. Creating the Deployment Workflow

Now, let's update our .github/workflows/main.yml file to add the deployment stage. A best practice is to separate build and deploy logic into distinct jobs. This makes the pipeline clearer and more modular.

Our updated workflow will have two jobs:

1. build-and-publish: This job will be responsible for building the Spring Boot JAR, then building the Docker image and pushing it to Docker Hub. This is largely what we created in the last lesson. It creates our official, versioned artifact.
2. deploy: This new job will run only after build-and-publish succeeds. It will check out the source code and use a specialized GitHub Action to deploy it to the Elastic Beanstalk environment we just created.

For the deployment, we will use the popular einaregilsson/beanstalk-deploy action. This action simplifies the process by packaging our source code (including the Dockerfile) into a zip file and deploying it to Elastic Beanstalk, which will then build and run our container.

Here is the complete main.yml file. Replace the previous content with this.

name: Spring Boot CI/CD Pipeline

on:
  push:
    branches: [ "main" ]

jobs:
  build-and-publish:
    name: Build and Publish Docker Image
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'
          cache: maven

      - name: Build with Maven
        run: mvn -B package --file pom.xml

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Build and push Docker image
        uses: docker/build-push-action@v6
        with:
          context: .
          push: true
          tags: ${{ secrets.DOCKERHUB_USERNAME }}/your-repo-name:latest # IMPORTANT: Replace with your repo name

  deploy:
    name: Deploy to AWS Elastic Beanstalk
    runs-on: ubuntu-latest
    needs: build-and-publish # This job runs only after the build-and-publish job succeeds
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Deploy to Elastic Beanstalk
        uses: einaregilsson/beanstalk-deploy@v21
        with:
          aws_access_key: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws_secret_key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          application_name: your-eb-app-name # IMPORTANT: Replace with your EB application name
          environment_name: your-eb-env-name # IMPORTANT: Replace with your EB environment name
          region: your-aws-region # IMPORTANT: e.g., us-east-1
          deployment_package: deploy.zip

      - name: Create deployment package
        run: zip -r deploy.zip . -x ".git/*" ".github/*"

Before you commit, make sure you replace the placeholder values:

• your-repo-name: The name of your image repository on Docker Hub.
• your-eb-app-name: The name of the application you created in Elastic Beanstalk.
• your-eb-env-name: The name of the environment within your EB application.
• your-aws-region: The AWS region where you created your EB environment (e.g., us-east-1, eu-west-2).

4. Triggering the Deployment

You are now ready to launch your automated deployment.

1. Commit the updated .github/workflows/main.yml file to your local repository.
2. Push the changes to the main branch on GitHub.

git add .github/workflows/main.yml
git commit -m "feat: Add CD pipeline to deploy to Elastic Beanstalk"
git push origin main

This push will trigger the workflow. You can watch it run in the "Actions" tab of your GitHub repository. You should see the build-and-publish job run first, followed by the deploy job.

The final video segment shows what to expect during and after the deployment.

After the deployment succeeds, navigate to your Elastic Beanstalk URL. Instead of the sample page, your Spring Boot application should now be running and ready to accept requests.

Conclusion

Congratulations! You have successfully built a complete, end-to-end CI/CD pipeline. Your development process is now automated from the moment you commit code to the point where it's live in the cloud. This is a fundamental skill for any modern backend developer.

Key Takeaways:

• Continuous Deployment (CD) automates the release of software to a production or staging environment.
• Platform-as-a-Service (PaaS) like AWS Elastic Beanstalk abstracts away infrastructure management, simplifying deployment.
• IAM Roles and Policies are the standard way to grant secure, programmatic access to AWS resources for automated systems.
• GitHub Actions jobs can be chained with needs to create multi-stage pipelines (e.g., build first, then deploy).
• Deploying a source bundle with a Dockerfile is a straightforward method for containerized deployments on Elastic Beanstalk.

This lesson concludes our course on the foundations of backend development with Java and Spring. You have journeyed from basic web concepts through building robust REST APIs, connecting to databases, securing your application, and finally, automating its deployment. You now have a solid foundation to build upon as you tackle more complex, enterprise-level challenges. Keep building