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

Dans ce tutoriel, nous allons voir comment configurer Docker et Docker Compose pour le développement local 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 :

• configuration Docker et Docker Compose pour le développement Ruby on Rails, sans base de données

• configuration Docker et Docker Compose pour le développement Ruby on Rails avec PostgreSQL

Ce tutoriel ne couvre pas l’installation de Docker sur votre ordinateur. Vous pouvez vous référer à la documentation officielle de Docker.

Objectif

Nous voulons disposer d’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 comme 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 dans un conteneur Docker, quelle que soit la version de Ruby ou de Rails.

Nous voulons une configuration Docker Compose permettant d’exécuter le conteneur de notre app, webpack-dev-server, notre suite de tests et des bases de données.

Bénéfices

L’utilisation de Docker et Docker Compose pour configurer un environnement de développement local présente de nombreux avantages.

Pour chacun de nos projets, nous pouvons spécifier très facilement :

• 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 libs ou du moteur de base de données ne viendra pas perturber nos autres projets de développement

• nous pouvons avoir, dans un conteneur, des dépendances logicielles spécifiques liées à un projet donné, sans conséquence sur nos autres projets

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

Enfin, nous pouvons complètement simplifier la configuration de l’environnement de développement local : il est plus facile d’onboarder de nouveaux développeurs sur nos projets, ou simplement de revenir sur un projet que nous n’avons pas touché depuis des mois ou des années.

