Nouveau : En savoir plus sur les réseaux privés sur Scalingo

Documentation

Contacter

Connexion

Select Language

Nouveau : En savoir plus sur les réseaux privés sur Scalingo

Réserver une démo

Commencer gratuitement

Réserver une démo

Commencer gratuitement

Blog

Insights

Tutoriel : Utiliser Docker et Docker Compose pour le développement Ruby on Rails

Chargement...

30 avril

2021

4 min de lecture

Insights

Tutoriels

Ingénierie

Tutoriel : Utiliser Docker et Docker Compose pour le développement Ruby on Rails

Utiliser Docker et Docker Compose pour le développement local présente de nombreux avantages. Dans ce tutoriel, nous verrons comment configurer ces outils pour le développement Ruby on Rails.

Dans ce tutoriel, nous allons voir comment configurer Docker et Docker Compose pour le développement local de Ruby on Rails.

TL;DR : si vous ne voulez pas lire toute l'histoire, nous avons créé plusieurs gists pour vous. Il vous suffit de suivre les instructions dans leur README :

Ce tutoriel ne couvrira pas comment installer Docker sur votre ordinateur. Vous pouvez vous référer à la documentation officielle de Docker.

Objectif

Nous voulons avoir un environnement de développement Ruby on Rails standard et homogène, isolé de tous nos autres projets de développement.

Cet environnement de développement doit également inclure webpack-dev-server en tant qu'environnement de test.

Il doit être possible de l'étendre avec une base de données.

Nous voulons exécuter notre code source Ruby on Rails local à l'intérieur d'un conteneur Docker, quelle que soit la version de Ruby ou de Rails.

Nous voulons une configuration Docker Compose pour exécuter notre conteneur d'application, webpack-dev-server, notre suite de tests et les bases de données.

Avantages

Il y a de nombreux avantages à utiliser Docker et Docker Compose pour la configuration d'un environnement de développement local.

Pour chacun de nos projets, nous pouvons spécifier d'une manière très simple :

une version exacte de Ruby
une version exacte de Rails
une version exacte du moteur de base de données

De plus, chacun de nos projets sera complètement isolé :

changer une version mineure ou majeure du langage, du framework, des bibliothèques ou du moteur de base de données ne perturbera pas nos autres projets de développement
nous pouvons avoir des dépendances logicielles spécifiques liées à un projet particulier à l'intérieur d'un conteneur sans conséquences sur nos autres projets

Et parce que nous pouvons spécifier clairement chaque version de notre pile, nous serons plus proches de la parité dev/prod.

Enfin, nous pouvons complètement rationaliser la configuration de l'environnement de développement local : il est plus facile d'intégrer de nouveaux développeurs dans nos projets ou simplement de revenir à des projets que nous n'avons pas touchés depuis des mois ou des années.

