Comment conteneuriser une application Laravel pour le développement avec Docker Compose sur Ubuntu 18.04

Conteneuriser une application fait référence au processus d’adaptation d’une application et de ses composants afin de pouvoir l’exécuter dans des environnements légers appelés conteneurs. Ces environnements sont isolés et remplaçables et peuvent être exploités pour développer, tester et déployer des apps en production.

Dans ce guide, nous utiliserons Docker Compose pour conteneuriser une application Laravel pour le développement. Lorsque vous aurez terminé, vous aurez une application Laravel de démonstration fonctionnant sur trois conteneurs de service distincts :

• Un service app fonctionnant sous PHP7.4-FPM ;
• Un service db fonctionnant sous MySQL 5.7 ;
• Un service nginx qui utilise le service app pour analyser le code PHP avant de servir l’application Laravel à l’utilisateur final.

Pour permettre un processus de développement simplifié et faciliter le débogage des apps, nous maintiendrons la synchronisation des fichiers d’application en utilisant des volumes partagés. Nous verrons également comment utiliser les commandes docker-compose exec pour exécuter Composer et Artisan sur le conteneur de l’app.

• Accès à une machine locale Ubuntu 18.04 ou à un serveur de développement en tant qu’utilisateur non root avec des privilèges sudo. Si vous utilisez un serveur distant, il est conseillé d’avoir un pare-feu actif installé. Pour les configurer, veuillez vous référer à notre Guide de configuration initiale du serveur pour Ubuntu 18.04.
• Docker installé sur votre serveur, en suivant les Étapes 1 et 2 de Comment installer et utiliser Docker sur Ubuntu 18.04.
• Docker Compose installé sur votre serveur, en suivant l’Étape 1 de Comment installer Docker Compose sur Ubuntu 18.04.

Pour commencer, nous irons chercher l’application de démonstration Laravel dans son répertoire Github. Nous sommes intéressés par la branche tutorial-01, qui contient l’application Laravel de base que nous avons créée dans le premier guide de cette série.

Pour obtenir le code d’application compatible avec ce tutoriel, téléchargez la version tutorial-1.0.1 dans votre répertoire de base avec :

cd ~
curl -L https://github.com/do-community/travellist-laravel-demo/archive/tutorial-1.0.1.zip -o travellist.zip

Nous aurons besoin de la commande unzip pour décompresser le code d’application. Si vous n’avez pas encore installé ce package, faites-le maintenant avec :

sudo apt update
sudo apt install unzip

Maintenant, décompressez le contenu de l’application et renommez le répertoire décompressé pour un accès plus facile :

unzip travellist.zip
mv travellist-laravel-demo-tutorial-1.0.1 travellist-demo

Naviguez vers le répertoire travellist-demo :

cd travellist-demo

Au cours de la prochaine étape, nous allons créer un fichier de configuration .env pour configurer l’application.

Les fichiers de configuration Laravel sont situés dans un répertoire appelé config, dans le répertoire root de l’application. En outre, un fichier .env est utilisé pour configurer environment-dependent configuration, telles que les références et toute information pouvant varier d’un déploiement à l’autre. Ce fichier n’est pas inclus dans la gestion de versions.

Les valeurs contenues dans le fichier .env auront la priorité sur les valeurs fixées dans les fichiers de configuration habituels situés dans le répertoire config. Chaque installation sur un nouvel environnement nécessite un fichier d’environnement personnalisé pour définir des éléments tels que les paramètres de connexion à la base de données, les options de débogage, l’URL de l’application, entre autres, qui peuvent varier en fonction de l’environnement dans lequel l’application est exécutée.

Nous allons maintenant créer un nouveau fichier .env afin de personnaliser les options de configuration pour l’environnement de développement que nous configurons. Laravel contient un exemple de fichier .env que nous pouvons copier pour créer le nôtre :

cp .env.example .env

Ouvrez ce fichier en utilisant nano ou votre éditeur de texte préféré :

nano .env

Le fichier .env provenant de l’application de démonstration travellist contient des paramètres pour utiliser une base de données MySQL locale, avec 127.0.0.1 comme hôte de base de données. Nous devons mettre à jour la variable DB_HOST afin qu’il pointe vers le service de base de données que nous allons créer dans notre environnement Docker. Dans ce guide, nous appellerons notre service de base de données db. Commencez et remplacez la valeur listée de DB_HOST par le nom du service de base de données :

APP_NAME=Travellist
APP_ENV=dev
APP_KEY=
APP_DEBUG=true
APP_URL=http://localhost:8000

