Creare un'immagine Docker con dati di base

Puoi creare un'immagine Docker pronta all'uso che include l'applicazione e i dati di base (tipologie documenti, tipologie eventi, ruoli). Scegli la configurazione in base alle tue esigenze:

1. Dockerfile (comune a entrambe le modalita)

Crea un file Dockerfile nella root del progetto:

FROM php:8.4-apache

# Abilita mod_rewrite
RUN docker-php-ext-enable opcache \
    && a2enmod rewrite

# Installa estensioni PHP (sia SQLite che MySQL)
RUN docker-php-ext-install pdo_mysql pdo_sqlite bcmath gd zip

# Installa Composer
COPY --from=composer:2 /usr/bin/composer /usr/bin/composer

# Configura DocumentRoot per Laravel
ENV APACHE_DOCUMENT_ROOT=/var/www/html/public
RUN sed -ri -e 's!/var/www/html!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/sites-available/*.conf \
    && sed -ri -e 's!/var/www/!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/apache2.conf /etc/apache2/conf-available/*.conf

# Copia l'applicazione
COPY . /var/www/html/

# Installa dipendenze e compila asset
RUN composer install --no-dev --optimize-autoloader \
    && mkdir -p storage/app/public \
    && mkdir -p storage/framework/cache/data \
    && mkdir -p storage/framework/sessions \
    && mkdir -p storage/framework/views \
    && mkdir -p storage/logs \
    && mkdir -p bootstrap/cache \
    && chown -R www-data:www-data storage bootstrap/cache

# Entrypoint per inizializzazione
COPY docker-entrypoint.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/docker-entrypoint.sh

ENTRYPOINT ["docker-entrypoint.sh"]
CMD ["apache2-foreground"]

2. Entrypoint Script (comune)

Crea docker-entrypoint.sh. Lo script rileva automaticamente la configurazione in base alle variabili d'ambiente:

#!/bin/bash
set -e

# Se .env non esiste, lo genera dalle variabili d'ambiente
if [ ! -f .env ]; then
    cp .env.example .env

    if [ "$DB_CONNECTION" = "mysql" ]; then
        # Configura MySQL
        sed -i "s/DB_CONNECTION=mysql/DB_CONNECTION=mysql/" .env
        sed -i "s/DB_HOST=.*/DB_HOST=${DB_HOST:-mysql}/" .env
        sed -i "s/DB_PORT=.*/DB_PORT=${DB_PORT:-3306}/" .env
        sed -i "s/DB_DATABASE=.*/DB_DATABASE=${DB_DATABASE:-glastree}/" .env
        sed -i "s/DB_USERNAME=.*/DB_USERNAME=${DB_USERNAME:-glastree}/" .env
        sed -i "s/DB_PASSWORD=.*/DB_PASSWORD=${DB_PASSWORD:-secret}/" .env

        # Attende che MySQL sia pronto
        echo "Attendo MySQL..."
        until php -r "new PDO('mysql:host=${DB_HOST:-mysql};dbname=${DB_DATABASE:-glastree}', '${DB_USERNAME:-glastree}', '${DB_PASSWORD:-secret}');" 2>/dev/null; do
            sleep 2
        done
        echo "MySQL pronto."
    else
        # Configura SQLite
        sed -i 's/DB_CONNECTION=mysql/DB_CONNECTION=sqlite/' .env
        sed -i 's/DB_HOST=.*//' .env
        sed -i 's/DB_PORT=.*//' .env
        sed -i 's/DB_DATABASE=.*/DB_DATABASE=\/var\/www\/html\/database\/database.sqlite/' .env
        sed -i 's/DB_USERNAME=.*//' .env
        sed -i 's/DB_PASSWORD=.*//' .env

        touch database/database.sqlite
        chmod 664 database/database.sqlite
    fi

    # Genera APP_KEY
    php artisan key:generate --force
fi

# Esegui migration e seed se il database e vuoto
if [ ! -f .db_initialized ]; then
    php artisan migrate --force
    php artisan db:seed --force
    touch .db_initialized
fi

# Configura storage link
php artisan storage:link --force 2>/dev/null || true

exec "$@"

chmod +x docker-entrypoint.sh

3. Seed Base Dati (comune)

Per includere tipologie documenti, tipologie eventi e ruoli, crea un seeder dedicato:

php artisan make:seeder DockerBaseDataSeeder

Contenuto di database/seeders/DockerBaseDataSeeder.php:

<?php

declare(strict_types=1);

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;

