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. Learn 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

## Highlights

Another action-packed chapter. You have now learned the major tools in our belt for deploying apps with Docker.
Let’s review what we covered in this chapter:

1. We introduced Docker Machine and used it to create a virtualized Docker-ready instance:
   ```text
   $ docker-machine create --driver virtualbox local-vm-1
   ```

2. We logged onto the new instance using SSH:
   ```text
   $ docker-machine ssh local-vm-1
   ```
   We also issued commands against it from our local shell session:
   ```text
   $ docker-machine ssh <instance name> "<command>"
   ```

3. We saw how to configure our Docker Client to target the Docker Engine on our virtual instance:
   ```text
   $ eval $(docker-machine env local-vm-1)
   ```
   and to reset it again with:
   ```text 
   $ eval $(docker-machine env -u)
   ```

4. We turned our vanilla Docker instance into a single-node swarm cluster:
   ```text
   $ docker swarm init --advertise-addr <IP address of instance>
   ```

5. Having created a production version of our `docker-compose.yml` called `docker-stack.yml`, we deployed our application on the swarm as a stack using:
   ```text
   $ docker stack deploy -c docker-stack.yml myapp
   ```

6. We saw how to list the services in our stack with:
   ```text
   $ docker stack services myapp
   ```
   or list all services on the swarm with:
   ```text
   $ docker service ls
   ```

7. We saw how to deploy an updated version of the app:
   ```text
   $ docker stack deploy -c docker-stack.yml myapp
   ```

8. We scaled up our web service by running multiple containers, utilizing Swarm’s built-in load balancing:
   ```text
   $ docker service scale myapp_web=<n>
   ```

## What to expect in the next chapter?

Now that we have started to get a feel for Docker Machine and Swarm, and have seen how to deploy and scale our application, it is time to move onto the big leagues. In the next chapter, we will finally move off our local machine and into the big, wide world that is the cloud.

# Highlights

Another action-packed chapter. You have now learned the major tools in our belt for deploying apps with Docker.
Let’s review what we covered in this chapter:

1. We introduced Docker Machine and used it to create a virtualized Docker-ready instance:
   ```text
   $ docker-machine create --driver virtualbox local-vm-1
   ```

2. We logged onto the new instance using SSH:
   ```text
   $ docker-machine ssh local-vm-1
   ```
   We also issued commands against it from our local shell session:
   ```text
   $ docker-machine ssh <instance name> "<command>"
   ```

3. We saw how to configure our Docker Client to target the Docker Engine on our virtual instance:
   ```text
   $ eval $(docker-machine env local-vm-1)
   ```
   and to reset it again with:
   ```text 
   $ eval $(docker-machine env -u)
   ```

4. We turned our vanilla Docker instance into a single-node swarm cluster:
   ```text
   $ docker swarm init --advertise-addr <IP address of instance>
   ```

5. Having created a production version of our `docker-compose.yml` called `docker-stack.yml`, we deployed our application on the swarm as a stack using:
   ```text
   $ docker stack deploy -c docker-stack.yml myapp
   ```

6. We saw how to list the services in our stack with:
   ```text
   $ docker stack services myapp
   ```
   or list all services on the swarm with:
   ```text
   $ docker service ls
   ```

7. We saw how to deploy an updated version of the app:
   ```text
   $ docker stack deploy -c docker-stack.yml myapp
   ```

8. We scaled up our web service by running multiple containers, utilizing Swarm’s built-in load balancing:
   ```text
   $ docker service scale myapp_web=<n>
   ```

# What to expect in the next chapter?

Now that we have started to get a feel for Docker Machine and Swarm, and have seen how to deploy and scale our application, it is time to move onto the big leagues. In the next chapter, we will finally move off our local machine and into the big, wide world that is the cloud.

Let's review what we have covered in this chapter.

Quick Recap

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

Deploy a Full Stack Web Application over Kubernetes

Deploying to the Cloud

Docker for Rails Developer - Exam 3

Closing Thoughts and Next Steps

APPENDIX

Quick Recap

Highlights