AWS_ACCESS_KEY_ID

AWS_SECRET_ACCESS_KEY

AWS_DEFAULT_REGION

INTERNAL_IP

IP_PORT

SWARM_TOKEN

BUCKET

DIGITAL_OCEAN_TOKEN

Gain insights into Docker architecture, images, and containers. Delve into Docker Compose, JS integration, and production readiness. Master deploying, clustering, and scaling Rails apps using Docker tools.

tarball.tar.gz

simpleJob

simpleJob2

simpleJob-copy

viewImages

dockerCompose1

challenge1

dockerComposeRedis1

dockerComposeRedis2

dockerComposeRedis3

cdToUsercode

delGitCopyUpCreate

delGitCopyUp

delGitCopyUpMigrate

webPackerCh7

RSpec-Ch8

RSpec-Ch8_2

RSpec-Ch8_2_1

RSpec-Ch8_3

runRailsUsingCustomImage

dockerCompose1-copy

RSpec-Ch8_2-copy

delGitCopyUp-copy

RSpec-Ch8_5

RSpec-Ch8_6

RSpec-Ch8_6_GUI

dockerCompose1-copy-copy

dockerComposePostgres1

webPackerCh7-copy

postgress_last_lesson

Ch12_2

postgress_2nd_last_lesson

Ch12_3

gem_1

gem_2

irritation_1

irritation_1_1

Ch12_1

webPackerCh7_2

Cloud

Cloud_DO

Cloud_1

Cloud_2_1

Cloud_2_2

Cloud_2_4

RSpec-Ch8_2_new

RSpec-Ch8_7

Cloud_1_1_bucket

dockerComposeRedis3-copy

dockerComposeRedis2-copy

Cloud_DO_2

chap4_1

chap5_3

chap5_4

challenge

simpleJob2-ForceRelaunch

simpleJob-ForceRelaunch

RSpec-Ch8_5-copy

dockerCompose1-copy-copy-copy

testing

chap4_1-copy

chap5_3-copy

chap5_4-copy

dockerComposeRedis3-copy-iwrz0a

postgress_2nd_last_lesson-copy

postgress_last_lesson-copy

webPackerCh7_2-copy

This course is your field manual for building Rails applications with Docker. 

To kick things off, you’ll start by learning the basics of Docker like architecture, images, and containers. You will then be introduced to Docker Compose and use it to build up to a multiservice application with Redis.

You will then work to get your Dockerized setup to play nice with JavaScript, using both the standard asset pipeline and webpacker, Rails’ newest approach for integrating modern JavaScript front ends.

Lastly, you will learn how to prepare your Rails app for production. Once ready, using Docker’s own tools, you will provision machines, create a cluster, deploy the app, and scale the app’s resources to meet its changing needs.

By the end of the course, you will be able to confidently use Docker in any of your further projects.

Docker for Rails Developers

# Life cycle of containers

A common thing we will need to do while developing our application is to stop or start the various services that make it up. In a moment, we will dive into the fine-grained control Compose gives us to do this. Before we do, though, it is helpful to have in mind the journey that containers go through from creation until they are no longer needed. The following figure shows a simplified version of a container’s life cycle: 


## Created state
A container comes into existence in the **created stat**e. It does not execute any code; it merely sits around waiting until it is called for. When the container is started, it moves into the running state, where it actively executes code. The docker run command we have seen creates a new container, then starts it running. 

## Running state
In the **running state**, a container can be restarted, stopped, killed, or paused. Pausing a container suspends the running processes so that they can be resumed sometime later. Stopping a container attempts to shut it down gracefully by sending a terminate signal, `SIGTERM`, to the main process inside the container, falling back to a forceful shutdown with a kill signal `SIGKILL` if this fails. Killing a container jumps straight to forceful termination. 

## Stopped state
A container moves into the stopped state if it is stopped, killed, or if the main process running inside it terminates. The stopped state is similar to the created state: the container sits there doing nothing until it is called upon. From there, the container can either be restarted or, if you have no more use for it, removed from the system. 

# Compose and containers
With that in mind, let’s see how this works in practice using Compose.

## Listing running containers 
First of all, to list running containers, we use the `ps` command: 
```text
$ docker-compose ps 
Name Command State Ports 
--------------------------------------------------------------------- 
myapp_web_1 bin/rails s -b 0.0.0.0 Up 0.0.0.0:3000->3000/tcp 
```
The listing includes the container name, the command used to start it, its current state, and its port mappings. **Up** means that the container for our Rails server is still running. 

## Stopping Rails server
By default, the `stop` command would stop all services listed in our **docker-compose.yml** file. For example, to stop all containers in the entire application, we would run: 

```text
$ docker-compose stop 
```

## Stopping particular service
To target a particular service, we would specify the service name after the action like this: 
```text
$ docker-compose stop <service_name> 
```
This may seem like a moot point since currently, `web` is the only service we have defined. However, when more services will be added, this feature will be handy. It is common to want to target commands at a specific service, so it is very useful to remember this pattern particularly as all the `docker-compose` commands follow it. To stop the `web` service, we will use: 
```text
$ docker-compose stop web 
Stopping myapp_web_1 ... done 
```
Loading Rails app in the browser will now fail, and listing the containers will report that the Rails server has terminated: 
```text
$ docker-compose ps -a
Name Command State Ports 
----------------------------------------------------- 
myapp_web_1 bin/rails s -b 0.0.0.0 Exit 1 
```

## Starting a service
Having stopped a container, we can start it again with the start command: 
```text
$ docker-compose start web 
Starting web ... done 
```
There is also a `restart` command that comes in handy in different instances. For example, if you have made some config changes and want the Rails server to pick them up, you could use the restart command. 
```text
$ docker-compose restart web 
Restarting myapp_web_1 ... done 
```
These various Compose commands rely on underlying `docker` commands. Compose gives us all the power of the lower-level `docker` commands, but with simpler, app-centric commands.

# 🍀 Practice

Click on the Run button. After Compose will be up, try to do the following in the terminal.

1. List the running service(s).
2. Stop the `web` service.
3. List the stopped service(s).
4. Restart the `web` service.
5. Stop Compose.


We will discuss the life cycle of containers and how Compose helps in stopping and starting particular services.

Starting and stopping services

Introduction

A Brave New World

Running a Rails App in a Container

Fine-Tuning Our Rails Image

Describing Our App Declaratively with Docker Compose

Beyond the App: Adding Redis

Docker for Rails Developer—Exam 1

Adding a Database: Postgres

Playing Nice with JavaScript

Testing in a Dockerized Environment

Advanced Gem Management

Some Minor Irritations

Docker for Rails Developer—Exam 2

The Production Landscape

Preparing for Production

A Production-Like Playground

Deploying to the Cloud

Docker for Rails Developer - Exam 3

Closing Thoughts and Next Steps

APPENDIX

Starting and stopping services

Life cycle of containers