¿Qué es Artisan en Laravel? Guía completa de comandos php artisan

Laravel dispone de una interfaz de línea de comandos (CLI) sencilla y muy potente conocida como Artisan. En términos simples, Artisan no es más que un archivo llamado artisan que se ubica en la raíz de tu proyecto y que sirve como punto de entrada para ejecutar una serie de comandos preestablecidos por el propio framework. Por supuesto, también puedes extender esos comandos programando los tuyos propios, pero eso lo veremos más adelante. Por ahora, y dado que ya conocemos las rutas en Laravel, vamos con Artisan. En líneas generales, los comandos que ofrece se pueden dividir en tres grandes grupos:

Comandos para generar archivos:

1. Crear migraciones: archivos que guardan la estructura de una tabla que el framework mapea a la base de datos (las veremos en detalle en otro capítulo).
2. Generar seeds o semillas para poblar la base de datos con datos de prueba.
3. Generar controladores, modelos, middlewares y otros tipos de archivos del framework.

Comandos para manejar procesos:

1. Levantar un servidor de desarrollo integrado, útil si no quieres configurar Apache u otros servidores externos.
2. Ejecutar o revertir migraciones.
3. Limpiar cachés de configuración, rutas y vistas.
4. Gestionar la base de datos (seeders, migraciones, rollbacks).
5. Ejecutar las migraciones y seeds de forma combinada.

Comandos para obtener información del proyecto:

1. Listado de todos los comandos disponibles.
2. Listado de las rutas registradas en el proyecto.

Si estás comenzando con Laravel o quieres aprovechar al máximo esta herramienta, aquí te explico cómo usar Artisan paso a paso, con ejemplos prácticos y consejos reales de desarrollo.

1. Qué es Artisan en Laravel y por qué es tan útil

El archivo artisan vive en la raíz del proyecto y funciona como el punto de entrada al sistema de comandos de Laravel. Para ejecutarlo, siempre utilizas la estructura php artisan nombre:comando, por ejemplo:

$ php artisan make:controller UserController

Con esa sola línea generas automáticamente un controlador completo con su estructura base. Esa sencillez fue, personalmente, una de las cosas que me enamoró de Laravel: lo que en otros frameworks requiere varios pasos, aquí se resuelve en segundos.

Diferencia entre php artisan y sail artisan

Si estás usando Laravel Sail (el entorno Docker oficial de Laravel) y no tienes PHP instalado directamente en tu sistema, deberás ejecutar los comandos de Artisan así:

./vendor/bin/sail artisan make:controller UserController

La diferencia es simple: php artisan usa el PHP de tu máquina local, mientras que sail artisan se ejecuta dentro del contenedor Docker. El resultado es el mismo; solo cambia el entorno de ejecución.

2. Cómo usar Artisan desde cero

Comenzar con Artisan es muy sencillo. El primer comando que deberías probar al abrir cualquier proyecto Laravel es:

$ php artisan list

Esto te mostrará todos los comandos disponibles, ordenados por categorías. Es la mejor forma de explorar qué ofrece el framework (y los paquetes instalados) sin tener que buscar en la documentación.

Estructura general de un comando Artisan

La estructura básica es siempre la misma:

$ php artisan comando:accion [opciones]

Por ejemplo:

$ php artisan make:model Producto -m

Este comando crea un modelo Producto y, gracias al sufijo -m, genera también su archivo de migración asociado de forma automática. Así de directo.

3. Comandos más utilizados de Artisan en Laravel

A continuación tienes los comandos de Artisan que más vas a usar en el día a día. Te recomiendo que los leas varias veces hasta familiarizarte con ellos; con la práctica los interiorizarás sin esfuerzo:

1. php artisan make:controller: Crea un nuevo controlador en app/Http/Controllers.
2. php artisan make:migration: Genera un archivo de migración para definir o modificar tablas en la base de datos.
3. php artisan migrate: Ejecuta las migraciones pendientes. Tiene variantes muy útiles como migrate:rollback para deshacer la última tanda de migraciones.
4. php artisan make:model: Genera un modelo de Eloquent. Combinado con la opción -mf también crea la migración y el factory de una sola vez.

