How do you use Docker in a CI/CD pipeline?

Question

Accepted Answer

Docker plays a central role in modern CI/CD pipelines by enabling containerization, which packages an application with all its dependencies into a standardized unit . This ensures that the software runs the same way across different environments—from a developer's laptop to a test server to production—effectively solving the "it works on my machine" problem . In a pipeline, Docker is typically used to build an image of the application, run tests inside containers, push the image to a registry, and finally deploy it . The typical workflow starts when a developer pushes code to a version control system like Git. This action triggers the CI/CD tool (such as Jenkins, GitHub Actions, GitLab CI, or TeamCity) . The pipeline then checks out the code and uses a Dockerfile to build a Docker image. This image is a snapshot of the application and its environment . For example, a GitHub Actions workflow can be configured to build an image on every push to the 'main' branch . Advanced practices involve multi-stage builds to keep the final image lean and secure, using one stage for building the application and a smaller, separate stage for running it . Once the image is built, the pipeline can run tests inside a temporary container created from that image. This ensures tests are executed in an environment identical to where the application will eventually run . After tests pass, the image is tagged (e.g., with the Git commit SHA) and pushed to a container registry like Docker Hub, Amazon ECR, or a private Nexus repository . Storing the image in a registry creates an immutable artifact that can be deployed to any environment. The final stage is deployment. The CI/CD tool connects to the target environment, which could be a single Docker host or an orchestration platform like Kubernetes . It pulls the newly built image from the registry and runs it. For a Docker host, the pipeline might SSH into the server and execute `docker run`. For Kubernetes, it typically updates a deployment manifest and applies it with `kubectl`, triggering a rolling update of the application with zero downtime . name: CI/CD Pipeline
on:
  push:
    branches: [ main ]

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3

- name: Log in to Docker Hub
      uses: docker/login-action@v2
      with:
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}

- name: Build and push Docker image
      uses: docker/build-push-action@v4
      with:
        context: .
        push: true
        tags: ${{ secrets.DOCKER_USERNAME }}/my-app:latest

deploy:
    needs: build-and-push
    runs-on: ubuntu-latest
    steps:
    - name: Deploy to server
      uses: appleboy/ssh-action@v0.1.5
      with:
        host: ${{ secrets.VPS_HOST }}
        username: ${{ secrets.VPS_USER }}
        key: ${{ secrets.VPS_SSH_KEY }}
        script: |
          docker pull ${{ secrets.DOCKER_USERNAME }}/my-app:latest
          docker stop my-app || true
          docker rm my-app || true
          docker run -d --name my-app -p 80:3000 ${{ secrets.DOCKER_USERNAME }}/my-app:latest **Optimize for Cache**: Structure your Dockerfile to copy dependency files first and install them before copying the rest of the source code. This leverages Docker's layer caching to significantly speed up builds . **Use a .dockerignore**: Add a `.dockerignore` file to exclude unnecessary files (like `.git`, `node_modules`) from the build context, which makes the build faster and more secure . **Tag Images Precisely**: Use specific tags like the Git commit SHA alongside `latest` to enable easy rollbacks and traceability . **Scan for Vulnerabilities**: Integrate image scanning tools like Trivy into the pipeline to catch security vulnerabilities before images are deployed . **Implement Health Checks**: After deployment, run a health check command to verify the container is running correctly before marking the deployment as successful . **Automate Rollback**: Design the pipeline to automatically revert to the previous version if a deployment or health check fails, ensuring zero downtime .

How do you use Docker in a CI/CD pipeline?

Docker is used in CI/CD pipelines to create consistent, reproducible environments for building, testing, and deploying applications by containerizing the application and its dependencies.

Scenario Questions

Follow-up Questions