# 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
    ```