Comandos para manejar procesos:

• php artisan serve: levanta un servidor de desarrollo en http://localhost:8000 (útil si no usas Apache o Nginx localmente).
• php artisan migrate: ejecuta todas las migraciones pendientes.
• php artisan db:seed: inserta datos de prueba definidos en los seeders.
• php artisan cache:clear: limpia la caché de la aplicación. Simple y salvavidas.

Comandos para obtener información:

• php artisan list: muestra todos los comandos disponibles, agrupados por categoría.
• php artisan route:list: muestra todas las rutas registradas en la aplicación, incluyendo método HTTP, URI, nombre y controlador asociado.
• php artisan config:show: muestra los valores de una configuración específica, por ejemplo php artisan config:show database.

No te preocupes si de momento no entiendes el propósito de cada uno; más adelante veremos en detalle el funcionamiento de cada elemento cuando lo necesitemos en el contexto correcto.

4. Crear tus propios comandos personalizados en Artisan

Una de las características más potentes de Artisan es que puedes crear tus propios comandos para automatizar cualquier proceso específico de tu aplicación: limpiar archivos temporales, sincronizar datos con una API externa, enviar notificaciones programadas, etc.

Estructura de un comando propio

Para generar la clase base de tu comando, ejecutas:

$ php artisan make:command NombreDelComando

Esto crea automáticamente una nueva clase dentro de app/Console/Commands, lista para que definas la firma del comando (su nombre en la terminal) y la lógica que ejecutará.

Ejemplo práctico: limpiar logs antiguos

Imagina que necesitas eliminar logs antiguos periódicamente. Primero generas el comando:

$ php artisan make:command CleanLogs

Luego, en el método handle() de la clase generada, añades la lógica:

public function handle() {
   File::cleanDirectory(storage_path('logs'));
   $this->info('Logs limpiados correctamente.');
}

Y ya puedes ejecutarlo desde la terminal cuando lo necesites:

$ php artisan clean:logs

Buenas prácticas al crear comandos personalizados

Usa nombres descriptivos para tus comandos (por ejemplo, sync:usuarios o export:pedidos), de modo que cualquiera que ejecute php artisan list entienda de un vistazo para qué sirve cada uno.

Añade mensajes de feedback con $this->info() para indicar el resultado, y usa $this->error() cuando algo falle. Esto hace que tus comandos sean mucho más informativos en producción.

Documenta cada comando personalizado en tu README o en la wiki del proyecto, sobre todo si trabajan en equipo.

En mi caso, tengo comandos personalizados que sincronizan usuarios o limpian cachés específicas de forma periódica. Es una excelente manera de ahorrar tiempo y estandarizar tareas repetitivas que de otro modo habría que hacer a mano.

Los comandos de Artisan son una herramienta de línea de comandos incluida en Laravel que resulta extremadamente útil durante el desarrollo. Su propósito es bastante amplio: creación de controladores, componentes, modelos, datos de prueba, migraciones de base de datos (para crear, modificar o eliminar tablas), ejecución de pruebas automatizadas y un largo etcétera. Incluso los paquetes de terceros para Laravel pueden registrar sus propios comandos Artisan al instalarse.

Comandos útiles de Artisan

Algunos de los comandos más utilizados son:

• php artisan make:model: Crea un nuevo modelo Eloquent.
• php artisan make:controller: Crea un nuevo controlador HTTP.
• php artisan make:migration: Crea un nuevo archivo de migración de base de datos.
• php artisan migrate: Ejecuta las migraciones pendientes.

Con esto podemos apreciar la potencia real de Artisan: en lugar de crear manualmente un archivo PHP, definir la clase, añadir las importaciones y estructurarlo correctamente, basta con ejecutar un comando y el framework genera todo eso por ti.

