Docker è un progetto open source che fornisce una piattaforma aperta a sviluppatori e amministratori di sistema per creare, impacchettare ed eseguire applicazioni ovunque come un contenitore leggero. Docker automatizza la distribuzione delle applicazioni all'interno di contenitori software.
Ruby on Rails (RoR) è un framework di applicazioni web open source, pubblicato con licenza MIT. È un framework di applicazioni Web lato server che segue il concetto MVC (Model-View-Controller).
In questo tutorial, ti mostrerò come configurare un ambiente di sviluppo per le applicazioni Ruby on Rails utilizzando Docker e Docker Compose. Utilizzeremo Ubuntu 18.04 come sistema operativo host e utilizzeremo il database PostgreSQL per il nostro progetto Rails.
Cosa faremo:
- Installa Docker e Docker Compose
- Genera il progetto Rails
- Imposta il progetto Rails
- Crea script di composizione Docker
- Costruisci il progetto
- Test Crea CRUD di base su binari
Passaggio 1:installazione di Docker e Docker Compose
Il primo passo che dobbiamo fare è installare la finestra mobile e la finestra mobile si compone da sola. Installeremo il docker dal repository docker ufficiale e installeremo docker-compose dal progetto GitHub docker ufficiale.
Prima di installare i pacchetti Docker, esegui il comando apt di seguito per installare le dipendenze dei pacchetti.
sudo apt install -y \
apt-transport-https \
ca-certificates \
curl \
software-properties-common
Ora aggiungi la chiave mobile e il repository della finestra mobile.
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"
Il comando aggiornerà automaticamente tutti i repository sul sistema. Al termine, installa i pacchetti docker-ce.
sudo apt install -y docker-ce
Attendi l'installazione docker-ce, quindi avvia il servizio docker e aggiungilo all'ora di avvio.
sudo systemctl start docker
sudo systemctl enable docker
Docker è attivo e funzionante sul sistema.
Quindi, installa il docker-compose scaricando il file binario direttamente dal repository GitHub docker.
Scarica il file binario di composizione mobile nella directory '/usr/local/bin/' e rendilo eseguibile.
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
La finestra mobile e la composizione mobile sono state installate sul sistema, controlla la versione usando i comandi seguenti.
docker version
docker-compose version
Di seguito il risultato.
Fase 2 - Genera progetto Ruby on Rails
Dopo aver installato i pacchetti principali docker e docker-compose sul sistema, vogliamo creare un nuovo utente e quindi generare il progetto Rails utilizzando le immagini docker.
Aggiungi un utente chiamato 'hakase' e fornisci all'utente una password.
useradd -m -s /bin/bash hakase
passwd hakase
Aggiungi l'utente al gruppo 'sudo' e 'docker' e accedi alla shell utente 'hakase'.
usermod -a -G sudo hakase
usermod -a -G docker hakase
su - hakase
Ora l'utente 'hakase' può eseguire ed eseguire il comando docker.
Successivamente, creeremo una nuova directory 'rails' per il nostro progetto Ruby on Rails.
Crea la directory 'rails' e vai ad essa.
mkdir -p ~/rails
cd ~/rails/
Ora esegui il comando 'docker run' di seguito.
docker run --rm -v ${PWD}:/usr/src -w /usr/src -ti ruby:alpine sh ; cd app Il comando eseguirà il contenitore temporaneo basato sull'immagine ruby:alpine, monterà la directory locale nella directory '/usr/src' all'interno del contenitore, quindi eseguirà il comando shell 'sh' e andrà alla directory 'app'.
All'interno del container, installa i pacchetti 'build-base'.
apk add build-base
Ora installa Ruby on Rails all'interno del contenitore temporaneo.
gem install -N rails
E genera il nuovo progetto Rails denominato 'app' con PostgreSQL come database, quindi esci/disconnetti dal contenitore.
rails new app --database=postgresql --skip-bundle
exit
E sarai nella directory del progetto Rails 'app'.
Ora cambia il proprietario della directory del progetto "app" con l'utente "hakase".
sudo chown -R hakase:hakase ~/rails/app/
ls -lah
E il progetto Ruby on Rails è stato generato tramite il container Docker temporaneo.
Fase 3:imposta il progetto Rails
In questo passaggio creeremo un nuovo Dockerfile per le nostre applicazioni Rails.
All'interno della directory 'rails', crea un nuovo Dockerfile usando vim.
vim Dockerfile
Incolla la configurazione di seguito.
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
Salva ed esci.
Stiamo creando una nuova immagine Docker basata su Linux Ruby Alpine. Stiamo installando nuovi pacchetti per l'installazione dei binari, creiamo una nuova directory /app, copiamo Gemfile e Gemfile.lock dalla directory locale dell'app e installiamo tutti i pacchetti basati su Gemfile.
Quindi, vai alla directory 'app', crea un nuovo file Gemfile.lock.
cd app/
touch Gemfile.lock
Modifica il file 'database.yml'.
vim config/database.yml
Modifica la configurazione predefinita del database e modifica i dettagli come di seguito.
default: &default
adapter: postgresql
encoding: unicode
host: db
username: postgres
pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
timeout: 5000 Salva ed esci.
La configurazione del progetto Rails è stata completata.
Passaggio 4:crea un file di composizione Docker
In questo passaggio, creeremo un nuovo file di composizione mobile per la nostra applicazione Rails. Creeremo solo due servizi database db PostgreSQL e web è l'applicazione rails stessa.
Crea un nuovo file 'docker-compose.yml' all'interno della directory 'rails'.
vim docker-compose.yml
E incolla la configurazione di seguito.
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 Salva ed esci.
Ora crea la directory 'postgresql' all'interno del progetto 'rails'.
mkdir -p ~/rails/postgresql
E siamo pronti per realizzare il nostro progetto Rails.
Fase 5:crea il progetto
Costruisci l'immagine della finestra mobile Rails usando il comando docker-compose di seguito.
docker-compose build
Il comando scaricherà l'immagine Ruby Alpine Linux e creerà l'immagine personalizzata di cui abbiamo bisogno in base al nostro Dockerfile.
Genera il database PostgreSQL per il progetto.
docker-compose run web rake db:create
Ora attiva i servizi 'db' e 'web'.
docker-compose up -d
E i servizi ferroviari sono attivi e funzionanti, controllalo utilizzando il comando docker-compose di seguito.
docker-compose ps
Puoi vedere che il servizio "web" è in esecuzione sulla porta "80" dell'host.
Ora controlla le immagini della finestra mobile sul nostro sistema.
docker-compose images
E otterrai il risultato come di seguito.
Ora apri il tuo browser web e digita l'indirizzo IP del server o il nome di dominio. Il mio è:
http://rails.hakase-labs.io/
E otterrai l'applicazione predefinita della pagina Rails.
Ora siamo pronti per sviluppare il nostro progetto Rails.
Fase 6:prova a creare CRUD di base su binari
Genera semplice CRUD on rails eseguendo il comando rails all'interno del servizio container 'web'.
docker-compose exec web rails g scaffold Post title:string body:text
Ora genera il database.
docker-compose exec web rake db:migrate
Ora apri il tuo browser web e digita l'indirizzo IP del server sulla barra degli indirizzi con il percorso '/posts'. Il mio è:
http://rails.hakase-labs.io/posts
E otterrai la semplice pagina CRUD come di seguito.
Digita il post e fai clic sul pulsante "Crea post".
E otterrai il risultato come di seguito.
La configurazione dell'ambiente di sviluppo per Ruby on Rails con Docker e Docker Compose è stata completata con successo.