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

# Introduction

Docker-compose is a tool that combines and runs multiple containers of interrelated services with a single command. It is a tool to define all the application dependencies in one place and let the Docker take care of running all of those services in just one simple command `docker-compose up`.

If you are following this course on your local machine remember to install the Docker Compose [from the official documentation website.](https://docs.docker.com/compose/install/)


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

Below is an example of docker-compose file that combines a MySQL database service with a Python flask app that implements a simple login and logout web application.

version: '3'
services:
  web:
    # Path to dockerfile.
    # '.' represents the current directory in which
    # docker-compose.yml is present.
    build: .

    # Mapping of container port to host
    
    ports:
      - "5000:5000"
    # Mount volume 
    volumes:
      - "/usercode/:/code"

    # Link database container to app container 
    # for reachability.
    links:
      - "database:backenddb"
    
  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 define variables. 
    environment:
      - "MYSQL_ROOT_PASSWORD=root"
      - "MYSQL_USER=testuser"
      - "MYSQL_PASSWORD=admin123"
      - "MYSQL_DATABASE=backend"
    # 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:
      - "/usercode/db/init.sql:/docker-entrypoint-initdb.d/init.sql"
    

# Docker Compose file explanation

The Compose file is in YAML format. It's a very simple language. You can validate the YAML file using any of the online validator tools. [Here is one for reference.](https://yamlchecker.com/)

So, without further ado, let's understand the docker-compose file line by line.

* **version '3'**: Like other software, docker-compose also started with version 1.0. At the time of writing this course, the current latest version of Compose file is 3.7.

   We have specified the version of Compose file we will be using and Docker will provide the features accordingly. 

  Compose versions are backward compatible, hence it is recommended to use the latest version.


* **services**: The services section defines all the docker images required and need to be built for the application to work. In short, it's the collection of all different components of the application that are dependent on each other.

   We have two services namely, web and database. In Compose version 3, we can have multiple containers of the same service as well. 

  We will see that in the next section, but if you are curious, you can check [here](https://docs.docker.com/compose/compose-file/) under the deploy section in the compose file.  

* **web**: The name `web` is the name of our Flask app service. It can be anything. Docker Compose will create containers with this name.

* **build**: This clause specifies the Dockerfile location. '.' represents the current directory where the docker-compose.yml file is located and Dockerfile is used to build an image and run the container from it. We can also provide the absolute path to Dockerfile instead of the current working directory symbol.

* **ports**: The `ports` clause is used to map the container ports to the host machine's port. It creates a tunnel from the specified container port to the provided host machine's port.

  This is the same as using the `-p 5000:5000` option to map the container's 5000 port to the host machine's 5000 port while running the container using the `docker run` command.

* **volumes**: This is the same as the `-v` option used to mount disks in `docker run` command. Here, we are attaching our code files directory to the container's `/code` directory so that we don't have to rebuild the images for every change in the files.

  This will also help in auto-reloading the server when running in debug mode.

* **links**: Links literally link one service to another. In the bridge network, we have to specify which container should be accessible to what container using a link to the respective containers.

  Here, we are linking the database container to the web container, so that our web container can reach the database in the [bridge network](https://www.educative.io/courses/working-with-containers-docker-docker-compose/introduction-to-docker-networks#network-fundamentals). Links are a legacy way of connecting services and are [deprecated](https://docs.docker.com/network/links/). You will learn the alternative to `links` (that is `networks`) in upcoming lessons. 

* **image**: If we don't have a Dockerfile and want to run a service directly using an already built docker image, then specify the image location using the 'image' clause. Compose will pull the image and fork a container from it.

* **environment**: Any environment variable that should be present in the container can be created using the `environment` clause. This does the same work as the `-e` argument in the `docker run` command while running a container.






Docker-Compose Explanation

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

Docker-Compose Explanation

Introduction