Étape 0 : Création de la structure des fichiers {#step-0}

D'abord, nous créons le répertoire qui accueillera notre code source et créons trois fichiers vides Dockerfile, docker-compose.yml et entrypoint.sh.

mkdir my-new-app
cd my-new-app
touch Dockerfile
touch docker-compose.yml
touch

mkdir my-new-app
cd my-new-app
touch Dockerfile
touch docker-compose.yml
touch

mkdir my-new-app
cd my-new-app
touch Dockerfile
touch docker-compose.yml
touch

mkdir my-new-app
cd my-new-app
touch Dockerfile
touch docker-compose.yml
touch

Le Dockerfile est là pour instruire Docker sur la façon de construire un conteneur à partir de notre code source et le docker-compose.yml est là pour indiquer comment exécuter plusieurs conteneurs, y compris notre conteneur d'application. Nous aborderons le fichier entrypoint.sh plus tard.

Étape 1 : Copier Dockerfile {#step-1}

Il existe de nombreuses possibilités pour créer une image de conteneur Docker. La manière la plus simple et la plus flexible est d'écrire un Dockerfile.

Un Dockerfile est un fichier texte très simple qui décrit les différentes étapes à suivre pour construire une image Docker.

Chaque ligne du Dockerfile est une étape de la recette commençant par un mot clé spécial appelé commande.

Dans notre Dockerfile, nous allons utiliser seulement 6 commandes :

FROM : spécifier une image Docker externe que nous allons utiliser comme couche de base
RUN : exécuter une commande dans le cadre de notre conteneur
ENV : construire une variable d'environnement
WORKDIR : spécifier le répertoire de base dont dépendent toutes les autres commandes
COPY : copiera un fichier de notre système de fichiers local dans le conteneur
ENTRYPOINT : indiquera comment démarrer notre conteneur Docker

Voici le Dockerfile que nous allons utiliser pour tous nos projets Ruby on Rails. N'ayez pas peur, nous ferons une analyse ligne par ligne ci-dessous !

FROM ruby:3.0.1

ARG USER_ID
ARG GROUP_ID

RUN addgroup --gid $GROUP_ID user
RUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID user

RUN apt-get update -qq

ENV GEM_HOME="/usr/src/app/bundle"
ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

RUN apt-get update -qq

# Install NodeJS
RUN apt-get install -y nodejs

# Install yarn
RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update -qq
RUN apt-get install -y yarn

WORKDIR /usr/src/app

# Add a script to be executed every time the container starts.
COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh

USER $USER_ID

ENTRYPOINT ["entrypoint.sh"

FROM ruby:3.0.1

ARG USER_ID
ARG GROUP_ID

RUN addgroup --gid $GROUP_ID user
RUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID user

RUN apt-get update -qq

ENV GEM_HOME="/usr/src/app/bundle"
ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

RUN apt-get update -qq

# Install NodeJS
RUN apt-get install -y nodejs

# Install yarn
RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update -qq
RUN apt-get install -y yarn

WORKDIR /usr/src/app

# Add a script to be executed every time the container starts.
COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh

USER $USER_ID

ENTRYPOINT ["entrypoint.sh"

FROM ruby:3.0.1

ARG USER_ID
ARG GROUP_ID

RUN addgroup --gid $GROUP_ID user
RUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID user

RUN apt-get update -qq

ENV GEM_HOME="/usr/src/app/bundle"
ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

RUN apt-get update -qq

# Install NodeJS
RUN apt-get install -y nodejs

# Install yarn
RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update -qq
RUN apt-get install -y yarn

WORKDIR /usr/src/app

# Add a script to be executed every time the container starts.
COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh

USER $USER_ID

ENTRYPOINT ["entrypoint.sh"

FROM ruby:3.0.1

ARG USER_ID
ARG GROUP_ID

RUN addgroup --gid $GROUP_ID user
RUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID user

RUN apt-get update -qq

ENV GEM_HOME="/usr/src/app/bundle"
ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

RUN apt-get update -qq

# Install NodeJS
RUN apt-get install -y nodejs

# Install yarn
RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update -qq
RUN apt-get install -y yarn

WORKDIR /usr/src/app

# Add a script to be executed every time the container starts.
COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh

USER $USER_ID

ENTRYPOINT ["entrypoint.sh"

Analyse de notre Dockerfile

Nous allons prendre l'image Docker Ruby officielle. Comme nous voulons utiliser Ruby 3.0.1, nous allons baser notre image Docker sur la version Docker 3.0.1. La balise de version de l'image Docker est la même que la version du langage Ruby.

FROM ruby:

FROM ruby:

FROM ruby:

FROM ruby:

Comme notre objectif est d'installer des gems, nous allons indiquer à notre conteneur Docker où stocker le code source de nos gems. Le GEM_HOME va indiquer à bundle où stocker les gems. Ici, nous souhaitons que le code source des gems soit installé dans le répertoire bundle. Nous verrons ci-dessous où ce répertoire bundle sera réellement stocké sur notre système de fichiers local.

ENV GEM_HOME="/usr/src/app/bundle"

ENV GEM_HOME="/usr/src/app/bundle"

ENV GEM_HOME="/usr/src/app/bundle"

ENV GEM_HOME="/usr/src/app/bundle"

Et bien sûr, nous voulons que les binstubs des gems soient disponibles dans le chemin standard à l'intérieur de notre conteneur :

ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

Les images Docker Ruby officielles sont basées sur Ubuntu. Nous pouvons utiliser les outils standard d'Ubuntu. Tout d'abord, nous aimerions mettre à jour la base de données d'informations sur les paquets. L'option -qq est là pour afficher uniquement les messages d'erreur.

RUN apt-get update

RUN apt-get update

RUN apt-get update

RUN apt-get update

Comme Rails a besoin que node soit installé, nous pouvons l'installer avec le paquet Ubuntu correspondant.

RUN apt-get install -y nodejs

RUN apt-get install -y nodejs

RUN apt-get install -y nodejs

RUN apt-get install -y nodejs

Les versions récentes de Rails installent le gem webpacker qui nécessite que yarn soit installé. Voici une méthode pour installer yarn depuis le dépôt officiel Debian/Ubuntu fourni par yarn.

RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update
RUN apt-get install -y

RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update
RUN apt-get install -y

RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update
RUN apt-get install -y

RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update
RUN apt-get install -y

Nous voulons spécifier que notre répertoire de travail de base sera /usr/src/app.

Enfin, nous ajoutons un script à exécuter chaque fois que le conteneur démarre.

COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh
ENTRYPOINT ["entrypoint.sh"

COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh
ENTRYPOINT ["entrypoint.sh"

COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh
ENTRYPOINT ["entrypoint.sh"

COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh
ENTRYPOINT ["entrypoint.sh"

Étape 2 : Copier docker-compose.yml {#step-2}

Docker Compose est un outil pour exécuter plusieurs conteneurs Docker en parallèle.

Un simple fichier texte au format YAML appelé docker-compose.yml est nécessaire pour indiquer à Docker Compose comment exécuter plusieurs conteneurs Docker appelés services.

Voici le fichier docker-compose.yml que nous allons utiliser. Nous allons commencer par une configuration très simple.

version: "2"
services:
  web:
    build: .
    ports:
      - 3000:3000
    volumes:
      - ./:/usr/src/app
    command

version: "2"
services:
  web:
    build: .
    ports:
      - 3000:3000
    volumes:
      - ./:/usr/src/app
    command

version: "2"
services:
  web:
    build: .
    ports:
      - 3000:3000
    volumes:
      - ./:/usr/src/app
    command

version: "2"
services:
  web:
    build: .
    ports:
      - 3000:3000
    volumes:
      - ./:/usr/src/app
    command

Analyse de notre docker-compose.yml

À faire

Étape 3 : Copier entrypoint.sh {#step-3}

À faire

Étape 4 : Initialiser notre nouvelle application Rails {#step-4}

Maintenant que nous avons configuré notre Docker, en utilisant la version exacte de Ruby dont nous avons besoin pour ce projet, il est temps de les exécuter !

Tout d'abord, nous aimerions exécuter une commande bash à l'intérieur de notre conteneur d'application pour installer Ruby on Rails.

docker-compose run web bash

docker-compose run web bash

docker-compose run web bash

docker-compose run web bash

Nous exécutons maintenant un terminal bash à l'intérieur de notre conteneur d'application en cours d'exécution.

Nous pouvons maintenant procéder à l'installation de Rails.

Le gem et toutes ses dépendances seront installés dans notre répertoire bundle local.

Une fois terminé, nous pouvons créer la structure de notre application :

Chaque fois que vous devez sortir d'un conteneur Docker en cours d'exécution, vous pouvez taper exit puis appuyer sur ENTER ou taper CTRL+D.

Lancer la commande docker-compose run web command est notre solution de prédilection pour exécuter toute commande dans notre conteneur en cours d'exécution. Vous pouvez l'utiliser pour exécuter un terminal bash comme décrit ci-dessus, exécuter une commande bundle comme docker-compose run web bundle install devise ou une commande yarn comme docker-compose run web yarn install @hotwired/turbo-rails.

Étape 5 : Démarrer notre pile locale {#step-5}

Vous pouvez lancer docker-compose up et visiter http//localhost:3000 dans votre navigateur.

Lancer la commande docker-compose up est notre solution de prédilection pour démarrer tout projet Rails utilisant la configuration Docker et Docker Compose utilisée dans ce tutoriel.

Voilà, nous avons maintenant un environnement de développement Rails local fonctionnel utilisant Docker !

Étape 6 : Configurer webpack-dev-server {#step-6}

Les versions récentes de Rails nécessitent webpack. La compilation des actifs en direct se fait avec un démon appelé webpack-dev-server.

Nous allons l'ajouter en tant que nouveau service dans notre fichier docker-compose.yml qui ressemblera à ce qui suit :

version: "2"
services:
  web:
    build: .
    ports:
      - 3000:3000
    volumes:
      - ./:/usr/src/app
    links:
      - webpack      
    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development
  webpack:
    build: .
    ports:
      - 3035:3035
    volumes:
      - ./:/usr/src/app
    command: ./bin/webpack-dev-server
    environment:
      WEBPACK_HOST: "172.17.0.1:3035"

version: "2"
services:
  web:
    build: .
    ports:
      - 3000:3000
    volumes:
      - ./:/usr/src/app
    links:
      - webpack      
    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development
  webpack:
    build: .
    ports:
      - 3035:3035
    volumes:
      - ./:/usr/src/app
    command: ./bin/webpack-dev-server
    environment:
      WEBPACK_HOST: "172.17.0.1:3035"

version: "2"
services:
  web:
    build: .
    ports:
      - 3000:3000
    volumes:
      - ./:/usr/src/app
    links:
      - webpack      
    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development
  webpack:
    build: .
    ports:
      - 3035:3035
    volumes:
      - ./:/usr/src/app
    command: ./bin/webpack-dev-server
    environment:
      WEBPACK_HOST: "172.17.0.1:3035"

version: "2"
services:
  web:
    build: .
    ports:
      - 3000:3000
    volumes:
      - ./:/usr/src/app
    links:
      - webpack      
    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development
  webpack:
    build: .
    ports:
      - 3035:3035
    volumes:
      - ./:/usr/src/app
    command: ./bin/webpack-dev-server
    environment:
      WEBPACK_HOST: "172.17.0.1:3035"

De plus, comme webpack-dev-server s'exécutera dans un conteneur séparé de notre conteneur d'application normal, nous devrons le lier à 0.0.0.0 ce qui signifie sur toutes les interfaces réseau. De cette façon, il sera accessible de l'extérieur de son conteneur.

Dans config/webpacker.yml, remplacez la clé development/dev_server/host par la valeur 0.0.0.0 (localhost est la valeur par défaut et nous ne la voulons pas).

Maintenant, stoppez la pile, reconstruisez-la et relancez-la.

Nous avons maintenant une flotte de 2 conteneurs en cours d'exécution : un conteneur exécutant notre code source Rails et un conteneur exécutant webpack-dev-server.

Étape 7 : Ajouter une base de données PostgreSQL à notre pile locale {#step-7-alt1}

FROM ruby:3.0.1

RUN apt-get update

ENV GEM_HOME="/usr/src/app/bundle"
ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

RUN apt-get update -qq

RUN apt-get install -y postgresql-client

# Install NodeJS
# If you don't neet any specific NodeJS version use the Ubuntu package
RUN apt-get install -y nodejs
# If you'd like to install a specific NodeJS version, comment the line above and
# uncomment the lines below
# RUN apt-get install apt-transport-https
# ENV NODE_VERSION 14.16.1
# RUN cd /opt && \
#     curl -L "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" | tar -xJf - && \
#     mv -v node-v$NODE_VERSION-linux-x64 node
# ENV PATH /node_modules/.bin:/opt/node/bin:$PATH

# Install yarn
RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update -qq
RUN apt-get install -y yarn

WORKDIR /usr/src/app

# Add a script to be executed every time the container starts.
COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh
ENTRYPOINT ["entrypoint.sh"

FROM ruby:3.0.1

RUN apt-get update

ENV GEM_HOME="/usr/src/app/bundle"
ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

RUN apt-get update -qq

RUN apt-get install -y postgresql-client

# Install NodeJS
# If you don't neet any specific NodeJS version use the Ubuntu package
RUN apt-get install -y nodejs
# If you'd like to install a specific NodeJS version, comment the line above and
# uncomment the lines below
# RUN apt-get install apt-transport-https
# ENV NODE_VERSION 14.16.1
# RUN cd /opt && \
#     curl -L "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" | tar -xJf - && \
#     mv -v node-v$NODE_VERSION-linux-x64 node
# ENV PATH /node_modules/.bin:/opt/node/bin:$PATH

# Install yarn
RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update -qq
RUN apt-get install -y yarn

WORKDIR /usr/src/app

# Add a script to be executed every time the container starts.
COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh
ENTRYPOINT ["entrypoint.sh"

FROM ruby:3.0.1

RUN apt-get update

ENV GEM_HOME="/usr/src/app/bundle"
ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

RUN apt-get update -qq

RUN apt-get install -y postgresql-client

# Install NodeJS
# If you don't neet any specific NodeJS version use the Ubuntu package
RUN apt-get install -y nodejs
# If you'd like to install a specific NodeJS version, comment the line above and
# uncomment the lines below
# RUN apt-get install apt-transport-https
# ENV NODE_VERSION 14.16.1
# RUN cd /opt && \
#     curl -L "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" | tar -xJf - && \
#     mv -v node-v$NODE_VERSION-linux-x64 node
# ENV PATH /node_modules/.bin:/opt/node/bin:$PATH

# Install yarn
RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update -qq
RUN apt-get install -y yarn

WORKDIR /usr/src/app

# Add a script to be executed every time the container starts.
COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh
ENTRYPOINT ["entrypoint.sh"

FROM ruby:3.0.1

RUN apt-get update

ENV GEM_HOME="/usr/src/app/bundle"
ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATH

RUN apt-get update -qq

RUN apt-get install -y postgresql-client

# Install NodeJS
# If you don't neet any specific NodeJS version use the Ubuntu package
RUN apt-get install -y nodejs
# If you'd like to install a specific NodeJS version, comment the line above and
# uncomment the lines below
# RUN apt-get install apt-transport-https
# ENV NODE_VERSION 14.16.1
# RUN cd /opt && \
#     curl -L "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" | tar -xJf - && \
#     mv -v node-v$NODE_VERSION-linux-x64 node
# ENV PATH /node_modules/.bin:/opt/node/bin:$PATH

# Install yarn
RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update -qq
RUN apt-get install -y yarn

WORKDIR /usr/src/app

# Add a script to be executed every time the container starts.
COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh
ENTRYPOINT ["entrypoint.sh"

La première chose à faire sera d'ajouter une nouvelle entrée dans la section services de notre fichier docker-compose.yml qui ressemblera désormais à ce qui suit :

version: "2"
services:
  web:
    build: .
    volumes:
      - .:/usr/src/app:rw
    environment:
      DATABASE_URL: postgresql://admin:admin-secret@postgresql:5432/my_new_app_development
      WEBPACKER_DEV_SERVER_HOST: 172.17.0.1
    links:
      - postgresql
      - webpack
    ports:
      - 3000:3000
    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development
  webpack:
    build: .
    ports:
      - 3035:3035
    volumes:
      - ./:/usr/src/app
    command: ./bin/webpack-dev-server
    environment:
      WEBPACK_HOST: "172.17.0.1:3035"
  specs:
    build: .
    volumes:
      - ./:/usr/src/app/
    environment:      
      DATABASE_URL_TEST: postgresql://admin:admin-secret@postgresql:5432/my_new_app_test
      RAILS_ENV: test
      SMTP_URL: smtp://hello%40localhost@localhost
    links:
      - postgresql
    command: "tail -F /dev/null"
  postgresql:
    image: scalingo/postgresql:12.2.0-6
    ports:
      - 5432:5432
    environment:
      DB_UID: 1000
    volumes:
      - ./docker/postgresql-data:/var/lib/postgresql:rw
    command

version: "2"
services:
  web:
    build: .
    volumes:
      - .:/usr/src/app:rw
    environment:
      DATABASE_URL: postgresql://admin:admin-secret@postgresql:5432/my_new_app_development
      WEBPACKER_DEV_SERVER_HOST: 172.17.0.1
    links:
      - postgresql
      - webpack
    ports:
      - 3000:3000
    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development
  webpack:
    build: .
    ports:
      - 3035:3035
    volumes:
      - ./:/usr/src/app
    command: ./bin/webpack-dev-server
    environment:
      WEBPACK_HOST: "172.17.0.1:3035"
  specs:
    build: .
    volumes:
      - ./:/usr/src/app/
    environment:      
      DATABASE_URL_TEST: postgresql://admin:admin-secret@postgresql:5432/my_new_app_test
      RAILS_ENV: test
      SMTP_URL: smtp://hello%40localhost@localhost
    links:
      - postgresql
    command: "tail -F /dev/null"
  postgresql:
    image: scalingo/postgresql:12.2.0-6
    ports:
      - 5432:5432
    environment:
      DB_UID: 1000
    volumes:
      - ./docker/postgresql-data:/var/lib/postgresql:rw
    command

version: "2"
services:
  web:
    build: .
    volumes:
      - .:/usr/src/app:rw
    environment:
      DATABASE_URL: postgresql://admin:admin-secret@postgresql:5432/my_new_app_development
      WEBPACKER_DEV_SERVER_HOST: 172.17.0.1
    links:
      - postgresql
      - webpack
    ports:
      - 3000:3000
    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development
  webpack:
    build: .
    ports:
      - 3035:3035
    volumes:
      - ./:/usr/src/app
    command: ./bin/webpack-dev-server
    environment:
      WEBPACK_HOST: "172.17.0.1:3035"
  specs:
    build: .
    volumes:
      - ./:/usr/src/app/
    environment:      
      DATABASE_URL_TEST: postgresql://admin:admin-secret@postgresql:5432/my_new_app_test
      RAILS_ENV: test
      SMTP_URL: smtp://hello%40localhost@localhost
    links:
      - postgresql
    command: "tail -F /dev/null"
  postgresql:
    image: scalingo/postgresql:12.2.0-6
    ports:
      - 5432:5432
    environment:
      DB_UID: 1000
    volumes:
      - ./docker/postgresql-data:/var/lib/postgresql:rw
    command

version: "2"
services:
  web:
    build: .
    volumes:
      - .:/usr/src/app:rw
    environment:
      DATABASE_URL: postgresql://admin:admin-secret@postgresql:5432/my_new_app_development
      WEBPACKER_DEV_SERVER_HOST: 172.17.0.1
    links:
      - postgresql
      - webpack
    ports:
      - 3000:3000
    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development
  webpack:
    build: .
    ports:
      - 3035:3035
    volumes:
      - ./:/usr/src/app
    command: ./bin/webpack-dev-server
    environment:
      WEBPACK_HOST: "172.17.0.1:3035"
  specs:
    build: .
    volumes:
      - ./:/usr/src/app/
    environment:      
      DATABASE_URL_TEST: postgresql://admin:admin-secret@postgresql:5432/my_new_app_test
      RAILS_ENV: test
      SMTP_URL: smtp://hello%40localhost@localhost
    links:
      - postgresql
    command: "tail -F /dev/null"
  postgresql:
    image: scalingo/postgresql:12.2.0-6
    ports:
      - 5432:5432
    environment:
      DB_UID: 1000
    volumes:
      - ./docker/postgresql-data:/var/lib/postgresql:rw
    command

Étape 7 option : Ajouter une base de données MySQL à notre pile locale {#step-7-alt2}

Étape 7 option : Ajouter une base de données Redis à notre pile locale {#step-7-alt3}

FAQ

Comment démarrer ma pile locale ?

Comment arrêter ma pile locale ?

Comment exécuter une commande contre ma pile locale ?

Comment installer une gem ?

Comment installer un paquet yarn ?

Comment installer mimemagick ?

Comment installer des binaires externes comme wkhtmltopdf ?

Yann Klis

Yann KLIS a fondé Scalingo en 2015 avec son associé Léo Unbekandt avec la vision de proposer une plateforme cloud d'hébergement web, véritable alternative européenne et souveraine aux géants américains. Aujourd'hui Scalingo héberge plusieurs milliers d'applications web déployées par des clients du monde entier ! L'objectif de Scalingo est de devenir la plateforme cloud de référence pour les développeurs web en Europe. Auparavant, il a fondé Novelys, un studio de développement spécialisé dans la technologie Ruby on Rails.

Restez informé

Recevez des articles et des mises à jour de la plateforme dans votre boîte de réception.

Prêt à déployer en toute confiance ?

Découvrez des déploiements sans temps d'arrêt, une mise à l'échelle automatique intelligente et une infrastructure entièrement gérée. Commencez à déployer vos applications sur Scalingo dès aujourd'hui.

Commencez gratuitement

Voir les tarifs

Aucune carte de crédit requise • Déployez en quelques minutes • Annulez à tout moment

Articles connexes

7 min

2 mars 2026

Découvrez en détail la nouvelle fonctionnalité Private Networks

Étienne Michon

Lire

➝

4 min

18 février 2026

Créez un RAG en quelques minutes avec OpenSearch® et Scalingo

Samir Akarioh

Lire

➝

5 min

1 février 2026

De Heroku à Scalingo : migrez vers un PaaS européen en quelques minutes

Fanny Dufour

Lire

➝

7 min

2 mars 2026

Découvrez en détail la nouvelle fonctionnalité Private Networks

Étienne Michon

Lire

➝

4 min

18 février 2026

Créez un RAG en quelques minutes avec OpenSearch® et Scalingo

Samir Akarioh

Lire

➝

Déployez une première application ou base de données

Commencez à déployer

Rejoignez les équipes qui misent sur une plateforme conçue pour livrer rapidement, opérer sereinement, avec des valeurs européennes et un support humain.

Contactez-nous

Commencez gratuitement

Déployez une première application ou base de données

Commencez à déployer

Rejoignez les équipes qui misent sur une plateforme conçue pour livrer rapidement, opérer sereinement, avec des valeurs européennes et un support humain.

Contactez-nous

Commencez gratuitement

Déployez une première application ou base de données

Commencez à déployer

Rejoignez les équipes qui misent sur une plateforme conçue pour livrer rapidement, opérer sereinement, avec des valeurs européennes et un support humain.

Contactez-nous

Commencez gratuitement