Esto nos lleva de forma natural a la creación de comandos personalizados, que es un proceso sorprendentemente sencillo. La creación de comandos propios es clave para automatizar cualquier tipo de operación recurrente en tu aplicación: igual que make:controller genera un controlador, tú puedes crear comandos que ejecuten cualquier proceso que necesites. En esta entrada, a modo de ejemplo, vamos a crear un usuario directamente desde un comando Artisan personalizado.

Crear la clase para nuestro comando personalizado

Artisan incluye un comando específico para generar la clase base del comando que quieres crear. Para el ejemplo del usuario, ejecutamos:

php artisan make:command CreateUserCommand

Esto genera automáticamente un nuevo archivo en app/Console/Commands. Como puedes suponer, ese archivo corresponde a una clase con una estructura predefinida que debemos completar.

Generar la lógica de nuestro comando

El archivo generado consta de cuatro partes fundamentales:

1. El constructor de la clase: donde podemos inyectar dependencias o inicializar datos.
2. El método handle(): aquí definimos la lógica del comando; en nuestro caso, crear un usuario.
3. La propiedad $signature: define el nombre con el que se invocará el comando desde la terminal.
4. La propiedad $description: una descripción corta que aparece al ejecutar php artisan list, para que quede claro qué hace el comando.

Nuestro archivo completo quedaría así, importando el modelo User para crear el usuario:

 <?php
namespace App\Console\Commands;
use App\Models\User;
use Illuminate\Support\Str;
use Illuminate\Console\Command;
class CreateUserCommand extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'user:create';
    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Comando para crear usuarios *-*';
    /**
     * Create a new command instance.
     *
     * @return void
     */
    public function __construct()
    {
        parent::__construct();
    }
    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        User::create([
            'name' => Str::random(8),
            'email' => Str::random(8).'@gmail.com',
            'password' => Str::random(12),
        ]);
        return 0;
    }
}

Si ahora ejecutamos:

$ php artisan list

Veremos nuestro nuevo comando listado junto al resto:

Y si lo ejecutamos:

php artisan user:create

En la base de datos veremos el resultado: un nuevo usuario creado.

Parámetros opcionales en los comandos

Si quieres que algún argumento sea opcional (por ejemplo, la contraseña), basta con añadir un ? después del nombre del parámetro en la $signature:

protected $signature = 'user:create {name} {password?}';

Parámetros con nombre (opciones)

También puedes definir opciones con nombre, que se pasan con el prefijo -- al ejecutar el comando. Por ejemplo, para indicar si el usuario debe quedar verificado o no:

php artisan user:create --name="andres"

Para habilitar esta opción en la firma del comando, la defines con -- seguido del nombre y un signo igual; si el parámetro se llama verified:

protected $signature = 'user:create {--verified=} {name} {password?}';

Con todo esto, el código final del método handle() quedaría así:

  protected $signature = 'user:create {--verified=} {name} {password?}';
  
  
      $name = $this->argument('name');
        $password = $this->argument('password');
        $email_verified_at = $this->option('verified') ? now() : null;
        User::create([
            'name' => $name ?? Str::random(8),
            'email' => Str::random(8).'@gmail.com',
            'password' => bcrypt($password  ??  Str::random(12)),
            'email_verified_at' => $email_verified_at,
        ]);

5. Comandos Artisan para optimizar tu aplicación Laravel

A medida que tu proyecto crece, Artisan también se convierte en tu aliado para mantener un buen rendimiento. Estos son los comandos que más uso en entornos productivos:

Limpiar caché y configuración

$ php artisan cache:clear
$ php artisan config:clear
$ php artisan route:clear
$ php artisan view:clear

Estos comandos eliminan archivos temporales que pueden causar comportamientos inesperados, especialmente tras despliegues o cambios en la configuración.

Optimizar rutas y autoload para producción

$ php artisan route:cache
$ php artisan config:cache
$ composer dump-autoload -o

Estos comandos compilan rutas y configuraciones en archivos estáticos, de modo que Laravel no tenga que reconstruirlos en cada petición. El resultado es una aplicación notablemente más rápida en producción.

Reiniciar colas de trabajo

