Introducción

Artisan es la interfaz de línea de comandos incluida con Laravel. Artisan existe en la raíz de tu aplicación como el script artisan y proporciona una serie de comandos útiles que pueden asistirte mientras construyes tu aplicación. Para ver una lista de todos los comandos disponibles de Artisan, puedes usar el comando list:

php artisan list

Cada comando también incluye una pantalla de «ayuda» que muestra y describe los argumentos y opciones disponibles del comando. Para ver una pantalla de ayuda, precede el nombre del comando con help:

php artisan help migrate

Laravel Sail

Si estás utilizando Laravel Sail como tu entorno de desarrollo local, recuerda usar la línea de comandos de sail para invocar comandos de Artisan. Sail ejecutará tus comandos de Artisan dentro de los contenedores Docker de tu aplicación:

./vendor/bin/sail artisan list

Tinker (REPL)

Laravel Tinker es un poderoso REPL para el framework Laravel, impulsado por el paquete PsySH.

Instalación

Todas las aplicaciones Laravel incluyen Tinker por defecto. Sin embargo, puedes instalar Tinker usando Composer si lo has eliminado previamente de tu aplicación:

composer require laravel/tinker

¿Buscas recarga en caliente, edición de código en varias líneas y autocompletado al interactuar con tu aplicación Laravel? ¡Echa un vistazo a Tinkerwell!

Uso

Tinker te permite interactuar con toda tu aplicación Laravel en la línea de comandos, incluyendo tus modelos Eloquent, trabajos, eventos y más. Para entrar en el entorno de Tinker, ejecuta el comando tinker de Artisan:

php artisan tinker

Puedes publicar el archivo de configuración de Tinker usando el comando vendor:publish:

php artisan vendor:publish --provider="Laravel\Tinker\TinkerServiceProvider"

La función auxiliar dispatch y el método dispatch en la clase Dispatchable dependen de la recolección de basura para colocar el trabajo en la cola. Por lo tanto, al usar tinker, debes usar Bus::dispatch o Queue::push para despachar trabajos.

Lista de Comandos Permitidos

Tinker utiliza una lista de «permitidos» para determinar qué comandos de Artisan se pueden ejecutar dentro de su shell. Por defecto, puedes ejecutar los comandos clear-compiled, down, env, inspire, migrate, migrate:install, up y optimize. Si deseas permitir más comandos, puedes agregarlos al array commands en tu archivo de configuración tinker.php:

'commands' => [
    // App\Console\Commands\ExampleCommand::class,
],

Clases Que No Deben Ser Alias

Normalmente, Tinker alias automáticamente las clases a medida que interactúas con ellas en Tinker. Sin embargo, es posible que desees no alias algunas clases. Puedes lograr esto listando las clases en el array dont_alias de tu archivo de configuración tinker.php:

'dont_alias' => [
    App\Models\User::class,
],

Escribiendo Comandos

Además de los comandos proporcionados con Artisan, puedes construir tus propios comandos personalizados. Los comandos se almacenan típicamente en el directorio app/Console/Commands; sin embargo, eres libre de elegir tu propia ubicación de almacenamiento siempre que tus comandos puedan ser cargados por Composer.

Generando Comandos

Para crear un nuevo comando, puedes usar el comando make:command de Artisan. Este comando creará una nueva clase de comando en el directorio app/Console/Commands. No te preocupes si este directorio no existe en tu aplicación: se creará la primera vez que ejecutes el comando make:command de Artisan:

php artisan make:command SendEmails

Estructura del Comando

Después de generar tu comando, debes definir valores apropiados para las propiedades signature y description de la clase. Estas propiedades se usarán al mostrar tu comando en la pantalla de lista. La propiedad signature también te permite definir las expectativas de entrada de tu comando. El método handle se llamará cuando se ejecute tu comando. Puedes colocar la lógica de tu comando en este método.

Veamos un ejemplo de comando. Ten en cuenta que podemos solicitar cualquier dependencia que necesitemos a través del método handle del comando. El contenedor de servicios de Laravel inyectará automáticamente todas las dependencias que estén indicadas en la firma del método:

