Artisan la línea de comandos de Laravel

▶

Laravel dispone de una línea de comandos (CLI) sencilla y muy potente conocida como artisan; artisan no es más que un archivo que se ubica en la raíz de nuestro proyecto con el nombre de "artisan" y permite ejecutar una serie de comandos preestablecidos; por supuesto, podemos extender los comandos que nos ofrece el propio framework programando comandos propios; pero este es otro tema; ya que conocemos como emplear las rutas en Laravel, vamos con Artisan, que en definitiva, podemos dividir los comandos que podemos emplear en tres grupos:

Comandos para generar archivos:

1. Crear migraciones, de esto hablaremos en otro capítulo, pero no son más que archivos que guardan la estructura de una tabla que el framework mapeara a la base de datos.
2. Generar seeds o semillas para datos de prueba.
3. Generar controladores y otros tipos de archivos.

Comandos para manejar procesos:

1. Levantar un servidor de desarrollo, por si no quieres emplear Apache u otros servidores soportados por el framework.
2. Ejecutar o devolver migraciones.
3. Limpiar caches.
4. Manejar la base de datos.
5. Ejecutar las migraciones y seeds.

Comandos para obtener información del proyecto:

1. Listado de comandos.
2. Listado de las rutas del proyecto.

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

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

El archivo artisan está en la raíz del proyecto y funciona como punto de entrada al sistema de comandos de Laravel.
Cada comando se ejecuta con php artisan nombre:comando, por ejemplo:

$ php artisan make:controller UserController

Así generas automáticamente un controlador. Esta facilidad fue lo que me hizo enamorarme de Laravel: todo se crea con una línea.

Diferencia entre PHP y Sail al ejecutar comandos

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

./vendor/bin/sail artisan

2. Cómo usar Artisan desde cero

Comenzar con Artisan es muy fácil.
El primer comando que debes probar es:

$ php artisan list

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

Crea un modelo y su migración asociada.

El sufijo -m indica que también debe generar la migración.

Te mostrará todos los comandos disponibles, divididos en categorías.

3. Comandos más utilizados de Artisan

Para que tengas una lista de los comandos; te recomiendo que la copies y la leas algunas veces al dia y te familiarices con estos comandos que son los más empleados al momento de desarrollar en Laravel:

1. php artisan make:controller: Para crear controladores.
2. php artisan make:migration: Para generar un archivo de migración.
3. php artisan migrate: Para generar una migración y relacionados como el rollback para devolver las migraciones.
4. php artisan make:model: Genera un modelo de Eloquent.

Comandos para manejar procesos:

• php artisan serve: levanta un servidor de desarrollo (útil si no usas Apache).
• php artisan migrate: ejecuta migraciones pendientes.
• php artisan db:seed: inserta datos de prueba.
• php artisan cache:clear: limpia la caché de la aplicación.

Comandos para obtener información:

• php artisan list: muestra todos los comandos disponibles.
• php artisan route:list: Para ver las rutas de la aplicación.
• php artisan config:show: muestra configuraciones específicas.

No te preocupes si no comprendes el propósito de estas funciones, más adelante veremos en detalle el funcionamiento de cada uno de estos elementos.

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.
Esto te permite automatizar procesos específicos de tu aplicación.

Estructura de un comando propio

$ php artisan make:command NombreDelComando

Este comando crea una clase dentro de app/Console/Commands.

Ahí defines la firma (nombre del comando) y la lógica que ejecutará.

Ejemplo práctico paso a paso

Imagina que necesitas eliminar logs antiguos:

$ php artisan make:command CleanLogs

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

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

Ahora puedes ejecutarlo:

$ php artisan clean:logs

Buenas prácticas

Usa nombres claros (sync:usuarios, export:pedidos).

Añade mensajes con $this->info() para mostrar resultados.

Documenta cada comando en tu README.

En mi caso, tengo comandos personalizados que sincronizan usuarios o limpian cachés específicas.
Es una forma de ahorrar tiempo y estandarizar tareas repetitivas.

▶

Los comandos de Artisan son una herramienta de línea de comandos que se incluye en Laravel que son extremadamente útiles para el desarrollo de nuestras aplicaciones en Laravel; su proposito en el desarrollo de software es bastante general y los podemos usar para diversas tareas, como la creación de controladores, componentes, generar modelos, datos de prueba, migraciones de bases de datos, ya sea para crear tablas, o remover las mismas o cambiar las tablas, ejecutar pruebas automatizadas y un largo etc; inclusive, cuando instalamos ciertos paquete para Laravel, pueden agregarse comandos adicionales.

Comandos útiles de artesano

