# Day-18 of #90DaysOfDevOps

# Docker for DevOps Engineers: Mastering Docker Compose and Containerization

In this blog, I'll be diving into some essential Docker concepts for DevOps engineers. Today’s focus is on Docker Compose and running containers as non-root users.

## **What is Docker Compose?**

Docker Compose is a powerful tool used to define and share multi-container applications. With Docker Compose, we can create a `docker-compose.yml` file to define the services required by our application and link them together. With just a single command, we can spin up or tear down the entire environment.

**Key Benefits of Docker Compose:**

* **Multi-container management:** You can define multiple services that work together in a single YAML file.
    
* **Ease of use:** With a single command, all the necessary services for the application are up and running.
    
* **Configuration management:** You can easily manage the configuration of all the services involved in your project.
    

Learn more about Docker Compose from [this tutorial](https://tecadmin.net/tutorial/docker/docker-compose/).

## **What is YAML?**

YAML stands for "YAML Ain’t Markup Language" and is commonly used for writing configuration files. It's human-readable and makes managing configurations simpler. YAML files use `.yml` or `.yaml` extensions.

If you want to get deeper into YAML, you can read more about it [here](https://www.redhat.com/en/topics/automation/what-is-yaml).

---

## **Task 1: Setting Up the Environment with Docker Compose**

In this task, we’ll set up a Spring Boot application using MySQL as the database. We'll define the services, configure the environment, and link the containers together using Docker Compose.

### **Steps:**

1. **Clone the Git Repository:**
    
    Clone the repository that contains the application code:
    
    ```bash
    git clone https://github.com/LondheShubham153/Springboot-BankApp.git
    ```
    
2. **Create the Dockerfile:**
    
    Create a `Dockerfile` for building and deploying the Spring Boot application:
    
    ```bash
    # Stage 1: Build the application
    FROM maven:3.8.3-openjdk-17 as builder
    WORKDIR /app
    COPY . /app
    RUN mvn clean install -DskipTests=true
    
    # Stage 2: Deploy the application
    FROM openjdk:17-alpine as deployer
    COPY --from=builder /app/target/*.jar /app/target/bankapp.jar
    EXPOSE 8080
    ENTRYPOINT ["java", "-jar", "/app/target/bankapp.jar"]
    ```
    
3. **Create the docker-compose.yml:**
    
    Create a `docker-compose.yml` file to configure the MySQL and Spring Boot services:
    
    ```yaml
    version: "3.8"
    services:
      mysql:
        image: mysql:latest
        container_name: Mysql
        environment:
          - MYSQL_DATABASE=BankDB
          - MYSQL_ROOT_PASSWORD=test@123
        volumes:
          - ./mysql-data:/var/lib/mysql
        networks:
          - bankapp
        healthcheck:
          test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost"]
          interval: 10s
          timeout: 5s
          retries: 3
          start_period: 30s
    
      bankapp:
        build: .
        container_name: Bankapp
        environment:
          - SPRING_DATASOURCE_USERNAME=root
          - SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/BankDB?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
          - SPRING_DATASOURCE_PASSWORD=test@123
        ports:
          - "8080:8080"
        depends_on:
          mysql:
            condition: service_healthy
        networks:
          - bankapp
        restart: always
        healthcheck:
          test: ["CMD-SHELL", "curl -f http://localhost:8080/actuator/health || exit 1"]
          interval: 10s
          timeout: 5s
          retries: 5
          start_period: 30s
    
    networks:
      bankapp:
    
    volumes:
      mysql-data:
    ```
    
4. **Running the Application:**
    
    Use the following command to bring up the environment:
    
    ```bash
    docker-compose up -d
    ```
    
5. **Accessing the Application:**
    
    Open the inbound rule of your instance to allow traffic on port 8080.
    

---

## **Task 2: Running Containers as a Non-Root User**

In this task, we’ll learn how to run Docker containers as a non-root user, ensuring that Docker commands can be executed without `sudo`.

### **Steps:**

1. **Create a User and Add to Docker Group:**
    
    Create a new user `amitabh` and add them to the Docker group:
    
    ```bash
    sudo usermod -aG docker amitabh
    newgrp docker
    ```
    
    This ensures that `amitabh` can execute Docker commands without needing `sudo`.
    
2. **Pull and Run a Custom Docker Image:**
    
    Pull a custom image:
    
    ```bash
    docker pull amitabhdevops/notes-app
    ```
    
    Run the container:
    
    ```bash
    docker run -d -p 8000:8000 --name notes-app amitabhdevops/notes-app
    ```
    
3. **Inspecting the Container:**
    
    After running the container, you can inspect it using:
    
    ```bash
    docker inspect notes-app
    ```
    
4. **Viewing Container Logs:**
    
    To view the container logs:
    
    ```bash
    docker logs notes-app
    ```
    
5. **Stopping and Starting the Container:**
    
    To stop the container:
    
    ```bash
    docker stop notes-app
    ```
    
    To start it again:
    
    ```bash
    docker start notes-app
    ```
    
6. **Removing the Container:**
    
    Once done, remove the container:
    
    ```bash
    docker stop notes-app && docker rm notes-app
    ```
    

---

### **Conclusion:**

Docker Compose simplifies the management of multi-container applications by defining all services in a single YAML file. Running containers as non-root users adds an extra layer of security and allows developers to work without `sudo` for Docker commands. These tasks are essential for DevOps engineers working with containerized applications.

Feel free to check out the [video tutorial](https://youtu.be/Tevxhn6Odc8) for further guidance.

For more updates, connect with me on [LinkedIn](https://www.linkedin.com/in/amitabh-devops/).

---