278 lines
6.7 KiB
Markdown
278 lines
6.7 KiB
Markdown
# Guide de Déploiement - Fiche Agent (Docker)
|
|
|
|
Ce guide décrit la procédure pour déployer l'application **Fiche Agent** en utilisant Docker et Docker Compose. Cette méthode simplifie la gestion des dépendances et garantit un environnement identique entre le développement et la production.
|
|
|
|
## 1. Prérequis
|
|
|
|
Assurez-vous que le serveur hôte dispose de :
|
|
* **Docker**
|
|
* **Docker Compose** (souvent inclus avec Docker Desktop ou via le plugin `docker-compose-plugin` sur Linux)
|
|
* **Git**
|
|
|
|
## 2. Structure des Fichiers Docker
|
|
|
|
Créez les fichiers suivants à la racine de votre projet.
|
|
|
|
### 2.1 Dockerfile (Production)
|
|
|
|
Créez un fichier nommé `Dockerfile` :
|
|
|
|
```dockerfile
|
|
# Étape 1 : Construction des assets Frontend
|
|
FROM node:20 AS frontend
|
|
WORKDIR /app
|
|
COPY package*.json ./
|
|
RUN npm ci
|
|
COPY . .
|
|
RUN npm run build
|
|
|
|
# Étape 2 : Construction de l'application PHP
|
|
FROM php:8.2-fpm
|
|
|
|
# Installation des dépendances système
|
|
RUN apt-get update && apt-get install -y \
|
|
git \
|
|
curl \
|
|
libpng-dev \
|
|
libonig-dev \
|
|
libxml2-dev \
|
|
zip \
|
|
unzip \
|
|
libzip-dev \
|
|
libicu-dev \
|
|
default-mysql-client \
|
|
nginx \
|
|
supervisor
|
|
|
|
# Nettoyage du cache apt
|
|
RUN apt-get clean && rm -rf /var/lib/apt/lists/*
|
|
|
|
# Installation des extensions PHP
|
|
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd intl zip
|
|
|
|
# Installation de Composer
|
|
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
|
|
|
|
# Configuration du répertoire de travail
|
|
WORKDIR /var/www
|
|
|
|
# Copie des fichiers du projet
|
|
COPY . .
|
|
|
|
# Copie des assets buildés depuis l'étape frontend
|
|
COPY --from=frontend /app/public/build ./public/build
|
|
|
|
# Installation des dépendances PHP (Mode Production)
|
|
RUN composer install --no-dev --optimize-autoloader --no-scripts
|
|
|
|
# Permissions
|
|
RUN chown -R www-data:www-data /var/www/storage /var/www/bootstrap/cache
|
|
|
|
# Configuration Nginx
|
|
COPY docker/nginx/conf.d/app.conf /etc/nginx/sites-available/default
|
|
RUN rm /etc/nginx/sites-enabled/default && ln -s /etc/nginx/sites-available/default /etc/nginx/sites-enabled/
|
|
|
|
# Configuration PHP
|
|
COPY docker/php/local.ini /usr/local/etc/php/conf.d/local.ini
|
|
|
|
# Configuration Supervisor
|
|
COPY docker/supervisor/supervisord.conf /etc/supervisor/conf.d/supervisord.conf
|
|
|
|
# Script d'entrée
|
|
COPY docker/entrypoint.sh /usr/local/bin/entrypoint.sh
|
|
RUN chmod +x /usr/local/bin/entrypoint.sh
|
|
|
|
EXPOSE 80
|
|
|
|
ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
|
|
```
|
|
|
|
### 2.2 Configuration Nginx
|
|
|
|
Créez le fichier `docker/nginx/conf.d/app.conf` :
|
|
|
|
```nginx
|
|
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 127.0.0.1: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;
|
|
}
|
|
}
|
|
```
|
|
|
|
### 2.3 Configuration PHP
|
|
|
|
Créez le fichier `docker/php/local.ini` :
|
|
|
|
```ini
|
|
upload_max_filesize=40M
|
|
post_max_size=40M
|
|
memory_limit=256M
|
|
```
|
|
|
|
### 2.4 Configuration Supervisor
|
|
|
|
Créez le fichier `docker/supervisor/supervisord.conf` :
|
|
|
|
```ini
|
|
[supervisord]
|
|
nodaemon=true
|
|
|
|
[program:php-fpm]
|
|
command=docker-php-entrypoint php-fpm
|
|
stdout_logfile=/dev/stdout
|
|
stdout_logfile_maxbytes=0
|
|
stderr_logfile=/dev/stderr
|
|
stderr_logfile_maxbytes=0
|
|
autorestart=true
|
|
|
|
[program:nginx]
|
|
command=nginx -g 'daemon off;'
|
|
stdout_logfile=/dev/stdout
|
|
stdout_logfile_maxbytes=0
|
|
stderr_logfile=/dev/stderr
|
|
stderr_logfile_maxbytes=0
|
|
autorestart=true
|
|
|
|
[program:laravel-worker]
|
|
process_name=%(program_name)s_%(process_num)02d
|
|
command=php /var/www/artisan queue:work database --sleep=3 --tries=3
|
|
autostart=true
|
|
autorestart=true
|
|
user=www-data
|
|
numprocs=2
|
|
redirect_stderr=true
|
|
stdout_logfile=/var/www/storage/logs/worker.log
|
|
```
|
|
|
|
### 2.5 Script d'Entrée (Entrypoint)
|
|
|
|
Créez le fichier `docker/entrypoint.sh` :
|
|
|
|
```bash
|
|
#!/bin/sh
|
|
|
|
# Démarrer Nginx et PHP-FPM via Supervisor
|
|
# Mais avant, on peut lancer des commandes de maintenance
|
|
# php artisan migrate --force
|
|
# php artisan cache:clear
|
|
|
|
# Donner les droits si nécessaire (à adapter selon votre contexte de volume)
|
|
chown -R www-data:www-data /var/www/storage
|
|
|
|
exec /usr/bin/supervisord -c /etc/supervisor/conf.d/supervisord.conf
|
|
```
|
|
|
|
### 2.6 Docker Compose (Production)
|
|
|
|
Créez le fichier `docker-compose.prod.yml` :
|
|
|
|
```yaml
|
|
version: '3.8'
|
|
|
|
services:
|
|
app:
|
|
build:
|
|
context: .
|
|
dockerfile: Dockerfile
|
|
container_name: fiche_agent_app
|
|
restart: always
|
|
ports:
|
|
- "8080:80" # L'application sera accessible sur le port 8080
|
|
environment:
|
|
APP_NAME: "Fiche Agent"
|
|
APP_ENV: production
|
|
APP_KEY: ${APP_KEY}
|
|
APP_DEBUG: false
|
|
APP_URL: ${APP_URL}
|
|
DB_CONNECTION: mysql
|
|
DB_HOST: db
|
|
DB_PORT: 3306
|
|
DB_DATABASE: ${DB_DATABASE}
|
|
DB_USERNAME: ${DB_USERNAME}
|
|
DB_PASSWORD: ${DB_PASSWORD}
|
|
QUEUE_CONNECTION: database
|
|
depends_on:
|
|
- db
|
|
networks:
|
|
- app-network
|
|
|
|
db:
|
|
image: mysql:8.0
|
|
container_name: fiche_agent_db
|
|
restart: always
|
|
environment:
|
|
MYSQL_DATABASE: ${DB_DATABASE}
|
|
MYSQL_USER: ${DB_USERNAME}
|
|
MYSQL_PASSWORD: ${DB_PASSWORD}
|
|
MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}_root
|
|
volumes:
|
|
- db_data:/var/lib/mysql
|
|
networks:
|
|
- app-network
|
|
|
|
networks:
|
|
app-network:
|
|
driver: bridge
|
|
|
|
volumes:
|
|
db_data:
|
|
```
|
|
|
|
## 3. Déploiement
|
|
|
|
1. **Créez le fichier `.env` sur le serveur :**
|
|
Copiez votre `.env.example` en `.env` et remplissez les valeurs (APP_KEY, DB_PASSWORD, etc.). Assurez-vous que `DB_HOST=db`.
|
|
|
|
2. **Lancez les conteneurs :**
|
|
|
|
```bash
|
|
docker-compose -f docker-compose.prod.yml up -d --build
|
|
```
|
|
|
|
3. **Initialisation (première fois seulement) :**
|
|
|
|
```bash
|
|
# Générer la clé d'application si ce n'est pas fait
|
|
docker-compose -f docker-compose.prod.yml exec app php artisan key:generate
|
|
|
|
# Lancer les migrations
|
|
docker-compose -f docker-compose.prod.yml exec app php artisan migrate --force
|
|
|
|
# (Optionnel) Seeder la base de données
|
|
docker-compose -f docker-compose.prod.yml exec app php artisan db:seed --force
|
|
```
|
|
|
|
4. **Accédez à l'application :**
|
|
Ouvrez votre navigateur sur `http://votre-serveur:8080`.
|
|
|
|
## 4. Maintenance
|
|
|
|
* **Mettre à jour l'application :**
|
|
```bash
|
|
git pull
|
|
docker-compose -f docker-compose.prod.yml up -d --build
|
|
docker-compose -f docker-compose.prod.yml exec app php artisan migrate --force
|
|
```
|
|
|
|
* **Voir les logs :**
|
|
```bash
|
|
docker-compose -f docker-compose.prod.yml logs -f app
|
|
```
|