<?php

namespace App\Console\Commands;

use App\Models\User;
use App\Support\DripEmailer;
use Illuminate\Console\Command;

class SendEmails extends Command
{
    /**
     * El nombre y la firma del comando de consola.
     *
     * @var string
     */
    protected $signature = 'mail:send {user}';

    /**
     * La descripción del comando de consola.
     *
     * @var string
     */
    protected $description = 'Enviar un correo electrónico de marketing a un usuario';

    /**
     * Ejecutar el comando de consola.
     */
    public function handle(DripEmailer $drip): void
    {
        $drip->send(User::find($this->argument('user')));
    }
}

Para una mayor reutilización del código, es una buena práctica mantener tus comandos de consola ligeros y dejar que deleguen a los servicios de la aplicación para realizar sus tareas. En el ejemplo anterior, observa que inyectamos una clase de servicio para hacer el «trabajo pesado» de enviar los correos electrónicos.

Códigos de Salida

Si no se devuelve nada del método handle y el comando se ejecuta correctamente, el comando saldrá con un código de salida 0, indicando éxito. Sin embargo, el método handle puede opcionalmente devolver un entero para especificar manualmente el código de salida del comando:

$this->error('Algo salió mal.');
 
return 1;

Si deseas «fallar» el comando desde cualquier método dentro del comando, puedes utilizar el método fail. El método fail terminará inmediatamente la ejecución del comando y devolverá un código de salida de 1:

$this->fail('Algo salió mal.');

Comandos de Cierre

Los comandos basados en cierres proporcionan una alternativa a la definición de comandos de consola como clases. De la misma manera que los cierres de rutas son una alternativa a los controladores, piensa en los cierres de comandos como una alternativa a las clases de comandos.

Aunque el archivo routes/console.php no define rutas HTTP, define puntos de entrada basados en consola (rutas) en tu aplicación. Dentro de este archivo, puedes definir todos tus comandos de consola basados en cierres usando el método Artisan::command. El método command acepta dos argumentos: la firma del comando y un cierre que recibe los argumentos y opciones del comando:

Artisan::command('mail:send {user}', function (string $user) {
    $this->info("Enviando correo a: {$user}!");
});

El cierre está vinculado a la instancia subyacente del comando, por lo que tienes acceso completo a todos los métodos auxiliares a los que normalmente podrías acceder en una clase de comando completa.

Dependencias con Type-Hinting

Además de recibir los argumentos y opciones de tu comando, los cierres de comandos también pueden indicar dependencias adicionales que te gustaría resolver del contenedor de servicios:

use App\Models\User;
use App\Support\DripEmailer;
 
Artisan::command('mail:send {user}', function (DripEmailer $drip, string $user) {
    $drip->send(User::find($user));
});

Descripciones de Comandos de Cierre

Al definir un comando basado en cierres, puedes usar el método purpose para agregar una descripción al comando. Esta descripción se mostrará cuando ejecutes los comandos php artisan list o php artisan help:

Artisan::command('mail:send {user}', function (string $user) {
    // ...
})->purpose('Enviar un correo electrónico de marketing a un usuario');

Comandos Aislables

Para utilizar esta función, tu aplicación debe estar utilizando el controlador de caché memcached, redis, dynamodb, database, file o array como el controlador de caché predeterminado de tu aplicación. Además, todos los servidores deben estar comunicándose con el mismo servidor de caché central.

A veces puedes desear asegurarte de que solo una instancia de un comando pueda ejecutarse a la vez. Para lograr esto, puedes implementar la interfaz Illuminate\Contracts\Console\Isolatable en tu clase de comando:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Contracts\Console\Isolatable;

class SendEmails extends Command implements Isolatable
{
    // ...
}