class DockerBaseDataSeeder extends Seeder
{
    public function run(): void
    {
        // Tipologie Documenti
        $tipologieDoc = ['documento', 'avatar', 'galleria', 'statuto', 'programma', 'locandina', 'altro'];
        foreach ($tipologieDoc as $ord => $nome) {
            DB::table('tipologie_documenti')->updateOrInsert(
                ['nome' => $nome],
                ['descrizione' => ucfirst($nome), 'ordine' => $ord + 1, 'attiva' => true]
            );
        }

        // Tipologie Eventi
        $tipologieEventi = [
            ['nome' => 'catechesi', 'descrizione' => 'Catechesi'],
            ['nome' => 'liturgia', 'descrizione' => 'Liturgia'],
            ['nome' => 'animazione', 'descrizione' => 'Animazione'],
            ['nome' => 'formazione', 'descrizione' => 'Formazione'],
            ['nome' => 'incontro', 'descrizione' => 'Incontro'],
            ['nome' => 'riunione', 'descrizione' => 'Riunione'],
            ['nome' => 'festa', 'descrizione' => 'Festa'],
            ['nome' => 'altro', 'descrizione' => 'Altro'],
        ];
        foreach ($tipologieEventi as $ord => $t) {
            DB::table('tipologie_eventi')->updateOrInsert(
                ['nome' => $t['nome']],
                ['descrizione' => $t['descrizione'], 'ordine' => $ord + 1, 'attiva' => true]
            );
        }

        // Ruoli
        $ruoli = ['presidente', 'vicepresidente', 'segretario', 'tesoriere', 'consigliere', 'volontario', 'socio', 'altro'];
        foreach ($ruoli as $ord => $nome) {
            DB::table('ruoli')->updateOrInsert(
                ['nome' => $nome],
                ['descrizione' => ucfirst($nome), 'ordine' => $ord + 1, 'attiva' => true]
            );
        }
    }
}

Registralo in database/seeders/DatabaseSeeder.php:

$this->call([
    // ... altri seeder ...
    DockerBaseDataSeeder::class,
]);

4. Docker Compose

Opzione A — SQLite (leggero)

services:
  glastree:
    build: .
    ports:
      - "8080:80"
    volumes:
      - glastree_storage:/var/www/html/storage
      - glastree_db:/var/www/html/database
    environment:
      - APP_ENV=production
      - APP_DEBUG=false
      - APP_URL=http://localhost:8080
      - DB_CONNECTION=sqlite

volumes:
  glastree_storage:
  glastree_db:

Opzione B — MySQL (standard)

services:
  glastree:
    build: .
    ports:
      - "8080:80"
    volumes:
      - glastree_storage:/var/www/html/storage
    depends_on:
      mysql:
        condition: service_healthy
    environment:
      - APP_ENV=production
      - APP_DEBUG=false
      - APP_URL=http://localhost:8080
      - DB_CONNECTION=mysql
      - DB_HOST=mysql
      - DB_PORT=3306
      - DB_DATABASE=glastree
      - DB_USERNAME=glastree
      - DB_PASSWORD=secret

  mysql:
    image: mysql:8.0
    volumes:
      - mysql_data:/var/lib/mysql
    environment:
      - MYSQL_DATABASE=glastree
      - MYSQL_USER=glastree
      - MYSQL_PASSWORD=secret
      - MYSQL_ROOT_PASSWORD=root_secret
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 5s
      timeout: 3s
      retries: 10

volumes:
  glastree_storage:
  mysql_data:

5. Build e avvio

Assicurati di essere nella cartella del progetto (ottenuta via git clone o estraendo il ZIP), poi:

# Costruisci l'immagine (comune)
docker build -t glastree:latest .

# Avvia con SQLite
docker compose -f docker-compose.yml up -d

# Oppure avvia con MySQL
# docker compose -f docker-compose.mysql.yml up -d

# Apri nel browser
open http://localhost:8080

6. Primo accesso

Al primo avvio, l'entrypoint esegue automaticamente migration e seed. Troverai gia popolati:

• Tipologie Documenti: documento, avatar, galleria, statuto, programma, locandina, altro
• Tipologie Eventi: catechesi, liturgia, animazione, formazione, incontro, riunione, festa, altro
• Ruoli: presidente, vicepresidente, segretario, tesoriere, consigliere, volontario, socio, altro

Dovrai creare il primo utente amministratore via CLI:

docker exec -it glastree php artisan tinker --execute="
\$u = new \App\Models\User;
\$u->name = 'Amministratore';
\$u->email = 'admin@esempio.it';
\$u->password = bcrypt('password-forte');
\$u->is_admin = true;
\$u->permissions = ['individui' => 2, 'gruppi' => 2, 'eventi' => 2, 'documenti' => 2, 'mailing' => 2, 'viste' => 2, 'report' => 2, 'settings' => 2];
\$u->save();
echo 'Utente creato con successo!';
"