How to dockerize rails application compose and rails tutorial
0 likes63 views
This document provides a step-by-step tutorial on how to dockerize a Rails application using Docker Compose, starting from setting up the Rails app to configuring the Dockerfile and docker-compose.yml files. It includes commands for creating the database, running the application, and managing the application's dependencies. The tutorial aims to enhance the portability, modularity, and scalability of Rails applications.
How to dockerize rails application compose and rails tutorial
- 1. HOW TO DOCKERIZE RAILS APPLICATION : COMPOSE AND RAILS TUTORIAL https://www.bacancytechnology.com/
- 2. Introduction
- 3. A curious developer and tech enthusiast never miss an opportunity to learn a little more every day! I can absolutely relate to this urge to learn. So, keeping your curiosity in mind, we are back with another Rails tutorial on how to dockerize rails applications with the help of Docker Compose. Hoping that you are familiar with what is Docker and why do we need Docker. Let’s get started with the app development and dockerizing it.
- 5. Fire the following commands to create a rails app. mkdir ~/projects/noteapp cd ~/projects/noteapp
- 7. Install Docker Community Edition Install Docker Compose As we are implementing Docker Compose, make sure about the following installations before getting started.
- 9. The Dockerfile is the foundation of any Dockerized app. It contains all the instructions for building the application image. You can set this up by installing Ruby and all of its dependencies. The Dockerfile consists of the following instructions.
- 10. FROM ruby:2.3.0 RUN apt-get update -qq && apt-get install -y build-essential libpq-dev nodejs RUN mkdir /noteapp WORKDIR /noteapp ADD Gemfile /noteapp/Gemfile ADD Gemfile.lock /noteapp/Gemfile.lock RUN bundle install ADD . /noteapp // Dockerfile
- 11. Dockerfile will keep the app code inside an image, building a container with Bundler, Ruby, and other dependencies. Therefore in the root directory of the application, create a new Dockerfile using the command touch Dockerfile and put the content of the above dockerfile inside it. Explanation FROM ruby:2.3.0: Tells Docker to use the prebuilt Ruby image. There are several choices, but this project uses the ruby:2.3.0 image. RUN: To run commands. Here, RUN is for installing different software pieces with Apt. WORKDIR: For stating the base directory from where all the commands are executed. ADD: For copying files from the host machine to our container.
- 12. Create a Gemfile
- 13. Next, open the editor and create a bootstrap Gemfile that loads Rails. source 'https://rubygems.org' gem 'rails', '~>5.0.0' Create an empty Gemfile.lock file to build our Dockerfile. touch Gemfile.lock // gemfile
- 14. Dockerize Rails App: Add Portability, Modularity, and Scalability to your app Contact Bacancy and hire Rails developer to dockerize your rails application.
- 16. Finally, moving towards the most important section. The docker-compose.yml file will consist of services needed for your app (web application and DB), for getting each other’s Docker image, and the config for connecting them and making it visible on the port.
- 17. version: '2' services: db: image: mysql:5.7 restart: always environment: MYSQL_ROOT_PASSWORD: password MYSQL_DATABASE: noteapp MYSQL_USER: appuser MYSQL_PASSWORD: password // docker-compose.yml
- 18. ports: - "3307:3306" app: build: . command: bundle exec rails s -p 3000 -b '0.0.0.0' volumes: - ".:/noteapp" ports: - "3001:3000" depends_on - db links: - db
- 20. Now build the skeleton of the rails application with the help of docker- compose run. docker-compose run app rails new . --force --database=mysql compose– builds the image for the app service, which we have to define inside our docker-compose.yml runs rails new – using that image it runs the app inside a new container database=mysql– to define the database Your application should be created after the command is successfully executed. List the files using ls -l
- 22. In this section, we will connect the database as rails wants a database to be running on the localhost. We will also alter the database and username for aligning it with the defaults by the MySQL image. When we run the docker-compose command first, it will create a DB container that downloads the MySQL database image and creates a DB based on the environment variables set in the docker-compose.yml file. By now, we have a database container, and app structure created. We need to edit the config/database.yml file and set the configurations from the environment variables. Replace the contents of config/database.yml with the following:
- 23. version: '2' services: db: image: mysql:5.7 restart: always environment: MYSQL_ROOT_PASSWORD: password MYSQL_DATABASE: noteapp MYSQL_USER: appuser MYSQL_PASSWORD: password ports: - "3307:3306" app: build: . command: bundle exec rails s -p 3000 -b '0.0.0.0' // docker-compose.yml
- 24. volumes: - ".:/noteapp" ports: - "3001:3000" depends_on: - db links: - db environment : DB_USER: root DB_NAME: noteapp DB_PASSWORD: password DB_HOST: db After setting up the docker-compose.yml, run the docker-compose build command to build an image for the app and install all the required gems.
- 25. Run the below command for database creation. docker-compose run --rm app rake db:migrate Before creating any migrations/models, let’s do a docker-compose up to start both app and database services and boot the application after making the changes in database.yml. We can see that rails is running on port 3000 in the container after the command is successfully executed. But, that’s not the port on the host, so we won’t be able to access it on the browser. As per docker- compose, we have exposed the port on the localhost from 3000 to 3001; therefore, it should be available on localhost:3001.
- 26. Once you are done with the app running on the browser, create a model and perform the migration using these commands in a different console of the project directory. docker-compose run --rm app rails g scaffold note title body:text docker-compose run --rm app rake db:migrate Now, we can access the application on port 3001- localhost:3001/notes and perform actions on the application.
- 28. mkdir ~/projects/noteapp cd ~/projects/noteapp Create Gemfile and empty Gemfile.lock (content is given above) Create Dockerfile (content is given above) Create docker-compose.yml (content is given above) docker-compose run app rails new . – force –database=mysql Make changes in config/database.yml docker-compose build docker-compose up http://localhost:3001 docker-compose run –rm app rails g scaffold note title body:text docker-compose run –rm app rake db:migrate http://localhost:3001/notes Watch the video tutorial on how to dockerize rails application as well.
- 29. Source Code: dockerize- rails-app You can also clone the code and go through the project. Here’s the source code of the repository: dockerize-rails-app Commands: Stop, Restart, and Rebuild the Application To stop the application docker-compose down
- 30. To restart the application docker-compose up To rebuild the application Rebuilding the application is a must when you’re trying different configs and altering the Gemfile or Compose file. ➡Sometimes only docker-compose up – build is enough. ➡But, if you want to rebuild the entire app fully, then use docker-compose run app bundle install, followed by docker-compose up –build for synchronizing changes between the Gemfile.lock and the host.
- 31. Conclusion
- 32. That’s it for the tutorial: how to dockerize rails application using Docker compose. I hope the tutorial was helpful to you for building your own demo app and exploring more. Visit the Ruby on Rails tutorials page for similar tutorials, where you can explore your interests and play around with the code. Looking for skilled rails developers who can help you meet your project requirements? Contact us and hire Rails developer.