Cuando un comando está marcado como Isolatable, Laravel agregará automáticamente una opción --isolated al comando. Cuando el comando se invoca con esa opción, Laravel se asegurará de que no haya otras instancias de ese comando ya en ejecución. Laravel logra esto intentando adquirir un bloqueo atómico utilizando el controlador de caché predeterminado de tu aplicación. Si otras instancias del comando están en ejecución, el comando no se ejecutará; sin embargo, el comando aún saldrá con un código de estado de salida exitoso:

php artisan mail:send 1 --isolated

Si deseas especificar el código de estado de salida que el comando debe devolver si no puede ejecutarse, puedes proporcionar el código de estado deseado a través de la opción isolated:

php artisan mail:send 1 --isolated=12

ID de Bloqueo

Por defecto, Laravel usará el nombre del comando para generar la clave de cadena que se utiliza para adquirir el bloqueo atómico en la caché de tu aplicación. Sin embargo, puedes personalizar esta clave definiendo un método isolatableId en tu clase de comando de Artisan, lo que te permite integrar los argumentos u opciones del comando en la clave:

/**
 * Obtener el ID aislable para el comando.
 */
public function isolatableId(): string
{
    return $this->argument('user');
}

Tiempo de Expiración del Bloqueo

Por defecto, los bloqueos de aislamiento expiran después de que el comando haya terminado. O, si el comando se interrumpe y no puede terminar, el bloqueo expirará después de una hora. Sin embargo, puedes ajustar el tiempo de expiración del bloqueo definiendo un método isolationLockExpiresAt en tu comando:

use DateTimeInterface;
use DateInterval;
 
/**
 * Determinar cuándo expira un bloqueo de aislamiento para el comando.
 */
public function isolationLockExpiresAt(): DateTimeInterface|DateInterval
{
    return now()->addMinutes(5);
}

Definiendo Expectativas de Entrada

Al escribir comandos de consola, es común recopilar entradas del usuario a través de argumentos u opciones. Laravel hace que sea muy conveniente definir la entrada que esperas del usuario utilizando la propiedad signature en tus comandos. La propiedad signature te permite definir el nombre, los argumentos y las opciones para el comando en una sola sintaxis expresiva, similar a una ruta.

Argumentos

Todos los argumentos y opciones proporcionados por el usuario están envueltos en llaves. En el siguiente ejemplo, el comando define un argumento requerido: user:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send {user}';

También puedes hacer que los argumentos sean opcionales o definir valores predeterminados para los argumentos:

// Argumento opcional...
'mail:send {user?}'
 
// Argumento opcional con valor predeterminado...
'mail:send {user=foo}'

Opciones

Las opciones, como los argumentos, son otra forma de entrada del usuario. Las opciones están precedidas por dos guiones (–) cuando se proporcionan a través de la línea de comandos. Hay dos tipos de opciones: aquellas que reciben un valor y aquellas que no. Las opciones que no reciben un valor sirven como un «interruptor» booleano. Veamos un ejemplo de este tipo de opción:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send {user} {--queue}';

En este ejemplo, el interruptor --queue puede especificarse al llamar al comando Artisan. Si se pasa el interruptor --queue, el valor de la opción será true. De lo contrario, el valor será false:

php artisan mail:send 1 --queue

Opciones con Valores

A continuación, veamos una opción que espera un valor. Si el usuario debe especificar un valor para una opción, debes agregar un signo = al nombre de la opción:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send {user} {--queue=}';

En este ejemplo, el usuario puede pasar un valor para la opción de la siguiente manera. Si la opción no se especifica al invocar el comando, su valor será null:

php artisan mail:send 1 --queue=default

Puedes asignar valores predeterminados a las opciones especificando el valor predeterminado después del nombre de la opción. Si el usuario no pasa ningún valor de opción, se utilizará el valor predeterminado:

'mail:send {user} {--queue=default}'

Atajos de Opción

Para asignar un atajo al definir una opción, puedes especificarlo antes del nombre de la opción y usar el carácter | como delimitador para separar el atajo del nombre completo de la opción:

'mail:send {user} {--Q|queue}'

Al invocar el comando en tu terminal, los atajos de opción deben estar precedidos por un solo guion y no se debe incluir el carácter = al especificar un valor para la opción:

php artisan mail:send 1 -Qdefault

Arrays de Entrada

Si deseas definir argumentos u opciones para esperar múltiples valores de entrada, puedes usar el carácter *. Primero, veamos un ejemplo que especifica tal argumento:

'mail:send {user*}'

Al llamar a este método, los argumentos del usuario pueden pasarse en orden a la línea de comandos. Por ejemplo, el siguiente comando establecerá el valor de user en un array con 1 y 2 como sus valores:

php artisan mail:send 1 2

Este carácter * se puede combinar con una definición de argumento opcional para permitir cero o más instancias de un argumento:

'mail:send {user?*}'

Arrays de Opción

Al definir una opción que espera múltiples valores de entrada, cada valor de opción pasado al comando debe estar precedido por el nombre de la opción:

'mail:send {--id=*}'

Tal comando puede invocarse pasando múltiples argumentos --id:

php artisan mail:send --id=1 --id=2

Descripciones de Entrada

Puedes asignar descripciones a los argumentos y opciones de entrada separando el nombre del argumento de la descripción usando dos puntos. Si necesitas un poco más de espacio para definir tu comando, siéntete libre de distribuir la definición en varias líneas:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send
                        {user : El ID del usuario}
                        {--queue : Si el trabajo debe ser en cola}';

Solicitando Entrada Faltante

Si tu comando contiene argumentos requeridos, el usuario recibirá un mensaje de error cuando no se proporcionen. Alternativamente, puedes configurar tu comando para solicitar automáticamente al usuario cuando falten argumentos requeridos implementando la interfaz PromptsForMissingInput:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Contracts\Console\PromptsForMissingInput;

class SendEmails extends Command implements PromptsForMissingInput
{
    /**
     * El nombre y la firma del comando de consola.
     *
     * @var string
     */
    protected $signature = 'mail:send {user}';

    // ...
}

Si Laravel necesita recopilar un argumento requerido del usuario, automáticamente le preguntará al usuario por el argumento formulando inteligentemente la pregunta usando el nombre o la descripción del argumento. Si deseas personalizar la pregunta utilizada para recopilar el argumento requerido, puedes implementar el método promptForMissingArgumentsUsing, devolviendo un array de preguntas claveadas por los nombres de los argumentos:

/**
 * Solicitar argumentos de entrada faltantes usando las preguntas devueltas.
 *
 * @return array<string, string>
 */
protected function promptForMissingArgumentsUsing(): array
{
    return [
        'user' => '¿Qué ID de usuario debe recibir el correo?',
    ];
}

También puedes proporcionar texto de marcador de posición usando una tupla que contenga la pregunta y el marcador de posición:

return [
    'user' => ['¿Qué ID de usuario debe recibir el correo?', 'Ej. 123'],
];

Si deseas tener control total sobre el mensaje, puedes proporcionar un cierre que debe solicitar al usuario y devolver su respuesta:

use App\Models\User;
use function Laravel\Prompts\search;

// ...

return [
    'user' => fn () => search(
        label: 'Buscar un usuario:',
        placeholder: 'Ej. Taylor Otwell',
        options: fn ($value) => strlen($value) > 0
            ? User::where('name', 'like', "%{$value}%")->pluck('name', 'id')->all()
            : []
    ),
];

La documentación completa de Laravel Prompts incluye información adicional sobre los mensajes disponibles y su uso.

Si deseas solicitar al usuario que seleccione o ingrese opciones, puedes incluir mensajes en el método handle de tu comando. Sin embargo, si solo deseas solicitar al usuario cuando también se le haya solicitado automáticamente argumentos faltantes, entonces puedes implementar el método afterPromptingForMissingArguments:

use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use function Laravel\Prompts\confirm;

// ...

/**
 * Realizar acciones después de que el usuario haya sido solicitado por argumentos faltantes.
 */
protected function afterPromptingForMissingArguments(InputInterface $input, OutputInterface $output): void
{
    $input->setOption('queue', confirm(
        label: '¿Te gustaría poner el correo en cola?',
        default: $this->option('queue')
    ));
}

