Gain insights into Docker fundamentals, delve into advanced concepts like database connectivity and Docker Compose, and discover how to monitor and scale services with Docker Swarm.

course_final_image.tar.gz

Flask App_new

docker-compose

Docker_build

flask_venv

Flask_demo_test

add db to container

Exercise

Exercise 2

exercise 3

exercise_4

Bonus Section - Flask

exercise 3-copy

docker-compose-copy

Docker_build-copy

add db to container-copy

Exercise 2-copy

exercise_4-copy

Bonus Section - Flask-copy

Docker_build-copy-copy

Whether you are a DevOps beginner or just a developer who wants to start working with containers, you’re in the right place. Docker is an in-demand technology that you will be exposed to frequently while on the job.

 

Docker is used for setting up, deploying, and running applications, at scale, by containerizing them. More on that later. Docker also provides developers with a consistent environment for product development, and along with Kubernetes, makes managing the development lifecycle a breeze.

 

In this course, you will learn the fundamentals of Docker such as containers, images, and commands. You’ll then progress to more advanced concepts like connecting to a database container and how to simplify workflows with Docker Compose. At the end, you’ll learn how to monitor clusters and scale Docker services with Swarm.

Working with Containers: Docker & Docker Compose

In this lesson, we will automate all the steps we took to create and deploy our app using services.

> Clone the project using `git clone https://github.com/venky8283/Docker.git`  
>Type `git checkout fc0a9af7f7fb2c8d61e4777befdbf451568cf578` to get the exact code used in this lesson.

We did the same thing while working with docker-compose. In docker-compose, we created a docker-compose file and automated all the steps in it.

We will modify the same docker-compose file to run with docker-swarm because Compose and Docker stack are similar on some level.

Let's list all the steps we need to automate as follows:

- Pull the Flask_app v3.0 image from Docker Hub

- Increase the number of replicas of the Flask app to three

- Create a database service

- Establish communication between services using the network

- Create a visualizer service to monitor the swarm

# Docker stack implementation

Docker stack is a bundle of services. When you want to deploy a set of services to a machine, instead of creating each service separately, Docker stack allows users to deploy the full-stack of the services at once.

Let's see changes in our docker-compose file below.

version: '3.8'
services:
  web:
    
    image: venky8283/flask_app:3.0

    # Mapping of container port to host
    
    ports:
      - "5000:5000"
    # Mount volume 
    volumes:
      - "./:/code"
    
    networks:
      - app
    
    deploy:
      replicas: 3
    
  database:

    # image to fetch from docker hub
    image: mysql/mysql-server:5.7

    # Environment variables for startup script
    # container will use these variables
    # to start the container with these defined variables. 
    env_file:
      - ./.env

    # Mount init.sql file to automatically run 
    # and create tables for us.
    # everything in docker-entrypoint-initdb.d folder
    # is executed as soon as container is up nd running.
    volumes:
      - "./db/init.sql:/docker-entrypoint-initdb.d/init.sql"
    
    deploy:
      replicas: 2

    networks:
      - app
  
  viz:

    # Visualizer image for swarm cluster.

    image: dockersamples/visualizer

    # Mapping container ports to host port

    ports: 

      - "8080:8080"

    # Mounting docker socket to container.
    
    volumes:

      - "/var/run/docker.sock:/var/run/docker.sock"
    
    networks:
      - app

    

  
networks:
  app:
    

- `Line 1:` It is good practice to lock the exact version of Compose we are using.

- `Line 7:` We removed the build keyword and added an image location for the app. 'Build' is not supported in the swarm.

- `Line 17-21:` We added a deploy keyword to inform Docker swarm to maintain three instances of our app service. Also, we mentioned in which network our service will be located in.

- `Line 41-45:` We defined the deployment of database containers along with the network information.

- `Line 47-65:` We Defined the visualizer service. We have defined the image to be pulled from Docker Hub,  ports mapping, mounted a Docker socket to sync events and the network to be used by the service. 

- `Line 71-73:` We told the Docker swarm to create a network named app so that it can be used by the services.


Docker service also provides in-depth configuration for deployment at CPU level, but we will not make our docker-compose file more complex.

A docker-compose alternative for swarm cluster

Introduction to Course

Why Docker?

Getting Started With Docker

Docker Fundamentals

Automation using Dockerfile

Advance Docker

Introduction to Docker-Compose

Exposure to Docker Swarm

Bonus Section

Automating Deployments Using Docker Stack