Docker | Zero to Hero

11. Docker in CI/CD Pipelines

Continuous Integration (CI) and Continuous Deployment (CD) are essential practices in modern software development. Docker can significantly enhance CI/CD pipelines by providing consistent and isolated environments for building, testing, and deploying applications.

Integrating Docker with CI/CD Tools

Several CI/CD tools integrate seamlessly with Docker, including Jenkins, GitLab CI, CircleCI, and Travis CI.

Jenkins

Jenkins is a popular open-source automation server. To integrate Docker with Jenkins, you can use the Docker plugin.

Setting up Docker in Jenkins:

1. Install Docker Plugin:

   • Navigate to Jenkins Dashboard > Manage Jenkins > Manage Plugins.
   • Install the Docker plugin.

2. Create a Jenkins Pipeline:

   • Create a Jenkinsfile in your project repository:

     Code kopieren
     pipeline {     agent {         docker {             image 'maven:3-alpine'             label 'my-defined-label'         }     }     stages {         stage('Build') {             steps {                 sh 'mvn -B clean package'             }         }     } } 

3. Run the Pipeline:

   • Configure a new pipeline job in Jenkins and point it to your repository.

GitLab CI

GitLab CI is integrated into GitLab and provides robust CI/CD capabilities.

Setting up Docker in GitLab CI:

1. Define .gitlab-ci.yml:

   
   Code kopieren
   image: docker:latest
   services:   - docker:dind
   stages:   - build   - test
   build:   stage: build   script:     - docker build -t my-app .
   test:   stage: test   script:     - docker run my-app ./run-tests.sh 

2. Push to Repository:

   • Push the .gitlab-ci.yml file to your repository.
   • GitLab CI will automatically pick up the configuration and run the pipeline.

CircleCI

CircleCI is a cloud-based CI/CD tool that supports Docker natively.

Setting up Docker in CircleCI:

1. Define .circleci/config.yml:

   
   Code kopieren
   version: 2.1
   jobs:   build:     docker:       - image: circleci/node:latest     steps:       - checkout       - setup_remote_docker       - run:           name: Build Docker image           command: docker build -t my-app .       - run:           name: Test Docker image           command: docker run my-app ./run-tests.sh
   workflows:   version: 2   build_and_test:     jobs:       - build 

2. Push to Repository:

   • Push the .circleci/config.yml file to your repository.
   • CircleCI will automatically run the defined pipeline.

Travis CI

Travis CI is another popular CI/CD tool that integrates well with Docker.

Setting up Docker in Travis CI:

1. Define .travis.yml:

   
   Code kopieren
   language: minimal
   services:   - docker
   script:   - docker build -t my-app .   - docker run my-app ./run-tests.sh 

2. Push to Repository:

   • Push the .travis.yml file to your repository.
   • Travis CI will automatically run the pipeline.

Automating Builds and Deployments

Using Docker in CI/CD pipelines allows for automated builds and deployments, ensuring that your application is always in a deployable state.

Example Pipeline

Here's an example of a comprehensive CI/CD pipeline that includes building, testing, and deploying a Dockerized application:

1. Build Stage:

   • Build the Docker image from the source code.
   • Tag the image with the current commit SHA or version number.

2. Test Stage:

   • Run unit tests inside the Docker container.
   • Run integration tests using Docker Compose to spin up the necessary services.

3. Deploy Stage:

   • Push the Docker image to a container registry (e.g., Docker Hub, AWS ECR).
   • Deploy the application to a staging or production environment using Docker Swarm, Kubernetes, or another orchestration tool.

Example .gitlab-ci.yml for a Full Pipeline:

Code kopieren
image: docker:latest
services:   - docker:dind
variables:   DOCKER_DRIVER: overlay2
stages:   - build   - test   - deploy
build:   stage: build   script:     - docker build -t my-app:$CI_COMMIT_SHA .     - docker tag my-app:$CI_COMMIT_SHA my-app:latest
test:   stage: test   script:     - docker run my-app:$CI_COMMIT_SHA ./run-tests.sh
deploy:   stage: deploy   script:     - echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin     - docker push my-app:$CI_COMMIT_SHA     - docker push my-app:latest 

12. Troubleshooting and Debugging Docker

Common Issues and Solutions

1. Container Fails to Start:

   • Check container logs with docker logs <container_id>.
   • Ensure all required environment variables are set.

2. Docker Daemon Not Running:

   • Verify the Docker service status with systemctl status docker.
   • Restart the Docker service with systemctl restart docker.

3. Image Pull Failure:

   • Check network connectivity.
   • Ensure the image name and tag are correct.
   • Use docker pull <image_name>:<tag> to pull the image manually.

4. Permission Issues:

   • Ensure your user is part of the docker group.
   • Check file and directory permissions.

Debugging Techniques

1. Using docker logs:

   • Retrieve logs from a container to understand runtime issues.
   • Example: docker logs my-container

2. Inspecting Containers:

   • Use docker inspect to get detailed information about a container’s configuration and state.
   • Example: docker inspect my-container

3. Entering a Running Container:

   • Use docker exec to run commands inside a running container.
   • Example: docker exec -it my-container /bin/bash

4. Network Troubleshooting:

   • Use docker network ls to list networks and docker network inspect to inspect them.
   • Example: docker network inspect my-network

13. Docker and Kubernetes

Introduction to Kubernetes

Kubernetes (K8s) is an open-source platform for automating the deployment, scaling, and management of containerized applications. Kubernetes works with Docker and other container runtimes.

Deploying Docker Containers on Kubernetes

Setting Up Kubernetes

1. Install kubectl:

   • Follow the installation guide for your operating system: Install kubectl.

2. Set Up a Kubernetes Cluster:

   • Use a local tool like Minikube for development: Install Minikube.
   • Alternatively, use managed Kubernetes services like GKE, EKS, or AKS.

Creating Kubernetes Resources

1. Pod:

   • A Pod is the smallest deployable unit in Kubernetes, representing a single instance of a running process.
   • Example YAML file (pod.yaml):

     Code kopieren
     apiVersion: v1 kind: Pod metadata:   name: my-pod spec:   containers:   - name: my-container     image: nginx 

2. Deployment:

   • A Deployment manages a set of identical Pods and ensures that the specified number of Pods are running.
   • Example YAML file (deployment.yaml):

     
     Code kopieren
     apiVersion: apps/v1 kind: Deployment metadata:   name: my-deployment spec:   replicas: 3   selector:     matchLabels:       app: my-app   template:     metadata:       labels:         app: my-app     spec:       containers:       - name: my-container         image: nginx 

3. Service:

   • A Service provides network access to a set of Pods.
   • Example YAML file (service.yaml):

     Code kopieren
     apiVersion: v1 kind: Service metadata:   name: my-service spec:   selector:     app: my-app   ports:     - protocol: TCP       port: 80       targetPort: 80 

Deploying and Managing Resources

1. Apply Configuration:

   • Use kubectl apply to create or update resources:

     Code kopieren
     kubectl apply -f deployment.yaml kubectl apply -f service.yaml 

2. Check Status:

   • Use kubectl get to list resources and check their status:

     Code kopieren
     kubectl get pods kubectl get deployments kubectl get services 

3. Scale Deployment:

   • Use kubectl scale to scale the number of replicas:

     Code kopieren
     kubectl scale deployment my-deployment --replicas=5 

4. Delete Resources:

• Use kubectl delete to remove resources:

  Code kopieren
  kubectl delete -f deployment.yaml kubectl delete -f service.yaml