LOG_CHANNEL=stack

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=travellist
DB_USERNAME=travellist_user
DB_PASSWORD=password
...

N’hésitez pas à modifier également le nom de la base de données, le nom d’utilisateur et le mot de passe, si vous le souhaitez. Ces variables seront exploitées lors d’une étape ultérieure où nous mettrons en place le fichier docker-compose.yml pour configurer nos services.

Enregistrez le fichier lorsque vous avez fini de le modifier. Si vous avez utilisé nano, vous pouvez le faire en appuyant sur CTRL+X, puis Y et ENTER pour confirmer.

Bien que nos services MySQL et Nginx seront basés sur des images par défaut obtenues à partir de Docker Hub, nous devons encore construire une image personnalisée pour le conteneur de l’application. Bien que nos services MySQL et Nginx soient basés sur des images par défaut obtenues à partir de Docker Hub, nous devons malgré tout construire une image personnalisée pour le conteneur de l’application.

Notre image travellist sera basée sur l’image PHP officielle php:7.4-fpm de Docker Hub. En plus de cet environnement PHP-FPM de base, nous allons installer quelques modules PHP supplémentaires et l’outil de gestion des dépendances Composer.

Nous allons également créer un nouvel utilisateur système ; c’est nécessaire pour exécuter les commandes artisan et composer lors du développement de l’application. Le paramètre uid garantit que l’utilisateur à l’intérieur du conteneur a le même uid que l’utilisateur de votre système sur votre machine hôte, où vous exécutez Docker. Ainsi, tous les fichiers créés par ces commandes sont répliqués dans l’hôte avec les bonnes permissions. Cela signifie également que vous pourrez utiliser l’éditeur de code de votre choix dans la machine hôte pour développer l’application qui s’exécute dans les conteneurs.

Créez un nouveau Dockerfile avec :

nano Dockerfile

Copiez le contenu suivant dans votre Dockerfile :

FROM php:7.4-fpm

# Arguments defined in docker-compose.yml
ARG user
ARG uid

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip

