Transform Your Development Workflow: 5 Surprising Use Cases of Docker with YAML Explained

Introduction

In software development, is important to have tools to improve the development process, it means faster, and easier, making automatizations-Docker has emerged as one of those tools, revolutionizing the way developers and operations teams manage their applications. Are you wondering how Docker can transform your workflow? Here, we present five concrete use cases that show how Docker can take your development and deployment to the next level.

How Docker Uses YAML

Docker uses YAML (YAML Ain’t Markup Language) files to define multi-container applications. YAML is a human-readable data serialization standard that is often used for configuration files and in applications where data is being stored or transmitted. In the context of Docker, YAML files are used with Docker Compose to describe the services, networks, and volumes that your application uses.

Docker Compose YAML Basics

Docker Compose is a tool for defining and running multi-container Docker applications. With Compose, you use a YAML file to configure your application’s services. Then, with a single command, you create and start all the services from your configuration.

Basic Structure of a docker-compose.yml File

A docker-compose.yml file typically includes definitions for:

• Services: The various containers that make up your application.
• Networks: Custom networks for your services to communicate.
• Volumes: Persistent storage for your services.

Here’s a breakdown of a simple docker-compose.yml file:

version: '3.8'  # Version of the Docker Compose file format

services:  # Define the services (containers) for the application
  web:  # A service named 'web'
    image: mywebapp:latest  # The Docker image to use
    build: .  # Build the image from the current directory
    ports:
      - "8000:8000"  # Map host port 8000 to container port 8000
    depends_on:
      - db  # The 'web' service depends on the 'db' service
      - redis  # The 'web' service depends on the 'redis' service

  db:  # A service named 'db'
    image: postgres:latest  # The Docker image to use for PostgreSQL
    environment:  # Environment variables for the container
      POSTGRES_DB: mydatabase
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password

  redis:  # A service named 'redis'
    image: redis:latest  # The Docker image to use for Redis        

1. Local Development and Testing: Say Goodbye to “Works on My Machine”

Have you ever encountered the dreaded “works on my machine”? Docker eliminates this phrase from the developer’s vocabulary by encapsulating applications and their dependencies in containers. Each developer can run a Docker container that includes all necessary dependencies, ensuring everyone works in an identical environment.

Example:

# docker-compose.yml
version: '3.8'
services:
  web:
    image: mywebapp:latest
    build: .
    ports:
      - "8000:8000"
    depends_on:
      - db
      - redis
  db:
    image: postgres:latest
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
  redis:
    image: redis:latest        

2. Microservices: Independent Deployment and Scalability

Microservices architecture allows each application component to be deployed and scaled independently. Docker facilitates this process by encapsulating each microservice in its container. This way, you can update or scale a microservice without affecting others.

Example:

# docker-compose.yml for microservices
version: '3.8'
services:
  userservice:
    image: userservice:latest
    build: ./userservice
    ports:
      - "5000:5000"
  orderservice:
    image: orderservice:latest
    build: ./orderservice
    ports:
      - "5001:5001"
  productservice:
    image: productservice:latest
    build: ./productservice
    ports:
      - "5002:5002"        

3. Continuous Integration and Continuous Delivery (CI/CD): Total Automation

Automating the build, test, and deployment of your application is essential for an agile workflow. Docker integrates seamlessly with CI/CD tools like Jenkins, GitLab CI/CD, and GitHub Actions, allowing you to build Docker images, run tests, and deploy containers automatically.

Example:

# .gitlab-ci.yml for GitLab CI/CD
stages:
  - build
  - test
  - deploy        

build:
  stage: build
  script:
    - docker build -t mywebapp:latest .
  tags:
    - docker
test:
  stage: test
  script:
    - docker run --rm mywebapp:latest pytest
  tags:
    - docker
deploy:
  stage: deploy
  script:
    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
    - docker push mywebapp:latest
  tags:
    - docker
  environment:
    name: production
    url: https://example.com
  only:
    - master        

4. Application Deployment: Consistency Across Environments

Deploying applications in different environments can be a headache due to differences in configurations and dependencies. Docker ensures that your application runs the same way in any environment that supports Docker, whether on local servers or cloud providers.

Example:

# Dockerfile to build the image
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]        

5. Automated Testing: Production Simulation

To ensure your application works correctly in production, it’s vital to test in an environment that simulates production as closely as possible. Docker allows you to create containers that mimic this environment, making it easy to run automated tests.

Example:

# docker-compose.test.yml for automated testing
version: '3.8'
services:
  web:
    image: mywebapp:latest
    build: .
    depends_on:
      - db
  db:
    image: postgres:latest
    environment:
      POSTGRES_DB: testdb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password        

# Script to run tests
docker-compose -f docker-compose.test.yml up -d
docker-compose -f docker-compose.test.yml run web pytest
docker-compose -f docker-compose.test.yml down        

Conclusion

Docker is not just a tool; it’s a paradigm shift in how we develop, test, and deploy applications. From ensuring consistent environments to facilitating scalability and automation, Docker offers solutions that significantly transform and improve the software development workflow. If you haven’t integrated Docker into your projects yet, now is the perfect time to start and experience its benefits firsthand.

Follow me on Linkedin

https://www.dhirubhai.net/in/kevin-meneses-897a28127/

and Medium https://medium.com/@kevinmenesesgonzalez/subscribe

Subscribe to the Data Pulse Newsletter https://www.dhirubhai.net/newsletters/datapulse-python-finance-7208914833608478720