Tutorial - Laravel Console Starter

Passi per costruire un’app console con Laravel Console Starter. Impari a creare comandi, schedulare con GitHub Actions, inviare notifiche e vedi esempi pratici.

​

Introduzione

In questo tutorial costruirai un’applicazione Laravel con comandi Artisan personalizzati usando revolution/laravel-console-starter.

I vantaggi di usare questo starter kit:

• Setup rapido — puoi iniziare subito lo sviluppo di app console senza configurazioni complesse
• Ecosistema Laravel — puoi usare le funzionalità di Laravel come task scheduling, database e notifiche
• Comandi Artisan — con il potente sistema Artisan di Laravel puoi creare e gestire facilmente i tuoi comandi
• Facilità di test — puoi scrivere test per i comandi con il framework di testing di Laravel

​

Prerequisiti

Installa il seguente software.

• PHP ^8.3
• Composer (https://getcomposer.org/)
• Laravel Installer (composer global require laravel/installer)

​

Setup del progetto

1. Crea un nuovo progetto

   Esegui il seguente comando nel terminale.

   laravel new my-app --using=revolution/laravel-console-starter --no-interaction
   

   Viene creata la directory my-app e configurata la struttura base dell’app console.

   All’installazione vengono eseguite automaticamente le seguenti operazioni.

   • Generazione del file .env a partire da .env.example
   • Impostazione dell’application key con php artisan key:generate

   Struttura principale delle directory:

   my-app/
   ├── app/Console/Commands/   # I comandi personalizzati
   ├── .github/workflows/
   │   └── cron.yml            # Esempio di schedulazione GitHub Actions
   ├── config/                 # Configurazione dell'applicazione
   └── routes/console.php      # Registrazione dei comandi
   
2. Verifica la configurazione dell'ambiente

   Per impostazione predefinita, l’invio email è impostato sul log (MAIL_MAILER=log).

   Se ti serve un vero invio di email, configura nel file .env servizi come Mailgun, Postmark o SES.

​

Creazione di un comando console

1. Genera un comando

   Crea un nuovo comando con make:command di Artisan.

   php artisan make:command YourCommandName --command=your:command
   

   • YourCommandName — nome della classe del comando da creare (es.: SendDailyReport)
   • your:command — nome invocabile del comando (es.: report:send-daily)

   Viene generato app/Console/Commands/YourCommandName.php.

2. Implementa il comando

   Modifica il file generato per implementare la logica. Ecco un esempio “Hello World”.

   <?php
   
   namespace App\Console\Commands;
   
   use Illuminate\Console\Command;
   use Illuminate\Support\Facades\Log;
   
   class HelloWorldCommand extends Command
   {
       protected $signature = 'hello:world';
       protected $description = 'Displays a hello world message in the log';
   
       public function handle(): int
       {
           Log::info('Hello, World from Artisan Command!');
           $this->info('Hello, World message has been logged.');
           return Command::SUCCESS;
       }
   }
   

   In $signature definisci il nome invocabile del comando e scrivi la logica nel metodo handle().

3. Esegui il comando

   php artisan hello:world
   

   Dopo l’esecuzione, il messaggio viene stampato in storage/logs/laravel.log e in console.

​

Task scheduling con GitHub Actions

Usando GitHub Actions puoi eseguire comandi in modo periodico senza bisogno di cron sul server.

1. Controlla il file workflow

   Lo starter kit include .github/workflows/cron.yml già preconfigurato.

   name: cron
   
   on:
     schedule:
       - cron: '0 0 * * *'  # Ogni giorno a mezzanotte UTC
   
   jobs:
     cron:
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v6
         - uses: shivammathur/setup-php@v2
           with:
             php-version: 8.5
             coverage: none
         - run: composer install --no-dev -q
         - run: cp .env.example .env
         - run: php artisan key:generate
         - run: php artisan inspire
   
2. Cambia il comando

   Sostituisci php artisan inspire con il tuo comando.

   - name: Run Command
     run: php artisan your:command
   

   Per eseguire più comandi:

   - name: Run Commands
     run: |
       php artisan first:command
       php artisan second:command
   
3. Regola la pianificazione

   Modifica l’espressione cron per impostare la frequenza.

   Espressione cron	Quando
   0 0 * * *	Ogni giorno alle 00:00 UTC
   0 */6 * * *	Ogni 6 ore
   0 0 * * 1	Ogni lunedì a mezzanotte

4. Gestisci le informazioni sensibili come secret

   Le informazioni sensibili come API key e password vanno tenute nei secret della repository GitHub.

   Aggiungi i secret in Settings > Secrets and variables > Actions della repository GitHub e referenziali nel workflow.

   - name: Run Command with Secrets
     run: php artisan your:command
     env:
       API_KEY: ${{ secrets.API_KEY }}
       DB_PASSWORD: ${{ secrets.DATABASE_PASSWORD }}
   

​

Notifiche

Puoi notificare via email, Slack, ecc. il risultato o gli errori di un comando.

1. Crea una classe di notifica

   php artisan make:notification TaskCompleted
   

   Viene generato app/Notifications/TaskCompleted.php.

2. Configura il canale di notifica

   Se necessario, pubblica i file di configurazione.

   php artisan config:publish mail
   php artisan config:publish services
   
3. Invia la notifica dal comando

   <?php
   
   namespace App\Console\Commands;
   
   use App\Notifications\TaskCompleted;
   use Illuminate\Console\Command;
   use Illuminate\Support\Facades\Notification;
   
   class ProcessDataCommand extends Command
   {
       protected $signature = 'data:process';
       protected $description = 'Elabora i dati e invia una notifica al completamento';
   
       public function handle()
       {
           $this->info('Elaborazione dei dati in corso...');
   
           // Logica di elaborazione...
   
           Notification::route('mail', '[e-mail]')
               ->notify(new TaskCompleted('Elaborazione dei dati completata con successo'));
   
           return Command::SUCCESS;
       }
   }
   

Per i dettagli consulta la documentazione delle notifiche di Laravel.

​

Esempi pratici di applicazioni

​

Esempio 1: monitoraggio uptime di siti web e alert Slack

Un comando che verifica se un sito è online e invia un alert su Slack in caso di problemi.

1. Installa il canale di notifica Slack

   composer require laravel/slack-notification-channel
   
2. Crea comando e notifica

   php artisan make:command MonitorWebsites --command=monitor:websites
   php artisan make:notification WebsiteDown
   
3. Configura Slack

   php artisan config:publish services
   

   Aggiungi l’URL del webhook Slack in .env.

   SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
   

   Aggiorna config/services.php.

   'slack' => [
       'webhook_url' => env('SLACK_WEBHOOK_URL'),
   ],
   
4. Implementa la notifica

   Modifica app/Notifications/WebsiteDown.php.

   <?php
   
   namespace App\Notifications;
   
   use Illuminate\Notifications\Messages\SlackMessage;
   use Illuminate\Notifications\Notification;
   
   class WebsiteDown extends Notification
   {
       public function __construct(
           protected string $website,
           protected string $error,
       ) {}
   
       public function via($notifiable): array
       {
           return ['slack'];
       }
   
       public function toSlack($notifiable): SlackMessage
       {
           return (new SlackMessage)
               ->error()
               ->content('Alert sito down!')
               ->attachment(function ($attachment) {
                   $attachment->title($this->website)
                              ->content("Errore: {$this->error}")
                              ->timestamp(now());
               });
       }
   }
   
5. Implementa il comando

   Modifica app/Console/Commands/MonitorWebsites.php.

   <?php
   
   namespace App\Console\Commands;
   
   use App\Notifications\WebsiteDown;
   use Illuminate\Console\Command;
   use Illuminate\Support\Facades\Http;
   use Illuminate\Support\Facades\Log;
   use Illuminate\Support\Facades\Notification;
   
   class MonitorWebsites extends Command
   {
       protected $signature = 'monitor:websites {--timeout=10}';
       protected $description = 'Verifica uptime dei siti e invio di alert Slack in caso di down';
   
       protected array $websites = [
           'https://example.com',
           'https://yourwebsite.com',
       ];
   
       public function handle(): int
       {
           $timeout = (int) $this->option('timeout');
           $webhookUrl = config('services.slack.webhook_url');
           $hasErrors = false;
   
           foreach ($this->websites as $website) {
               try {
                   $response = Http::timeout($timeout)->get($website);
                   if ($response->successful()) {
                       $this->info("{$website}: online ✓");
                   } else {
                       $error = "Stato HTTP: " . $response->status();
                       $this->error("{$website}: down ({$error})");
                       Notification::route('slack', $webhookUrl)
                           ->notify(new WebsiteDown($website, $error));
                       $hasErrors = true;
                   }
               } catch (\Exception $e) {
                   $this->error("{$website}: errore ({$e->getMessage()})");
                   Log::error("Verifica di {$website} fallita", ['error' => $e->getMessage()]);
                   Notification::route('slack', $webhookUrl)
                       ->notify(new WebsiteDown($website, $e->getMessage()));
                   $hasErrors = true;
               }
           }
   
           return $hasErrors ? Command::FAILURE : Command::SUCCESS;
       }
   }
   
6. Schedula con GitHub Actions

   Aggiorna .github/workflows/cron.yml.

   name: Website Monitoring
   
   on:
     schedule:
       - cron: '*/15 * * * *'  # Ogni 15 minuti
   
   jobs:
     monitor:
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v6
         - uses: shivammathur/setup-php@v2
           with:
             php-version: 8.5
         - run: composer install --no-dev -q
         - run: cp .env.example .env
         - run: php artisan key:generate
         - name: Monitor Websites
           run: php artisan monitor:websites
           env:
             SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
   

​

Esempio 2: aggiornamento portafoglio crypto e notifica Discord

Un comando che recupera i prezzi delle crypto dall’API CoinGecko e invia gli aggiornamenti tramite webhook Discord.

1. Installa il canale di notifica Discord

   composer require revolution/laravel-notification-discord-webhook
   
2. Crea comando e notifica

   php artisan make:command UpdateCryptoPortfolio --command=crypto:portfolio
   php artisan make:notification CryptoPortfolioUpdate
   
3. Configura Discord

   Aggiungi l’URL del webhook Discord in .env.

   DISCORD_WEBHOOK=https://discord.com/api/webhooks/YOUR/WEBHOOK
   

   Aggiorna config/services.php.

   'discord' => [
       'webhook' => env('DISCORD_WEBHOOK'),
   ],
   
4. Implementa ed esegui il comando

   Per l’implementazione dettagliata consulta il tutorial nella repository GitHub.

   php artisan crypto:portfolio
   

​

Esempio 3: scraping di contenuti dal web e notifica via email

Un comando che effettua scraping di contenuti da un sito e invia i risultati via email.

1. Crea comando e notifica

   php artisan make:command WebScraper --command=scrape:website
   php artisan make:notification ScrapingCompleted
   
2. Configura la mail

   php artisan config:publish mail
   

   Aggiungi la configurazione della mail nel file .env.

   MAIL_MAILER=smtp
   MAIL_HOST=smtp.mailtrap.io
   MAIL_PORT=2525
   MAIL_USERNAME=your_username
   MAIL_PASSWORD=your_password
   MAIL_ENCRYPTION=tls
   MAIL_FROM_ADDRESS=[e-mail]
   MAIL_FROM_NAME="${APP_NAME}"
   
3. Implementa ed esegui il comando

   protected $signature = 'scrape:website {--url=https://example.com} {--email=[e-mail]}';
   
   public function handle(): int
   {
       $url = $this->option('url');
       $email = $this->option('email');
   
       $response = Http::timeout(30)->get($url);
   
       // Elabora il contenuto e invia la notifica...
       Notification::route('mail', $email)
           ->notify(new ScrapingCompleted(true, $url, $title, $content));
   
       return Command::SUCCESS;
   }
   

   php artisan scrape:website --email=[e-mail]
   

​

Passi successivi

Ora conosci le basi per costruire un’applicazione console Laravel con revolution/laravel-console-starter.

Per approfondire:

• Esplora la documentazione Laravel — verifica sulla documentazione ufficiale Laravel le funzionalità che possono potenziare la tua app console
• Aggiungi test — scrivi test per i comandi con il framework di testing di Laravel per garantirne l’affidabilità
• Valuta lo sviluppo di pacchetti — se crei comandi simili in più progetti, valuta di pubblicarli come pacchetto Laravel riutilizzabile
• Segui le novità — segui Laravel News e il blog ufficiale per restare aggiornato sulle best practice