Ruby on Rails Ontwikkelomgeving opzetten met Docker en Docker Compose op Ubuntu

Docker is een open-source project dat een open platform biedt voor ontwikkelaars en sysadmins om overal toepassingen te bouwen, te verpakken en te draaien als een lichtgewicht container. Docker automatiseert het inzetten van toepassingen binnen software containers.

Ruby on Rails (RoR) is een open bron webapplicatie raamwerk, gepubliceerd onder de MIT Licentie. Het is een server-side webapplicatie raamwerk dat het MVC (Model-View-Controller) concept volgt.

In deze zelfstudie laat ik je zien hoe je een ontwikkelomgeving voor Ruby on Rails toepassingen opzet met Docker en Docker compose. We zullen Ubuntu 18.04 als hosts besturingssysteem gebruiken en de PostgreSQL databank voor ons Rails project.

Wat we zullen doen:

  1. Docker en Docker Compose installeren
  2. Genereer het Rails Project
  3. Stel het Rails Project op
  4. Maak Docker Compose Script
  5. Bouw het Project
  6. Test het maken van basis CRUD op Rails

Stap 1 – Installeer Docker en Docker Compose

De eerste stap die we moeten doen is het installeren van de docker en docker compose zelf. We zullen de docker installeren uit de officiële docker repository, en de docker-compose installeren uit het officiële docker GitHub project.

Voor je de Docker pakketten installeert, voer je het onderstaande apt commando uit om de afhankelijkheden van de pakketten te installeren.

sudo apt install -y \
    apt-transport-https \
    ca-certificates \
    curl \
    software-properties-common

Voeg nu de docker sleutel en docker repository toe.

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

Het commando zal automatisch alle repositories op het systeem bijwerken. Als dat voltooid is, installeer je de docker-ce pakketten.

sudo apt install -y docker-ce

Wacht tot de docker-ce installatie klaar is, en start dan de docker service en voeg die toe aan de opstarttijd.

sudo systemctl start docker
sudo systemctl enable docker

De Docker is up and running op het systeem.

Installeer vervolgens de docker-compose door het binaire bestand direct te downloaden van de docker GitHub repository.

Download het docker-compose binaire bestand naar de ‘/usr/local/bin/’ directory en maak er een uitvoerbaar bestand van.

sudo curl -L https://github.com/docker/compose/releases/download/1.21.0/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

De docker en docker-compose zijn op het systeem geïnstalleerd, controleer de versie met onderstaande commando’s.

docker version
docker-compose version

Hieronder staat het resultaat.

Docker installeren

Stap 2 – Genereer Ruby on Rails Project

Nadat we de kernpakketten docker en docker-compose op het systeem geïnstalleerd hebben, willen we een nieuwe gebruiker aanmaken en dan het Rails project genereren met behulp van de docker images.

Voeg een gebruiker toe met de naam ‘hakase’ en geef de gebruiker een wachtwoord.

useradd -m -s /bin/bash hakase
passwd hakase

Voeg de gebruiker toe aan de ‘sudo’ en ‘docker’ groep en log in op de ‘hakase’ gebruikers-shell.

usermod -a -G sudo hakase
usermod -a -G docker hakase
su - hakase

Nu kan de ‘hakase’ gebruiker het docker commando uitvoeren en uitvoeren.

Vervolgens maken we een nieuwe directory ‘rails’ voor ons Ruby on Rails project.

Maak de ‘rails’ directory aan en ga er naar toe.

mkdir -p ~/rails
cd ~/rails/

Voer nu het onderstaande ‘docker run’ commando uit.

docker run --rm -v ${PWD}:/usr/src -w /usr/src -ti ruby:alpine sh ; cd app

Het commando zal de tijdelijke container op basis van ruby:alpine image uitvoeren, de lokale directory mounten naar de ‘/usr/src’ directory binnen de container, en dan het ‘sh’ shell commando uitvoeren en naar de ‘app’ directory gaan.

Genereer Ruby on Rails project

Installeer binnen de container de ‘build-base’ pakketten.

apk add build-base

Installeer nu de Ruby on Rails binnen de tijdelijke container.

gem install -N rails

En genereer het nieuwe Rails project met de naam ‘app’ met PostgreSQL als database, verlaat/logout dan de container.

rails new app --database=postgresql --skip-bundle
exit

En je bent nu op de Rails project directory ‘app’.

Verander nu de eigenaar van de ‘app’ projectdirectory in de ‘hakase’ gebruiker.