# Clear cache
RUN apt-get clean && rm -rf /var/lib/apt/lists/*

# Install PHP extensions
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd

# Get latest Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Create system user to run Composer and Artisan Commands
RUN useradd -G www-data,root -u $uid -d /home/$user $user
RUN mkdir -p /home/$user/.composer && \
    chown -R $user:$user /home/$user

# Set working directory
WORKDIR /var/www

USER $user

N’oubliez pas d’enregistrer le fichier lorsque vous avez terminé.

Notre Dockerfile commence par définir l’image de base que nous utilisons : php:7.4-fpm.

Après avoir installé les packages système et les extensions PHP, nous installons Composer en copiant le fichier exécutable composer depuis sa dernière image officielle vers notre propre image d’application.

Un nouvel utilisateur système est alors créé et configuré en utilisant les arguments user et uid qui ont été déclarés au début du Dockerfile. Ces valeurs seront injectées par Docker Compose au moment de la construction.

Enfin, nous avons défini le répertoire de travail par défaut comme /var/www et changé pour l’utilisateur nouvellement créé. Cela vous permettra de vous connecter comme un utilisateur régulier et de vous assurer que vous êtes dans le bon répertoire lorsque vous exécutez les commandes composer et artisan sur le conteneur de l’application.

Lors de la création d’environnements de développement avec Docker Compose, il est souvent nécessaire de partager des fichiers de configuration ou d’initialisation avec des conteneurs de services, afin de mettre en place ou de démarrer ces services. Cette pratique facilite la modification des fichiers de configuration pour affiner votre environnement pendant que vous développez l’application.

Nous allons maintenant créer un dossier avec des fichiers qui serviront à configurer et à initialiser nos conteneurs de services.

Pour configurer Nginx, nous allons partager un fichier travellist.conf qui configurera la façon dont l’application est servie. Créez le dossier docker-compose/nginx avec :

mkdir -p docker-compose/nginx

Ouvrez un nouveau fichier appelé travellist.conf dans ce répertoire :

nano docker-compose/nginx/travellist.conf

Copiez la configuration Nginx suivante dans ce fichier :

server {
    listen 80;
    index index.php index.html;
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    root /var/www/public;
    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass app:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }
    location / {
        try_files $uri $uri/ /index.php?$query_string;
        gzip_static on;
    }
}

Ce fichier configurera Nginx pour écouter sur le port 80 et utilisera index.php comme page d’index par défaut. Il définira le document root comme /var/www/public, et configurera ensuite Nginx pour utiliser le service de l’app sur le port 9000 pour traiter les fichiers *.php.

Enregistrez et fermez le fichier lorsque vous avez fini de le modifier.

Pour mettre en place la base de données MySQL, nous allons partager un dump de base de données qui sera importé lors de l’initialisation du conteneur. C’est une fonctionnalité fournie par l’image MySQL 5.7 que nous utiliserons sur ce conteneur.

Créez un nouveau dossier pour vos fichiers d’initialisation MySQL dans le dossier docker-compose :

mkdir docker-compose/mysql

Ouvrez un nouveau fichier .sql :

nano docker-compose/mysql/init_db.sql

La sauvegarde Dump MySQL suivante est basée sur la base de données que nous avons mise en place dans notre guide Laravel sur LEMP. Elle créera une nouvelle table appelée places. Ensuite, elle remplira le tableau avec un ensemble de lieux d’échantillonnage.

Ajoutez le code suivant au fichier :

DROP TABLE IF EXISTS `places`;

CREATE TABLE `places` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
  `visited` tinyint(1) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

INSERT INTO `places` (name, visited) VALUES ('Berlin',0),('Budapest',0),('Cincinnati',1),('Denver',0),('Helsinki',0),('Lisbon',0),('Moscow',1),('Nairobi',0),('Oslo',1),('Rio',0),('Tokyo',0);

La table places contient trois champs : id, name, et visited. Le champ visited est un drapeau utilisé pour identifier les lieux qui doivent encore être visités. N’hésitez pas à modifier les échantillons de lieux ou à en inclure de nouveaux. Enregistrez et fermez le fichier lorsque vous avez fini de le modifier.

Nous avons fini de mettre en place le Dockerfile de l’application et les fichiers de configuration du service. Ensuite, nous allons mettre en place Docker Compose pour utiliser ces fichiers lors de la création de nos services.

Docker Compose permet de créer des environnements multi-conteneurs pour les apps s’exécutant sur Docker. Il utilise les définitions de services pour construire des environnements entièrement personnalisables avec plusieurs conteneurs qui peuvent échanger des réseaux et des volumes de données. Cela permet une intégration harmonieuse entre les composants de l’application.

Pour configurer nos définitions de service, nous créerons un nouveau fichier appelé docker-compose.yml. Généralement, ce fichier est situé à la racine du dossier d’application et définit votre environnement conteneurisé, y compris les images de base que vous utiliserez pour construire vos conteneurs et la manière dont vos services interagiront.

Nous définirons trois services différents dans notre fichiers docker-compose.yml : app, db et nginx.

Le service app construira une image appelée travellist basée sur le Dockerfile que nous avons précédemment créé. Le conteneur défini par ce service exécutera un serveur php-fpm pour analyser le code PHP et renvoyer les résultats au service nginx, qui fonctionnera sur un conteneur séparé. Le service mysql définit un conteneur exécutant un serveur MySQL 5.7. Nos services partageront un pont de réseau appelé travellist.

Les fichiers de l'application seront synchronisés à la fois sur l’application et sur le service nginx via bind mounts. Les bind mounts sont utiles dans les environnements de développement car ils permettent une synchronisation bidirectionnelle performante entre la machine hôte et les conteneurs.

Créez un nouveau fichier docker-compose.yml à la racine du dossier de l’application :

nano docker-compose.yml

Un fichier docker-compose.yml classique débute par une définition de la version, suivie par un noeud de services qui définit l’ensemble des services. Les réseaux partagés sont généralement définis au bas de ce fichier.

Pour commencer, copiez ce code standard dans votre fichier docker-compose.yml :

version: "3.7"
services:


networks:
  travellist:
    driver: bridge

Nous allons maintenant modifier le nœud de services pour inclure les services app, db et nginx.

  app:
    build:
      args:
        user: sammy
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: travellist
    container_name: travellist-app
    restart: unless-stopped
    working_dir: /var/www/
    volumes:
      - ./:/var/www
    networks:
      - travellist

  db:
    image: mysql:5.7
    container_name: travellist-db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_USER: ${DB_USERNAME}
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - ./docker-compose/mysql:/docker-entrypoint-initdb.d
    networks:
      - travellist

  nginx:
    image: nginx:1.17-alpine
    container_name: travellist-nginx
    restart: unless-stopped
    ports:
      - 8000:80
    volumes:
      - ./:/var/www
      - ./docker-compose/nginx:/etc/nginx/conf.d
    networks:
      - travellist

version: "3.7"
services:
  app:
    build:
      args:
        user: sammy
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: travellist
    container_name: travellist-app
    restart: unless-stopped
    working_dir: /var/www/
    volumes:
      - ./:/var/www
    networks:
      - travellist

  db:
    image: mysql:5.7
    container_name: travellist-db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_USER: ${DB_USERNAME}
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - ./docker-compose/mysql:/docker-entrypoint-initdb.d
    networks:
      - travellist

  nginx:
    image: nginx:alpine
    container_name: travellist-nginx
    restart: unless-stopped
    ports:
      - 8000:80
    volumes:
      - ./:/var/www
      - ./docker-compose/nginx:/etc/nginx/conf.d/
    networks:
      - travellist

networks:
  travellist:
    driver: bridge

Nous allons maintenant utiliser les commandes docker-compose pour construire l’image de l’application et exécuter les services que nous avons spécifiés dans notre configuration.

Construisez l’image de app avec la commande suivante :

docker-compose build app

Cette commande peut prendre quelques minutes. Vous verrez une sortie similaire à celle-ci :

Output
Building app
Step 1/11 : FROM php:7.4-fpm
 ---> fa37bd6db22a
Step 2/11 : ARG user
 ---> Running in f71eb33b7459
Removing intermediate container f71eb33b7459
 ---> 533c30216f34
Step 3/11 : ARG uid
 ---> Running in 60d2d2a84cda
Removing intermediate container 60d2d2a84cda
 ---> 497fbf904605
Step 4/11 : RUN apt-get update && apt-get install -y     git     curl     libpng-dev     libonig-dev     ...
Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
 ---> e499f74896e3
Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user
 ---> Running in 232ef9c7dbd1
Removing intermediate container 232ef9c7dbd1
 ---> 870fa3220ffa
Step 9/11 : RUN mkdir -p /home/$user/.composer &&     chown -R $user:$user /home/$user
 ---> Running in 7ca8c0cb7f09
Removing intermediate container 7ca8c0cb7f09
 ---> 3d2ef9519a8e
Step 10/11 : WORKDIR /var/www
 ---> Running in 4a964f91edfa
Removing intermediate container 4a964f91edfa
 ---> 00ada639da21
Step 11/11 : USER $user
 ---> Running in 9f8e874fede9
Removing intermediate container 9f8e874fede9
 ---> fe176ff4702b

Successfully built fe176ff4702b
Successfully tagged travellist:latest

Lorsque la construction est terminée, vous pouvez exécuter l’environnement en mode arrière-plan avec :

docker-compose up -d

Output
Creating travellist-db    ... done
Creating travellist-app   ... done
Creating travellist-nginx ... done

Cela fera tourner vos conteneurs en arrière-plan. Pour afficher des informations sur l’état de vos services actifs, exécutez :

docker-compose ps

Vous verrez une sortie de ce type :

Output
      Name                    Command              State          Ports        
-------------------------------------------------------------------------------
travellist-app     docker-php-entrypoint php-fpm   Up      9000/tcp            
travellist-db      docker-entrypoint.sh mysqld     Up      3306/tcp, 33060/tcp
travellist-nginx   nginx -g daemon off;            Up      0.0.0.0:8000->80/tcp

Votre environnement est maintenant opérationnel, mais nous devons encore exécuter quelques commandes pour terminer la configuration de l’application. Vous pouvez utiliser la commande docker-compose exec pour exécuter les commandes dans les conteneurs de services, tels qu’un ls -l pour afficher les informations détaillées sur les fichiers dans le répertoire de l’application :

docker-compose exec app ls -l

Output
total 256
-rw-rw-r-- 1 sammy 1001    738 Jan 15 16:46 Dockerfile
-rw-rw-r-- 1 sammy 1001    101 Jan  7 08:05 README.md
drwxrwxr-x 6 sammy 1001   4096 Jan  7 08:05 app
-rwxr-xr-x 1 sammy 1001   1686 Jan  7 08:05 artisan
drwxrwxr-x 3 sammy 1001   4096 Jan  7 08:05 bootstrap
-rw-rw-r-- 1 sammy 1001   1501 Jan  7 08:05 composer.json
-rw-rw-r-- 1 sammy 1001 179071 Jan  7 08:05 composer.lock
drwxrwxr-x 2 sammy 1001   4096 Jan  7 08:05 config
drwxrwxr-x 5 sammy 1001   4096 Jan  7 08:05 database
drwxrwxr-x 4 sammy 1001   4096 Jan 15 16:46 docker-compose
-rw-rw-r-- 1 sammy 1001   1015 Jan 15 16:45 docker-compose.yml
-rw-rw-r-- 1 sammy 1001   1013 Jan  7 08:05 package.json
-rw-rw-r-- 1 sammy 1001   1405 Jan  7 08:05 phpunit.xml
drwxrwxr-x 2 sammy 1001   4096 Jan  7 08:05 public
-rw-rw-r-- 1 sammy 1001    273 Jan  7 08:05 readme.md
drwxrwxr-x 6 sammy 1001   4096 Jan  7 08:05 resources
drwxrwxr-x 2 sammy 1001   4096 Jan  7 08:05 routes
-rw-rw-r-- 1 sammy 1001    563 Jan  7 08:05 server.php
drwxrwxr-x 5 sammy 1001   4096 Jan  7 08:05 storage
drwxrwxr-x 4 sammy 1001   4096 Jan  7 08:05 tests
-rw-rw-r-- 1 sammy 1001    538 Jan  7 08:05 webpack.mix.js

Nous allons maintenant exécuter composer install pour installer les dépendances de l’application :

docker-compose exec app composer install

Vous verrez une sortie de ce type :

Output
Loading composer repositories with package information
Installing dependencies (including require-dev) from lock file
Package operations: 85 installs, 0 updates, 0 removals
  - Installing doctrine/inflector (1.3.1): Downloading (100%)         
  - Installing doctrine/lexer (1.2.0): Downloading (100%)         
  - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%)         
  - Installing erusev/parsedown (1.7.4): Downloading (100%)         
  - Installing symfony/polyfill-ctype (v1.13.1): Downloading (100%)         
  - Installing phpoption/phpoption (1.7.2): Downloading (100%)         
  - Installing vlucas/phpdotenv (v3.6.0): Downloading (100%)         
  - Installing symfony/css-selector (v5.0.2): Downloading (100%)        
…
Generating optimized autoload files
> Illuminate\Foundation\ComposerScripts::postAutoloadDump
> @php artisan package:discover --ansi
Discovered Package: facade/ignition
Discovered Package: fideloper/proxy
Discovered Package: laravel/tinker
Discovered Package: nesbot/carbon
Discovered Package: nunomaduro/collision
Package manifest generated successfully.

La dernière chose que nous devons faire avant de tester l’application est de générer une clé d’application unique avec l’outil de ligne de commande Laravel, artisan. Cette clé est utilisée pour chiffrer les sessions des utilisateurs et d’autres données sensibles :

docker-compose exec app php artisan key:generate

Output
Application key set successfully.

Ouvrez maintenant votre navigateur et accédez au nom de domaine ou à l’adresse IP de votre serveur sur le port 8000 :

http://server_domain_or_IP:8000

Vous verrez une page comme celle-ci :

Vous pouvez utiliser la commande logs pour consultez les journaux générés par vos services :

docker-compose logs nginx

Attaching to travellist-nginx
travellist-nginx | 192.168.160.1 - - [23/Jan/2020:13:57:25 +0000] "GET / HTTP/1.1" 200 626 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36"
travellist-nginx | 192.168.160.1 - - [23/Jan/2020:13:57:26 +0000] "GET /favicon.ico HTTP/1.1" 200 0 "http://localhost:8000/" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36"
travellist-nginx | 192.168.160.1 - - [23/Jan/2020:13:57:42 +0000] "GET / HTTP/1.1" 200 626 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36"
…

Si vous voulez mettre en pause votre environnement Docker Compose tout en conservant l’état de tous ses services, exécutez :

docker-compose pause

Output
Pausing travellist-db    ... done
Pausing travellist-nginx ... done
Pausing travellist-app   ... done

Vous pouvez alors reprendre vos services avec :

docker-compose unpause

Output
Unpausing travellist-app   ... done
Unpausing travellist-nginx ... done
Unpausing travellist-db    ... done

Pour fermer votre environnement Docker Compose et retirer tous ses conteneurs, réseaux et volumes, exécutez :

docker-compose down

Output
Stopping travellist-nginx ... done
Stopping travellist-db    ... done
Stopping travellist-app   ... done
Removing travellist-nginx ... done
Removing travellist-db    ... done
Removing travellist-app   ... done
Removing network travellist-laravel-demo_travellist

Pour un aperçu de toutes les commandes Docker Compose, veuillez consulter la référence de la ligne de commande Docker Compose.

Dans ce guide, nous avons mis en place un environnement Docker avec trois conteneurs en utilisant Docker Compose pour définir notre infrastructure dans un fichier YAML.

À partir de ce moment, vous pouvez travailler sur votre application Laravel sans avoir besoin d’installer et de configurer un serveur web local pour le développement et les tests. De plus, vous travaillerez avec un environnement jetable qui peut être facilement reproduit et distribué, ce qui peut être utile lors du développement de votre application et aussi lors de la transition vers un environnement de production.