Étape 0 : créer la structure des fichiers {#step-0}

Tout d’abord, nous créons le répertoire qui hébergera notre code source et nous créons trois fichiers vides : Dockerfile, docker-compose.yml et entrypoint.sh.

mkdir my-new-appcd my-new-apptouch Dockerfiletouch docker-compose.ymltouch entrypoint.sh

mkdir my-new-appcd my-new-apptouch Dockerfiletouch docker-compose.ymltouch entrypoint.sh

mkdir my-new-appcd my-new-apptouch Dockerfiletouch docker-compose.ymltouch entrypoint.sh

mkdir my-new-appcd my-new-apptouch Dockerfiletouch docker-compose.ymltouch entrypoint.sh

Le Dockerfile sert à indiquer à Docker comment construire un conteneur à partir de notre code source, et le fichier docker-compose.yml sert à indiquer comment exécuter plusieurs conteneurs, y compris celui de notre app. Nous reviendrons plus tard sur le fichier entrypoint.sh.

Étape 1 : copier le Dockerfile {#step-1}

Il existe de nombreuses façons de construire une image de conteneur Docker. La plus simple et la plus flexible consiste à é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 n’utiliserons que 6 commandes :

• FROM : spécifier une image Docker externe que nous utiliserons 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 : copier un fichier depuis notre système de fichiers local vers le conteneur

• ENTRYPOINT : indiquer comment démarrer notre conteneur Docker

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

FROM ruby:3.0.1ARG USER_IDARG GROUP_IDRUN addgroup --gid $GROUP_ID userRUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID userRUN apt-get update -qqENV GEM_HOME="/usr/src/app/bundle"ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATHRUN apt-get update -qq# Install NodeJSRUN apt-get install -y nodejs# Install yarnRUN 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.listRUN apt-get update -qqRUN apt-get install -y yarnWORKDIR /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.shUSER $USER_IDENTRYPOINT ["entrypoint.sh"]

FROM ruby:3.0.1ARG USER_IDARG GROUP_IDRUN addgroup --gid $GROUP_ID userRUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID userRUN apt-get update -qqENV GEM_HOME="/usr/src/app/bundle"ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATHRUN apt-get update -qq# Install NodeJSRUN apt-get install -y nodejs# Install yarnRUN 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.listRUN apt-get update -qqRUN apt-get install -y yarnWORKDIR /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.shUSER $USER_IDENTRYPOINT ["entrypoint.sh"]

FROM ruby:3.0.1ARG USER_IDARG GROUP_IDRUN addgroup --gid $GROUP_ID userRUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID userRUN apt-get update -qqENV GEM_HOME="/usr/src/app/bundle"ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATHRUN apt-get update -qq# Install NodeJSRUN apt-get install -y nodejs# Install yarnRUN 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.listRUN apt-get update -qqRUN apt-get install -y yarnWORKDIR /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.shUSER $USER_IDENTRYPOINT ["entrypoint.sh"]

FROM ruby:3.0.1ARG USER_IDARG GROUP_IDRUN addgroup --gid $GROUP_ID userRUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID userRUN apt-get update -qqENV GEM_HOME="/usr/src/app/bundle"ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATHRUN apt-get update -qq# Install NodeJSRUN apt-get install -y nodejs# Install yarnRUN 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.listRUN apt-get update -qqRUN apt-get install -y yarnWORKDIR /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.shUSER $USER_IDENTRYPOINT ["entrypoint.sh"]

Analyse de notre Dockerfile

Nous allons utiliser l’image Docker officielle Ruby. Comme nous voulons utiliser Ruby 3.0.1, nous baserons notre image Docker sur la version Docker 3.0.1. La version du tag de l’image Docker est la même que la version du langage Ruby.

FROM ruby:3.0.1

FROM ruby:3.0.1

FROM ruby:3.0.1

FROM ruby:3.0.1

Comme notre objectif est d’installer des gems, nous allons indiquer à notre conteneur Docker où stocker le code source de nos gems. GEM_HOME indiquera à Bundler où stocker les gems. Ici, nous voulons que le code source des gems soit installé dans le répertoire bundle. Nous verrons plus bas 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 PATH 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 officielles Ruby sont basées sur Ubuntu. Nous pouvons utiliser les outils standards d’Ubuntu. Nous aimerions d’abord mettre à jour la base d’informations des paquets. L’option -qq sert à n’afficher que les messages d’erreur.

RUN apt-get update -qq

RUN apt-get update -qq

RUN apt-get update -qq

RUN apt-get update -qq

Comme Rails nécessite que Node soit installé, nous pouvons l’installer avec son paquet Ubuntu.

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 la gem webpacker, qui nécessite l’installation de Yarn. Voici une méthode pour installer Yarn depuis le dépôt Debian/Ubuntu officiel 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.listRUN apt-get updateRUN apt-get install -y 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.listRUN apt-get updateRUN apt-get install -y 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.listRUN apt-get updateRUN apt-get install -y 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.listRUN apt-get updateRUN apt-get install -y yarn

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

WORKDIR /usr/src/app

WORKDIR /usr/src/app

WORKDIR /usr/src/app

WORKDIR /usr/src/app

Enfin, nous ajoutons un script qui sera exécuté à chaque démarrage du conteneur.

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

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

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

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

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

docker-compose est un outil permettant d’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 utiliserons. Nous commencerons avec une configuration très simple.

version: "2"services:  web:    build: .    ports:      - 3000:3000    volumes:      - ./:/usr/src/app    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development

version: "2"services:  web:    build: .    ports:      - 3000:3000    volumes:      - ./:/usr/src/app    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development

version: "2"services:  web:    build: .    ports:      - 3000:3000    volumes:      - ./:/usr/src/app    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development

version: "2"services:  web:    build: .    ports:      - 3000:3000    volumes:      - ./:/usr/src/app    command: bundle exec rails server -b 0.0.0.0 -p 3000 -e development

Analyse de notre docker-compose.yml

TBD

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

TBD

Étape 4 : initialiser notre nouvelle app Rails {#step-4}

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

Nous voulons d’abord lancer une commande bash dans le conteneur de notre app 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 dans le conteneur de notre app en cours d’exécution.

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

gem install rails

gem install rails

gem install rails

gem install rails

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

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

rails new

rails new

rails new

rails new

Chaque fois que vous devrez sortir d’un conteneur Docker en cours d’exécution, vous pouvez taper exit puis appuyer sur ENTRÉE, ou utiliser CTRL+D.

Lancer la commande docker-compose run web command est notre solution de référence pour exécuter n’importe quelle commande dans notre conteneur en cours d’exécution. Vous pouvez l’utiliser pour lancer un terminal bash comme décrit ci-dessus, exécuter une commande Bundler 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 stack 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 référence pour démarrer n’importe quel projet Rails utilisant la configuration Docker et Docker Compose décrite dans ce tutoriel.

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

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

Les versions récentes de Rails nécessitent Webpack. La compilation live des assets est effectuée par un daemon appelé webpack-dev-server.

Nous allons l’ajouter comme nouveau service dans notre fichier docker-compose.yml, qui ressemble désormais à ceci :

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 sera exécuté dans un conteneur séparé de notre conteneur d’app habituel, nous devrons binder webpack-dev-server sur 0.0.0.0, c’est-à-dire sur toutes les interfaces réseau. De cette façon, il sera accessible depuis 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 voulons pas l’utiliser).

Maintenant, arrêtez la stack, reconstruisez-la et redémarrez-la.

docker-compose downdocker-compose builddocker-compose up

docker-compose downdocker-compose builddocker-compose up

docker-compose downdocker-compose builddocker-compose up

docker-compose downdocker-compose builddocker-compose up

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 stack locale {#step-7-alt1}

FROM ruby:3.0.1RUN apt-get updateENV GEM_HOME="/usr/src/app/bundle"ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATHRUN apt-get update -qqRUN apt-get install -y postgresql-client# Install NodeJS# If you don't neet any specific NodeJS version use the Ubuntu packageRUN 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 yarnRUN 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.listRUN apt-get update -qqRUN apt-get install -y yarnWORKDIR /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.shENTRYPOINT ["entrypoint.sh"]

FROM ruby:3.0.1RUN apt-get updateENV GEM_HOME="/usr/src/app/bundle"ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATHRUN apt-get update -qqRUN apt-get install -y postgresql-client# Install NodeJS# If you don't neet any specific NodeJS version use the Ubuntu packageRUN 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 yarnRUN 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.listRUN apt-get update -qqRUN apt-get install -y yarnWORKDIR /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.shENTRYPOINT ["entrypoint.sh"]

FROM ruby:3.0.1RUN apt-get updateENV GEM_HOME="/usr/src/app/bundle"ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATHRUN apt-get update -qqRUN apt-get install -y postgresql-client# Install NodeJS# If you don't neet any specific NodeJS version use the Ubuntu packageRUN 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 yarnRUN 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.listRUN apt-get update -qqRUN apt-get install -y yarnWORKDIR /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.shENTRYPOINT ["entrypoint.sh"]

FROM ruby:3.0.1RUN apt-get updateENV GEM_HOME="/usr/src/app/bundle"ENV PATH $GEM_HOME/bin:$GEM_HOME/gems/bin:$PATHRUN apt-get update -qqRUN apt-get install -y postgresql-client# Install NodeJS# If you don't neet any specific NodeJS version use the Ubuntu packageRUN 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 yarnRUN 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.listRUN apt-get update -qqRUN apt-get install -y yarnWORKDIR /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.shENTRYPOINT ["entrypoint.sh"]

La première chose sera d’ajouter une nouvelle entrée dans la section services de notre fichier docker-compose.yml, qui ressemblera maintenant à ceci :

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: /postgresql

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: /postgresql

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: /postgresql

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: /postgresql

Étape 7 alternative : ajouter une base de données MySQL à notre stack locale {#step-7-alt2}

Étape 7 alternative : ajouter une base de données Redis à notre stack locale {#step-7-alt3}