Entrada/Salida de Comandos

Recuperando Entrada

Mientras tu comando se está ejecutando, probablemente necesitarás acceder a los valores de los argumentos y opciones aceptados por tu comando. Para hacerlo, puedes usar los métodos argument y option. Si un argumento u opción no existe, se devolverá null:

/**
 * Ejecutar el comando de consola.
 */
public function handle(): void
{
    $userId = $this->argument('user');
}

Si necesitas recuperar todos los argumentos como un array, llama al método arguments:

$arguments = $this->arguments();

Las opciones pueden recuperarse tan fácilmente como los argumentos usando el método option. Para recuperar todas las opciones como un array, llama al método options:

// Recuperar una opción específica...
$queueName = $this->option('queue');
 
// Recuperar todas las opciones como un array...
$options = $this->options();

Solicitando Entrada

Laravel Prompts es un paquete PHP para agregar formularios hermosos y fáciles de usar a tus aplicaciones de línea de comandos, con características similares a las de un navegador, incluyendo texto de marcador de posición y validación.

Además de mostrar salida, también puedes pedir al usuario que proporcione entrada durante la ejecución de tu comando. El método ask solicitará al usuario con la pregunta dada, aceptará su entrada y luego devolverá la entrada del usuario a tu comando:

/**
 * Ejecutar el comando de consola.
 */
public function handle(): void
{
    $name = $this->ask('¿Cuál es tu nombre?');
 
    // ...
}

El método ask también acepta un segundo argumento opcional que especifica el valor predeterminado que debe devolverse si no se proporciona ninguna entrada del usuario:

$name = $this->ask('¿Cuál es tu nombre?', 'Taylor');

El método secret es similar a ask, pero la entrada del usuario no será visible mientras escribe en la consola. Este método es útil cuando se solicita información sensible como contraseñas:

$password = $this->secret('¿Cuál es la contraseña?');

Solicitando Confirmación

Si necesitas pedir al usuario una simple confirmación de «sí o no», puedes usar el método confirm. Por defecto, este método devolverá false. Sin embargo, si el usuario ingresa y o yes en respuesta a la solicitud, el método devolverá true:

if ($this->confirm('¿Deseas continuar?')) {
    // ...
}

Si es necesario, puedes especificar que la solicitud de confirmación debe devolver true por defecto pasando true como segundo argumento al método confirm:

if ($this->confirm('¿Deseas continuar?', true)) {
    // ...
}

Autocompletado

El método anticipate se puede usar para proporcionar autocompletado para posibles opciones. El usuario aún puede proporcionar cualquier respuesta, independientemente de las sugerencias de autocompletado:

$name = $this->anticipate('¿Cuál es tu nombre?', ['Taylor', 'Dayle']);

Alternativamente, puedes pasar un cierre como segundo argumento al método anticipate. El cierre se llamará cada vez que el usuario escriba un carácter de entrada. El cierre debe aceptar un parámetro de cadena que contenga la entrada del usuario hasta el momento y devolver un array de opciones para el autocompletado:

$name = $this->anticipate('¿Cuál es tu dirección?', function (string $input) {
    // Devolver opciones de autocompletado...
});

Preguntas de Opción Múltiple

Si necesitas dar al usuario un conjunto predefinido de opciones al hacer una pregunta, puedes usar el método choice. Puedes establecer el índice del array del valor predeterminado que se devolverá si no se elige ninguna opción pasando el índice como tercer argumento al método:

$name = $this->choice(
    '¿Cuál es tu nombre?',
    ['Taylor', 'Dayle'],
    $defaultIndex
);

Además, el método choice acepta argumentos opcionales cuarto y quinto para determinar el número máximo de intentos para seleccionar una respuesta válida y si se permiten múltiples selecciones:

$name = $this->choice(
    '¿Cuál es tu nombre?',
    ['Taylor', 'Dayle'],
    $defaultIndex,
    $maxAttempts = null,
    $allowMultipleSelections = false
);