sudo chown -R hakase:hakase ~/rails/app/
ls -lah

En het Ruby on Rails project is gegenereerd via de tijdelijke docker container.

Rails Project

Stap 3 – Zet het Rails Project op

In deze stap maken we een nieuw Dockerfile voor onze Rails toepassingen.

Maak binnen de ‘rails’ directory een nieuwe Dockerfile met vim.

vim Dockerfile

Plak de configuratie hieronder.

FROM ruby:alpine

RUN apk update
RUN apk add build-base nodejs postgresql-dev tzdata
RUN gem install -N rails

RUN mkdir -p /app
WORKDIR /app

COPY ./app/Gemfile /app
COPY ./app/Gemfile.lock /app
RUN bundle install --binstubs

Sla op en sluit af.

We maken een nieuw docker image gebaseerd op de Ruby Alpine linux. We installeren nieuwe pakketten voor de rails installatie, maak een nieuwe /app directory, kopieer de Gemfile en Gemfile.lock uit app lokale directory, en de installeer alle pakketten op basis van de Gemfile.

Ga vervolgens naar de ‘app’ directory, maak een nieuw bestand Gemfile.lock.

cd app/
touch Gemfile.lock

Bewerk het ‘database.yml’ bestand.

vim config/database.yml

Verander de standaard database configuratie en verander de details als hieronder.

default: &default
   adapter: postgresql
   encoding: unicode
   host: db
   username: postgres
   pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
   timeout: 5000

Sla op en sluit af.

Opzetten van het Rails Project

De configuratie van het Rails project is voltooid.

Stap 4 – Maak een Docker Compose bestand

In deze stap maken we een nieuw docker-compose bestand voor onze Rails Applicatie. We zullen slechts twee diensten aanmaken db database PostgreSQL en web is de rails toepassing zelf.

Maak een nieuw bestand ‘docker-compose.yml’ binnen de ‘rails’ directory.

vim docker-compose.yml

En plak er onderstaande configuratie in.

version: '3.6'

services:

  db:
    image: postgres:alpine
    volumes:
      - ./postgresql:/var/lib/postgresql/data

  web:
    build: .
    volumes:
      - ./app:/app
    working_dir: /app
    command: bundle exec rails s -p 3000 -b '0.0.0.0'
    ports:
      - 80:3000
    depends_on:
      - db

Sla op en sluit af.

Maak Docker Compose bestand

Maak nu de ‘postgresql’ map aan binnen het ‘rails’ project.

mkdir -p ~/rails/postgresql

En we zijn klaar om ons Rails project te bouwen.

Stap 5 – Bouw het project

Bouw het Rails docker image met het onderstaande docker-compose commando.

docker-compose build

Het commando zal het Ruby Alpine Linux image downloaden en het aangepaste image bouwen zoals we nodig hebben op basis van ons Dockerfile.

Bouw het project

Genereer de PostgreSQL databank voor het project.

docker-compose run web rake db:create

Docker compose run

Breng nu de ‘db’ en ‘web’ diensten op gang.

docker-compose up -d

En rails services is up and running, controleer het met het onderstaande docker-compose commando.

docker-compose ps

Je ziet dat de dienst ‘web’ draait op poort ’80’ op de host.

Controleer nu docker images op ons systeem.

docker-compose images

En je krijgt het resultaat als hieronder.

Docker composeer images

Open nu je webbrowser en typ het IP adres of de domeinnaam van de server. De mijne is:

http://rails.hakase-labs.io/

En je krijgt er de standaard Rails pagina toepassing op.

Rails draait met succes

Nu zijn we klaar om ons Rails project te ontwikkelen.

Stap 6 – Test Maak eenvoudige CRUD op Rails

Genereer eenvoudige CRUD op rails door het rails commando uit te voeren binnen de ‘web’ container service.

docker-compose exec web rails g scaffold Post title:string body:text

Genereer nu de database.

docker-compose exec web rake db:migrate

Test maken van basis CRUD op Rails

Open nu je webbrowser en typ het IP adres van de server in de adresbalk met pad ‘/posts’. Het mijne is:

http://rails.hakase-labs.io/posts

En je krijgt de eenvoudige CRUD pagina zoals hieronder.

Test POST formulier

Typ de post en klik op de knop ‘Create Post’.

En je krijgt het resultaat als hieronder.

Rails app werkt naar behoren

De setup van de ontwikkelomgeving voor Ruby on Rails met Docker en Docker Compose is met succes voltooid.

Referentie