> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Seeding de base de datos

> Explicamos cómo introducir en la base de datos datos de muestra o iniciales para desarrollo y pruebas usando el seeding de Laravel.

## ¿Qué es el seeding?

El seeding es un mecanismo para introducir en la base de datos datos de muestra o iniciales.

Al preparar el entorno de desarrollo o al ejecutar pruebas automatizadas, suele necesitarse un estado inicial con datos. Introducirlos manualmente cada vez es costoso, así que se encapsulan en seeders para poder ejecutarlos repetidamente.

Las clases seeder se guardan en el directorio `database/seeders`. Por defecto se incluye la clase `DatabaseSeeder`.

```mermaid theme={null}
flowchart TD
    A["php artisan db:seed"] --> B["DatabaseSeeder::run()"]
    B --> C["UserSeeder::run()"]
    B --> D["PostSeeder::run()"]
    C --> E["Inserta datos en la tabla users"]
    D --> F["Inserta datos en la tabla posts"]
```

## Creación de un seeder

Genera una nueva clase seeder con el comando Artisan `make:seeder`.

```shell theme={null}
php artisan make:seeder UserSeeder
```

El archivo generado se ubica en `database/seeders/UserSeeder.php`.

```php theme={null}
<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class UserSeeder extends Seeder
{
    /**
     * Ejecuta el seeder
     */
    public function run(): void
    {
        // Escribe aquí la inserción de datos
    }
}
```

## Implementación del seeder

Escribe la lógica de inserción dentro del método `run()`. Puedes usar la fachada DB o modelos Eloquent.

### Usando la fachada DB

```php theme={null}
<?php

namespace Database\Seeders;

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

class UserSeeder extends Seeder
{
    public function run(): void
    {
        DB::table('users')->insert([
            [
                'name' => 'Taro Yamada',
                'email' => 'taro@example.com',
                'password' => Hash::make('password'),
                'created_at' => now(),
                'updated_at' => now(),
            ],
            [
                'name' => 'Hanako Suzuki',
                'email' => 'hanako@example.com',
                'password' => Hash::make('password'),
                'created_at' => now(),
                'updated_at' => now(),
            ],
        ]);
    }
}
```

### Usando modelos Eloquent

```php theme={null}
use App\Models\User;
use Illuminate\Support\Facades\Hash;

public function run(): void
{
    User::create([
        'name' => 'Administrador',
        'email' => 'admin@example.com',
        'password' => Hash::make('password'),
    ]);
}
```

<Info>
  Durante el seeding la protección de mass assignment se desactiva automáticamente. Puedes insertar datos sin preocuparte por la configuración de `$fillable` o `$guarded`.
</Info>

## Combinación con las factories de modelo

Cuando necesitas grandes volúmenes de datos de prueba, resulta muy útil combinarlo con las [factories de modelo](/es/eloquent). Con las factories puedes generar en bloque datos aleatorios ficticios.

```php theme={null}
use App\Models\User;
use App\Models\Post;

public function run(): void
{
    // Crea 10 usuarios
    User::factory(10)->create();

    // Crea 3 posts para cada uno de 5 usuarios
    User::factory(5)
        ->hasPosts(3)
        ->create();
}
```

<Tip>
  Consulta la documentación de factories de Eloquent para más detalles sobre su uso.
</Tip>

## Uso de DatabaseSeeder

`DatabaseSeeder` es el punto de entrada que gestiona la ejecución de múltiples seeders. Indica los seeders a ejecutar con `call()`.

```php theme={null}
<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        $this->call([
            UserSeeder::class,
            PostSeeder::class,
            CommentSeeder::class,
        ]);
    }
}
```

Los seeders se ejecutan en el orden en el que se pasan a `call()`. Si hay restricciones de clave foránea, ordénalos de forma que las tablas referidas se sembren primero (por ejemplo, `users` → `posts`).

## Ejecución del seeder

### Ejecutar todos los seeders

```shell theme={null}
php artisan db:seed
```

Se invoca `DatabaseSeeder` y desde ahí se ejecutan en orden los seeders indicados en `call()`.

### Ejecutar solo un seeder concreto

Con la opción `--class` puedes indicar la clase seeder a ejecutar.

```shell theme={null}
php artisan db:seed --class=UserSeeder
```

## Ejecución junto con las migraciones

Añadiendo la opción `--seed` al comando `migrate:fresh`, recreas todas las tablas y luego ejecutas los seeders de una vez.

```shell theme={null}
php artisan migrate:fresh --seed
```

Para ejecutar solo un seeder concreto, usa la opción `--seeder`.

```shell theme={null}
php artisan migrate:fresh --seed --seeder=UserSeeder
```

<Warning>
  `migrate:fresh` elimina y recrea todas las tablas. Se pierden todos los datos existentes, así que no lo uses en producción.
</Warning>

## Ejecución en producción

Al intentar ejecutar el seeding en producción aparece un prompt de confirmación. Para ejecutarlo sin confirmación, usa `--force`.

```shell theme={null}
php artisan db:seed --force
```

<Warning>
  El seeding en producción puede sobrescribir o perder datos. Haz siempre una copia de seguridad antes de ejecutarlo.
</Warning>

## Supresión de eventos del modelo

Si quieres evitar que se disparen los eventos del modelo (`creating`, `created`, etc.) durante el seeding, usa el trait `WithoutModelEvents`.

```php theme={null}
<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use Illuminate\Database\Console\Seeds\WithoutModelEvents;

class DatabaseSeeder extends Seeder
{
    use WithoutModelEvents;

    public function run(): void
    {
        $this->call([
            UserSeeder::class,
        ]);
    }
}
```

También se aplica a los seeders hijos ejecutados a través de `call()`.

## Ejemplo práctico: seeder de una aplicación blog

Ejemplo para preparar los datos iniciales de un blog con usuarios y posts.

```php theme={null}
// database/seeders/UserSeeder.php
class UserSeeder extends Seeder
{
    public function run(): void
    {
        User::factory(10)->create();
    }
}

// database/seeders/PostSeeder.php
class PostSeeder extends Seeder
{
    public function run(): void
    {
        // Crea entre 2 y 5 posts para cada usuario
        User::all()->each(function ($user) {
            Post::factory(rand(2, 5))->create([
                'user_id' => $user->id,
            ]);
        });
    }
}

// database/seeders/DatabaseSeeder.php
class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        $this->call([
            UserSeeder::class,
            PostSeeder::class, // Se ejecuta tras users
        ]);
    }
}
```

Cómo se ejecuta:

```shell theme={null}
php artisan migrate:fresh --seed
```

## Próximos pasos

<Card title="Introducción a Eloquent" icon="database" href="/es/eloquent">
  Aprende a obtener y manipular con Eloquent ORM los datos introducidos por los seeders.
</Card>


## Related topics

- [Migraciones de base de datos](/es/migrations.md)
- [Configuración de la base de datos](/es/database.md)
- [Pruebas de base de datos](/es/database-testing.md)
- [Actualización de Laravel 9 a 10](/es/blog/upgrade-9-to-10.md)
- [Concurrencia](/es/concurrency.md)