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

Congratulations!! You've made it this far. You can pat your back, because as you have done a wonderful job. Solving this exercise might have squeezed all your developer plus Docker knowledge, but you did not give up and that's a good thing.

Even if you were not able to solve this exercise, but you've tried your best, kudos to you because this exercise was a little tricky one. 
So, let's go through the solution and see what you might have missed.

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/:/exercise_3"

    # Link database container to app container 
    # for rechability.
    links:
      - "database:exercisedb"

    command: ["flask", "run"]

    environment:
      - "FLASK_RUN_HOST=0.0.0.0"

    depends_on:
      - database
    
  database:

    # image to fetch from docker hub
    build:
      context: ./db
      dockerfile: Dockerfile-db
    #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"
    

## Base Python Image for App
FROM python:3.9-rc-buster


# Setting up Docker environment 
# Setting Work directory for RUN CMD commands
WORKDIR /exercise_3


#Copy requirements file from current directory to file in 
#containers code directory we have just created.
COPY requirements.txt requirements.txt

#Run and install all required modules in container
RUN pip3 install -r requirements.txt

#Copy current directory files to containers code directory
COPY . .

# Docker
Docker and Docker compose for developers.

from flask import Flask, render_template, request, redirect
from flask_mysqldb import MySQL

app = Flask(__name__)

app.config['MYSQL_PASSWORD'] = 'admin123'
app.config['MYSQL_USER'] = 'testuser'
app.config['MYSQL_DB'] = 'backend'

app.config['MYSQL_HOST'] = 'exercisedb'

db  = MySQL(app)


### Temporary database
### We will replace this dictionary

@app.route('/', methods=['POST', 'GET'])
def login():

    cursor = db.connection.cursor()


    if request.method == 'GET':
        return render_template('form.html', title='Sign In')
    else:
        username = request.form.get("username")
        password = request.form.get("password")


        status = cursor.execute('''SELECT username FROM `users` WHERE `username`="{0}" and `password`="{1}"'''.format(username,password))

        if status:


            return "<h1>Hi {0}, You are successfully logged in.</h1>".format(username)
        else:
            

            return " <h2>Wrong Credentials! Please <a href=\'/\'>try again</a></h2>"

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

Here, we will only see the new changes in docker-compose.yml file. Since we have covered the rest of the commands in previous lessons, we don't need to repeat them but you can go back and revise them in case you don't understand all of them. 


# Web

- The very first thing is to set up the basic skeleton using `build` and `ports` keyword for our web service.

- Next, we check what the working directory is in Dockerfile and mount the host volume accordingly.

- Then we cross-check the DB credentials used in the app.py file. If it is changed, match those in the links section, because `links` will decide what should be the reachable hostname of the database service.

- `command`: Here comes the tricky one. This will pass the command to the container to execute. If you cross-check the Dockerfile, you will notice there is no `CMD` or `ENTRYPOINT` at the end to make a container executable. So, we are passing the command to run the Flask app from the docker-compose.yml file itself.

- `environment`: This is not a very tricky one, but if you do not set the `FLASK_RUN_HOST` variable to 0.0.0.0, you won't be able to access it outside of the container.

# Database

There is nothing new in this section. But you have to focus on the environment variables passed to it because this will be used by the application and any spelling mistake in these will result in a connection failure between the app and the database.

Writing down password and DB credentials in code files is not good practice. So at the end of this course, you will learn how to pass those to the application as well as to the container.

In the next section, you will learn some advanced topics of the Docker system which will strengthen your Docker skills. After solving this tricky exercise, you must be eager to learn some advanced topics.

So, jump to the section whenever you are ready.








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

Solution