Escribiendo Salida

Para enviar salida a la consola, puedes usar los métodos line, info, comment, question, warn y error. Cada uno de estos métodos usará colores ANSI apropiados para su propósito. Por ejemplo, mostremos alguna información general al usuario. Típicamente, el método info se mostrará en la consola como texto de color verde:

/**
 * Ejecutar el comando de consola.
 */
public function handle(): void
{
    // ...
 
    $this->info('¡El comando fue exitoso!');
}

Para mostrar un mensaje de error, usa el método error. El texto del mensaje de error se muestra típicamente en rojo:

$this->error('¡Algo salió mal!');

Puedes usar el método line para mostrar texto simple y sin color:

$this->line('Mostrar esto en la pantalla');

Puedes usar el método newLine para mostrar una línea en blanco:

// Escribir una sola línea en blanco...
$this->newLine();
 
// Escribir tres líneas en blanco...
$this->newLine(3);

Tablas

El método table facilita el formato correcto de múltiples filas/columnas de datos. Todo lo que necesitas hacer es proporcionar los nombres de las columnas y los datos para la tabla y Laravel calculará automáticamente el ancho y la altura apropiados de la tabla para ti:

use App\Models\User;
 
$this->table(
    ['Nombre', 'Correo Electrónico'],
    User::all(['name', 'email'])->toArray()
);

Barras de Progreso

Para tareas de larga duración, puede ser útil mostrar una barra de progreso que informe a los usuarios cuán completa está la tarea. Usando el método withProgressBar, Laravel mostrará una barra de progreso y avanzará su progreso por cada iteración sobre un valor iterable dado:

use App\Models\User;
 
$users = $this->withProgressBar(User::all(), function (User $user) {
    $this->performTask($user);
});

A veces, puedes necesitar más control manual sobre cómo se avanza una barra de progreso. Primero, define el número total de pasos que el proceso iterará. Luego, avanza la barra de progreso después de procesar cada elemento:

$users = App\Models\User::all();
 
$bar = $this->output->createProgressBar(count($users));
 
$bar->start();
 
foreach ($users as $user) {
    $this->performTask($user);
 
    $bar->advance();
}
 
$bar->finish();

Para opciones más avanzadas, consulta la documentación del componente Symfony Progress Bar.

Registrando Comandos

Por defecto, Laravel registra automáticamente todos los comandos dentro del directorio app/Console/Commands. Sin embargo, puedes instruir a Laravel para que escanee otros directorios en busca de comandos de Artisan usando el método withCommands en el archivo bootstrap/app.php de tu aplicación:

->withCommands([
    __DIR__.'/../app/Domain/Orders/Commands',
])

Si es necesario, también puedes registrar comandos manualmente proporcionando el nombre de la clase del comando al método withCommands:

use App\Domain\Orders\Commands\SendEmails;
 
->withCommands([
    SendEmails::class,
])

Cuando Artisan se inicia, todos los comandos en tu aplicación serán resueltos por el contenedor de servicios y registrados con Artisan.

Ejecutando Comandos Programáticamente

A veces puedes desear ejecutar un comando de Artisan fuera de la CLI. Por ejemplo, puedes desear ejecutar un comando de Artisan desde una ruta o controlador. Puedes usar el método call en la fachada Artisan para lograr esto. El método call acepta el nombre de la firma del comando o el nombre de la clase como su primer argumento, y un array de parámetros del comando como el segundo argumento. Se devolverá el código de salida:

use Illuminate\Support\Facades\Artisan;
 
Route::post('/user/{user}/mail', function (string $user) {
    $exitCode = Artisan::call('mail:send', [
        'user' => $user, '--queue' => 'default'
    ]);
 
    // ...
});

Alternativamente, puedes pasar el comando completo de Artisan al método call como una cadena:

Artisan::call('mail:send 1 --queue=default');

Pasando Valores de Array

Si tu comando define una opción que acepta un array, puedes pasar un array de valores a esa opción:

use Illuminate\Support\Facades\Artisan;
 
Route::post('/mail', function () {
    $exitCode = Artisan::call('mail:send', [
        '--id' => [5, 13]
    ]);
});

Pasando Valores Booleanos

Si necesitas especificar el valor de una opción que no acepta valores de cadena, como el flag --force en el comando migrate:refresh, debes pasar true o false como el valor de la opción:

$exitCode = Artisan::call('migrate:refresh', [
    '--force' => true,
]);

Encolando Comandos de Artisan

Usando el método queue en la fachada Artisan, incluso puedes encolar comandos de Artisan para que se procesen en segundo plano por tus trabajadores de cola. Antes de usar este método, asegúrate de haber configurado tu cola y estar ejecutando un listener de cola:

use Illuminate\Support\Facades\Artisan;
 
Route::post('/user/{user}/mail', function (string $user) {
    Artisan::queue('mail:send', [
        'user' => $user, '--queue' => 'default'
    ]);
 
    // ...
});

Usando los métodos onConnection y onQueue, puedes especificar la conexión o cola a la que debe enviarse el comando de Artisan:

Artisan::queue('mail:send', [
    'user' => 1, '--queue' => 'default'
])->onConnection('redis')->onQueue('commands');

Llamando Comandos Desde Otros Comandos

A veces puedes desear llamar a otros comandos desde un comando de Artisan existente. Puedes hacerlo usando el método call. Este método call acepta el nombre del comando y un array de argumentos/opciones del comando:

/**
 * Ejecutar el comando de consola.
 */
public function handle(): void
{
    $this->call('mail:send', [
        'user' => 1, '--queue' => 'default'
    ]);
 
    // ...
}

Si deseas llamar a otro comando de consola y suprimir toda su salida, puedes usar el método callSilently. El método callSilently tiene la misma firma que el método call:

$this->callSilently('mail:send', [
    'user' => 1, '--queue' => 'default'
]);

Manejo de Señales

Como sabrás, los sistemas operativos permiten que se envíen señales a los procesos en ejecución. Por ejemplo, la señal SIGTERM es cómo los sistemas operativos piden a un programa que termine. Si deseas escuchar señales en tus comandos de consola de Artisan y ejecutar código cuando ocurran, puedes usar el método trap:

/**
 * Ejecutar el comando de consola.
 */
public function handle(): void
{
    $this->trap(SIGTERM, fn () => $this->shouldKeepRunning = false);
 
    while ($this->shouldKeepRunning) {
        // ...
    }
}

Para escuchar múltiples señales a la vez, puedes proporcionar un array de señales al método trap:

$this->trap([SIGTERM, SIGQUIT], function (int $signal) {
    $this->shouldKeepRunning = false;
 
    dump($signal); // SIGTERM / SIGQUIT
});

Personalización de Stubs

Los comandos make de la consola Artisan se utilizan para crear una variedad de clases, como controladores, trabajos, migraciones y pruebas. Estas clases se generan utilizando archivos «stub» que se completan con valores basados en tu entrada. Sin embargo, puedes querer hacer pequeños cambios en los archivos generados por Artisan. Para lograr esto, puedes usar el comando stub:publish para publicar los stubs más comunes en tu aplicación para que puedas personalizarlos:

php artisan stub:publish

Los stubs publicados estarán ubicados dentro de un directorio stubs en la raíz de tu aplicación. Cualquier cambio que realices en estos stubs se reflejará cuando generes sus clases correspondientes usando los comandos make de Artisan.

Eventos

Artisan despacha tres eventos al ejecutar comandos: Illuminate\Console\Events\ArtisanStarting, Illuminate\Console\Events\CommandStarting y Illuminate\Console\Events\CommandFinished. El evento ArtisanStarting se despacha inmediatamente cuando Artisan comienza a ejecutarse. Luego, el evento CommandStarting se despacha inmediatamente antes de que se ejecute un comando. Finalmente, el evento CommandFinished se despacha una vez que un comando termina de ejecutarse.