Al cambiar código en producción, si usas colas de trabajo (Queue), los workers que están corriendo en segundo plano no recargan automáticamente el código nuevo. Para que lo hagan sin reiniciar manualmente el servidor, ejecutas:

$ php artisan queue:restart

Este comando me ha salvado en más de un despliegue continuo.

6. Rutas del proyecto con Artisan

Para inspeccionar todas las rutas registradas en tu proyecto Laravel, usa:

php artisan route:list

O su versión abreviada:

php artisan r:l

Ver solo las rutas de tu aplicación (sin las de terceros)

Cuando instalas paquetes como Telescope, Horizon o Fortify, estos registran sus propias rutas y pueden saturar el listado. Para ver únicamente las rutas de tu aplicación, añade la opción --except-vendor:

php artisan route:list --except-vendor

Con esto obtienes un listado limpio, sin las rutas generadas por paquetes de terceros.

7. Errores comunes y cómo resolverlos con Artisan

Artisan no reconoce un comando

Si obtienes un error como Command not defined, lo más probable es que el autoloader de PHP no esté actualizado. Ejecuta:

$ composer dump-autoload
$ php artisan optimize:clear

Problemas con migraciones o seeds

A veces la base de datos queda desincronizada respecto a las migraciones (por ejemplo, si modificaste una migración ya ejecutada). La solución más rápida en desarrollo es recrear toda la estructura:

$ php artisan migrate:fresh --seed

Esto elimina todas las tablas, ejecuta las migraciones desde cero y vuelve a poblar la base de datos con los seeders. Úsalo con precaución en producción: perderás todos los datos.

Solución rápida: cache:clear

Antes de desesperar ante un error misterioso, prueba siempre esto:

$ php artisan cache:clear

Personalmente, me ha resuelto decenas de errores extraños que no tenían ninguna explicación aparente. Es el equivalente al clásico "¿lo has apagado y encendido?"

8. Resumen de comandos Artisan esenciales

Qué aprendiste sobre Artisan en Laravel

Artisan es mucho más que un simple ejecutor de comandos.
Te permite automatizar, optimizar y mantener tu aplicación Laravel desde la terminal, de forma limpia, rápida y repetible.

No te preocupes si al principio no recuerdas todos los comandos.
Con el uso diario los irás interiorizando de forma natural. En mi experiencia, la práctica constante es el mejor maestro.

Preguntas frecuentes sobre Artisan en Laravel

1. ¿Qué es Artisan y para qué sirve?
   1. Es la interfaz de línea de comandos (CLI) de Laravel, utilizada para crear archivos del framework, ejecutar tareas de mantenimiento y administrar la aplicación sin necesidad de interfaz gráfica.
2. ¿Cuáles son los comandos Artisan más usados?
   1. make:controller, migrate, serve, route:list, cache:clear y db:seed.
3. ¿Cómo creo un comando personalizado en Artisan?
   1. Con php artisan make:command NombreDelComando y definiendo la lógica en el método handle() de la clase generada.
4. ¿Qué diferencia hay entre php artisan y sail artisan?
   1. El primero usa el PHP instalado en tu máquina local; el segundo ejecuta Artisan dentro del contenedor Docker de Laravel Sail. El resultado es idéntico, solo cambia el entorno.
5. ¿Cómo limpiar la caché de la aplicación?
   1. Ejecuta php artisan cache:clear para la caché de la aplicación, o php artisan optimize:clear para limpiar todas las cachés del framework de una sola vez.
6. ¿Cómo puedo saber más sobre un comando específico?
   1. Ejecuta php artisan help [nombre-del-comando] para ver todas sus opciones y argumentos disponibles. Es la forma más rápida de ser autodidacta con Artisan.
7. Veo el error Command not found o problemas con la versión de PHP.
   1. Es casi seguro que necesitas usar ./vendor/bin/sail artisan en lugar de php artisan, porque tu entorno de desarrollo corre dentro de Docker con Laravel Sail.

El siguiente paso es seguir avanzando con el framework y conocer cómo implementar el upload o carga de archivos en Laravel.