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

Getting exposure to production systems before starting on any project will definitely give you a positive feeling and confidence. This lesson is all about how the app looks like in production.

>There are n number of ways an app can be deployed in production, but the idea behind is the same: using an architecture which can survive the load.

> Type `git log` and
checkout the commit 327b245bbd4392d3dee40a24457c3ed44a1ef5b9 (    Flask in Production with Nginx - Microservices) for code related to this lesson.



# Production code explanation 
You will see a lot of changes in this version of the code. Let's list them one by one.

## Docker level
1. New Nginx service
2. Read-only mounting of the file system
3. Resources limitation

## App level

1. New wsgi server `gunicorn` instead of flask server.
>The **Gunicorn** "Green Unicorn" is a Python web server gateway interface HTTP server. It is a pre-fork worker model ported from Ruby's Unicorn project. The Gunicorn server is broadly compatible with a number of web frameworks, simply implemented, light on server resources and fairly fast


All these changes will make our app stable and robust. Adding extra replicas of services leads to a better distribution of load received by the app. Let's see the detailed explanation of every change we have done in this version.

# Nginx service

Flask comes with a prebuilt development server. As it is a development server, we cannot deploy the app to production with a server which cannot handle production load. So, we need something that is tested for production loads and can manage multiple requests efficiently for our app. These are called ***proxy servers.***

Two famous names for proxy servers are `Nginx` and `Apache`. Most of the time PHP coders use Apache and Python coders use Nginx. This is just a trend and not a strict guideline. We can use any of these two. Nginx is easy for configurations and is widely used for Python apps. So, we will use Nginx.

>Proxy servers handle requests for static content by themselves and pass on the request which can only be served by language-specific servers to upstream servers, like Gunicorn. This makes serving requests a little faster. We have used Gunicorn here as an upstream server.  

In the Nginx section in a docker-compose file, HTTP and HTTPS ports are mapped to hosts HTTP and HTTPS ports. The reason is very simple. 

Whenever you open up any website using `https`, you will see a lock icon. This means the website is served over a secure HTTP protocol, and certificates of security are shared and accepted by client and server. To simulate that in development, we need to make a localhost server on HTTPS, which is impossible without certificates.

So, to make HTTPS work over HTTPS, we created self-signed certificates. Self-signed certificates are accepted by only the local server and not by anybody else. Read more about [self-signed certificates here.](https://letsencrypt.org/docs/certificates-for-localhost/)

***These certificates are mounted to the Nginx certificate directory and used in SSL configuration of Nginx.***

- `volumes` is a section of Nginx service that mounts the Nginx configuration and certificates to the containers configuration directory.

- `ports` maps host's HTTP and HTTPS port to containers HTTP and HTTPS ports. 

- `deploy` section deploys two replicas to distribute the load and limit the host CPU usage by the container.

People use very complex Nginx configuration to secure a server from different attacks and there is a tool for generating these config files for a production system. [Certbot](https://certbot.eff.org/) is one of them.
 
But here we are using a simple one, which forwards all HTTP requests to the https server, and https server will forward requests to the upstream pythonic server.

This is enough about Nginx for now. Go and run the pulled code using `docker stack deploy login_app --compose-file=docker-compose.yml`.
 > You won't be able to see any output on Eductive's single page app below because port 80 and 443 are not allowed for the course use.

A simulation of production environment for the Flask app

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

Flask in Production with Nginx - Microservices

Production code explanation

Docker level

App level