Docker containers wrap a piece of software in a complete filesystem that contains everything needed to run: code, runtime, system tools, system libraries – anything that can be installed on a server. This guarantees that the software will always run the same, regardless of its environment.

docker

Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.

Node.js

In this course we will take a simple Node.js app that connects to a MongoDB database and uses an Express web server, and learn how to setup a full software development deployment process as well as how to properly “Dockerize” the app. 

We’ll step through setting up proper version control techniques, managing configuring within the environment, setting up proper build/deploy/run processes, and all with abiding by Docker best practices. We’ll also make sure our deployment is setup for scale, and have consistent development practices in place for reliable app deployments.

Kamil Khadeyev

The twelve-factor app is a development and deployment methodology for building apps with present-day concepts. Following it will ensure your app can be deployed easily and scaled effortlessly.

The website 12factor.net explains the concepts of the twelve-factor app. The lessons in this course each directly relate to one of the 12 factors and are presented in order. The first few go over revision control and managing the config and dependencies of your Node.js app, while the rest explain the devops of your app with Nginx & Docker, with concepts closely aligned to the 12-factor app.

egghead

Summary & Concepts of the Twelve-Factor App

npm shrinkwrap > npm install > npm shrinkwrap is not guaranteed to produce the same output as just shrinkwrapping once, whereas Yarn explicitly uses "an install algorithm that is deterministic and reliable". We’ll learn how to generate a `yarn.lock` file and commit it to version control to ensure a deterministic and reliable module install process.

Pin Down NPM Package Versions with Yarn.lock

A reliable version control and source code tracking process is important for delivering apps with consistency and reliability. In this lesson, we will learn aspects of the Git Flow branching model which provide standards for developing and deploying apps with Git. We will walk through the methodologies of this well-known branching model, how to work with it from develop through to staging environments, and versioning your source code properly for production.

Use Git Flow as a Reliable Version Control Model

Storing configuration in files instead of the environment has many downsides, including mistakenly checking in the wrong configuration in the wrong environment, coupling configuration with code, and scaling issues in larger server architectures. 

We’ll learn how to update app code to look at environment variables for configuration values instead of using configuration files, and different approaches for managing environment variables between dev/stage/prod.

node

Manage Configuration Values with Environment Variables

High availability apps require that no distinction be made between local and remote services. Attached resources should be accessed by environment variables, and in doing so allow you to swap out one attached resource for another. 

In this lesson we will setup a reverse proxy that directs image path requests and routes them through a defined server URL. By doing so, we decouple server requests for images which allows for easy switching from locally-served image assets to a CDN by simply updating an environment variable.

express

Proxy Requests for Local and Remote Service Parity

In this lesson we will cover proper version tagging when building Docker images, creating a docker-compose.yml file for proper release management, and running the tagged release by using Docker Compose to launch app resources as Docker containers.

Build, Release and Run Containers with Docker Compose

Docker containers should be designed to be stateless, meaning that they can survive system reboots and container terminations gracefully, and without the loss of data. Designing with stateless containers in mind will also help your app grow and make future horizontal scaling trivial. 

In this lesson, we will review an app that saves uploaded files to the filesystem. Then we will learn how to setup a persistent volume for the uploaded files so they can survive Docker container halts, restarts, stops and respawns.

Run Stateless Docker Containers

By default, Docker is locked down and no ports are exposed. We’ll cover how to expose ports when building your image with a `Dockerfile`, and how to export that port as a service when running containers. 

Export Services with Docker Port Binding

Node.js apps built with Docker cannot scale horizontally by themselves. In this lesson we will spawn out multiple Node.js processes/containers, and move the incoming request handler to an Nginx proxy to load balance and properly scale our Node.js app.

Scale Docker Horizontally with Nginx Load Balancing

A properly scaled Docker architecture should be able to kill off random containers at any time, and continue to run by implementing a crash-only design methodology. We will learn how to setup our architecture to auto-spawn new Docker containers when other containers are deemed unhealthy or in a terminated state. We will also learn how to scale containers easily with Compose in the event we need to quickly scale horizontally.

Ensure Containers Run with High-Availability

Docker makes it easy to have near-full environment parity between dev, stage and prod. In this lesson we’ll go over a typical setup within Docker Compose, and how to manage backing services between dev, stage and prod.

Run Consistent Dev, Stage & Prod Docker Environments

Since Docker filesystems are ephemeral, it's important to take into account anything that writes or appends to disk, such as log files. It is standard practice when running Docker containers to pipe log file output to the console, to allow for simple diagnostic and to avoid append-only files from consuming disk space. 

In this lesson, we’ll show you how to append output to `STDOUT`, and how to view log output from your running containers.

Pipe Log Output to STDOUT with Docker

You’ll often need to execute various administrative or maintenance tasks for your app, such as database migrations or arbitrary console commands. 

In this lesson, we will learn how to run arbitrary one-off commands as disposable Docker containers.

Build a Twelve-Factor Node.js App with Docker

Mark Shust

Credits

Course Content