Algunos de los comandos más utilizados son:

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

Con esto, podemos darnos cuenta de lo potente de artisan, en vez de (por ejemplo) crear un archivo, con su clase e importaciones para los modelos, podemos ejecutar un comando en su lugar y con esto generar el archivo correspondiente.

Los que nos lleva al proceso de crear nuestros propios comandos personalizados para Laravel lo cual resulta en un proceso bastante sencillo de realizar; la creación de comandos personalizados es fundamental para realizar cualquier tipo de operación que quieras automatizar mediante un comando, comandos como los de make:controller están a tu disposición para crear cualquier proceso: en esta entrada de manera demostrativa vamos a crear un usuario mediante un comando de artisan personalizado.

Crear la clase para ejecutar nuestros comandos

Tenemos un comando de artisan que nos permite crear el archivo en el cual podremos definir el proceso de nuestro comando, es decir, la lógica: para ello:

php artisan make:command CreateUserCommand

Este comando creará automáticamente un nuevo archivo de comando de Artisan listo para usar en la carpeta de app/Console/Commands el cual como puedes suponer, corresponde a una clase con una estructura que tenemos que seguir.

Generar la lógica de nuestro comando

Ejecutado el comando anterior, generará un archivo que consta de 4 partes:

1. El constructor de la clase: el la cual podemos inicializar alguna data
2. La función handle: En la cual definimos la lógica de nuestro comando, en nuestro caso, crear un usuario.
3. El parámetro signature: Que nos permite definir el comando
4. El parámetro description: En la cual podemos definir una descripción que aparece en la consola, to describe aquí lo que hace tu comandillo...

Nuestro archivo quedaría así, con el llamado a la clase User, el modelo 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 hacemos un:

$ php artisan list

Veras nuestro hermoso comando:

Y si lo ejecutamos:

php artisan user:create

En la base de datos veremos el resultado de nuestro usuario creado.

Parámetros opcionales en los comandos

Si quieres que por ejemplo la contraseña sea opcional, basta con indicar un ? en el parámetro en cuestión:

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

Parámetros con nombre

Puede que te interese colocar la opción de parámetros con nombre; es decir en algo como esto:

php artisan --name="andres"

En este caso, podemos agregar para si queremos verificar el usuario o no; en las opciones del parametros tienes que indicar un -- seguido del nombre del parámetro y luego un igual; si tenemos un parámetro verified:

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

A la final, nuestro código que da de la siguiente manera:

   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

Cuando tu proyecto crece, Artisan también te ayuda a mejorar el rendimiento.

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.

Optimizar rutas y autoload

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

Esto compila rutas y configuraciones en archivos estáticos, haciendo que tu aplicación se cargue más rápido.

Reiniciar servicios con Artisan

A veces, al cambiar código en producción, necesitas reiniciar colas o eventos:

$ php artisan queue:restart

Este comando me ha salvado en despliegues continuos: evita reiniciar manualmente procesos del servidor.

6. Errores comunes y cómo resolverlos con Artisan

Artisan no reconoce comandos

Si obtienes errores como “Command not defined”, ejecuta:

$ composer dump-autoload
$ php artisan optimize:clear

Problemas con migraciones o seeds

A veces olvidamos que la base de datos no está sincronizada. Solución:

$ php artisan migrate:fresh --seed

Esto recrea toda la estructura y vuelve a poblarla con datos.

Solución rápida con cache:clear

Nunca subestimes este comando. Me ha resuelto decenas de errores misteriosos:

$ php artisan cache:clear

7. Conclusión y recursos recomendados

Qué aprendiste sobre Artisan

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 y rápida.

No te preocupes si al principio no recuerdas todos los comandos.
Con el tiempo los interiorizarás. En mi experiencia, la práctica diaria es el mejor maestro.

Preguntas frecuentes sobre Artisan en Laravel

1. ¿Qué es Artisan y para qué sirve?
Es la interfaz de comandos de Laravel, usada para crear, ejecutar y administrar tareas del framework.

2. ¿Cuáles son los comandos más usados?
make:controller, migrate, serve, route:list, cache:clear.

3. ¿Cómo creo un comando personalizado?
Con php artisan make:command NombreDelComando y definiendo la lógica en handle().

4. ¿Qué diferencia hay entre php artisan y sail artisan?
El primero usa tu instalación local de PHP; el segundo se ejecuta dentro del contenedor Docker de Laravel Sail.

5. ¿Cómo limpiar la caché de la aplicación?
Ejecuta php artisan cache:clear o php artisan optimize:clear.

El siguiente paso, es seguir trabajando con formularios y conocer como implementar el upload o carga de archivos en Laravel.