Erstellen einer CLI-Anwendung mit Laravel und Docker

Was ist eine CLI-Anwendung?

Eine CLI-Anwendung (Command-Line Interface) ist ein Computerprogramm, das mit dem Benutzer über Textbefehle interagiert, die in ein Terminal oder eine Konsole eingegeben werden. Im Gegensatz zu Webanwendungen, die auf einer grafischen Benutzeroberfläche (GUI) basieren, sind CLI-Anwendungen textbasiert und werden häufig für Automatisierungs-, Systemverwaltungs- und Datenverarbeitungsaufgaben verwendet.

Warum Laravel und Docker?

Laravel ist ein leistungsstarkes PHP-Framework, das die Entwicklung von Webanwendungen vereinfacht. Seine elegante Syntax, seine robusten Funktionen und sein umfangreiches Ökosystem machen es zu einer hervorragenden Wahl für die Erstellung von CLI-Anwendungen. Mit dem Artisan-Befehlszeilentool von Laravel können Sie schnell Befehle erstellen und verwalten und so Aufgaben und Skripte einfach automatisieren.

Docker ist eine Containerisierungsplattform, die Anwendungen und ihre Abhängigkeiten in tragbare Container verpackt. Durch die Verwendung von Docker können wir isolierte Umgebungen für unsere Laravel-Anwendungen erstellen und so Konsistenz und Reproduzierbarkeit über verschiedene Entwicklungs- und Produktionsumgebungen hinweg gewährleisten.

In diesem Artikel erfahren Sie, wie Sie Laravel und Docker nutzen können, um robuste und effiziente CLI-Anwendungen zu erstellen.

Einrichten des Laravel-Projekts

Erstellen eines neuen Laravel-Projekts

Erstellen wir zunächst ein neues Laravel-Projekt. Mit dem Laravel-Installationsprogramm können Sie schnell ein neues Projekt einrichten:

laravel new my-cli-app

Dieser Befehl erstellt ein neues Verzeichnis mit dem Namen my-cli-app und initialisiert darin ein neues Laravel-Projekt.

Konfigurieren des Artisan-Befehls

Laravels integriertes Befehlszeilentool artisan ist das Herzstück des Frameworks. Wir können damit verschiedene Aspekte unserer Anwendung erstellen und verwalten. Um einen neuen Befehl zu erstellen, verwenden wir den make:command Artisan-Befehl:

php artisan make:command GreetUser

Dieser Befehl generiert eine neue Befehlsklasse namens GreetUser im Verzeichnis app/Console/Commands. Die Grundstruktur einer Befehlsklasse sieht folgendermaßen aus:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;

class GreetUser extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'greet:user {name?}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Greet a user';

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        $name = $this->argument('name');

        if ($name) {
            $this->info("Hello, {$name}!");
        } else {
            $this->info('Hello, world!');
        }

        return Command::SUCCESS;
    }
}

In diesem Beispiel:

- $signature: Definiert den Namen des Befehls und alle optionalen Argumente oder Optionen. Der Teil {name?} gibt ein optionales Argument mit dem Namen name.
an - $description: Bietet eine kurze Beschreibung des Befehls.
- handle(): Enthält die Kernlogik des Befehls. Es greift mit $this->argument('name') auf das Namensargument zu und gibt eine Begrüßungsnachricht an die Konsole aus.

Um diesen Befehl auszuführen, verwenden Sie den folgenden Befehl in Ihrem Terminal:

php artisan greet:user JohnDoe

Dies wird Folgendes ausgeben:

laravel new my-cli-app

Schreiben der Befehlslogik

Kernbefehlslogik

In der handle()-Methode geschieht die wahre Magie. Hier definieren Sie die Kernlogik Ihres Befehls. Sie können auf Befehlsargumente und -optionen zugreifen, mit dem Laravel-Framework interagieren und verschiedene Aufgaben ausführen.

Hier ist ein Beispiel für einen Befehl, der Daten von einer API abruft und verarbeitet:

php artisan make:command GreetUser

In diesem Beispiel:

- Daten abrufen: Wir verwenden die HTTP-Fassade, um eine HTTP-GET-Anfrage an die angegebene URL zu senden.
- Datenverarbeitung: Wenn die Anfrage erfolgreich ist, analysieren wir die JSON-Antwort und verarbeiten die Daten nach Bedarf.
- Ausgabe: Wir verwenden die Info- und Fehlermethoden, um Meldungen auf der Konsole anzuzeigen.

Testen des Befehls

Um Ihren Befehl zu testen, führen Sie ihn einfach mit dem PHP-Artisan-Befehl aus:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;

class GreetUser extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'greet:user {name?}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Greet a user';

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        $name = $this->argument('name');

        if ($name) {
            $this->info("Hello, {$name}!");
        } else {
            $this->info('Hello, world!');
        }

        return Command::SUCCESS;
    }
}

Denken Sie daran, https://api.example.com/data durch einen tatsächlichen API-Endpunkt zu ersetzen.

Dadurch wird die handle()-Methode des FetchData-Befehls ausgelöst und Sie sollten die entsprechende Ausgabe in Ihrem Terminal sehen.

Containerisieren der Anwendung mit Docker

Docker ist ein leistungsstarkes Tool zum Containerisieren von Anwendungen. Durch die Containerisierung Ihrer Laravel-Anwendung können Sie konsistente Umgebungen über verschiedene Entwicklungs- und Produktionseinstellungen hinweg sicherstellen.

Erstellen einer Docker-Datei

Eine Docker-Datei ist ein Textdokument, das Anweisungen zum Erstellen eines Docker-Images enthält. Hier ist eine grundlegende Docker-Datei für eine Laravel-Anwendung:

php artisan greet:user JohnDoe

Erstellen einer Docker Compose-Datei

Eine Docker Compose-Datei definiert und führt Docker-Anwendungen mit mehreren Containern aus. Hier ist eine einfache Docker Compose-Datei für eine Laravel-Anwendung:

Hello, JohnDoe!

Diese Docker Compose-Datei definiert zwei Dienste:

• app: Erstellt das Docker-Image mithilfe der Docker-Datei und ordnet Port 8000 Ihres Hostcomputers Port 9000 des Containers zu. Außerdem wird das aktuelle Verzeichnis als Volume im Container bereitgestellt, sodass Live-Codeänderungen möglich sind.
• Datenbank: Ruft ein MySQL-Image ab und richtet eine Datenbank mit den angegebenen Anmeldeinformationen ein.

Erstellen und Ausführen des Docker-Images

Das Image aufbauen

Um das Docker-Image zu erstellen, navigieren Sie in Ihrem Terminal zum Stammverzeichnis Ihres Projekts und führen Sie den folgenden Befehl aus:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Http;

class FetchData extends Command
{
    protected $signature = 'fetch:data {url}';

    protected $description = 'Fetch data from a given URL';

    public function handle()
    {
        $url = $this->argument('url');

        $response = Http::get($url);

        if ($response->successful()) {
            $data = $response->json();
            // Process the data here
            $this->info('Data fetched and processed successfully!');
        } else {
            $this->error('Failed to fetch data.');
        }
    }
}

Dieser Befehl erstellt das in der Docker-Datei definierte Docker-Image und markiert es mit einem Namen (normalerweise dem Dienstnamen aus der Datei docker-compose.yml).

Ausführen des Containers

Sobald das Image erstellt ist, können Sie den Container mit dem folgenden Befehl starten:

laravel new my-cli-app

Dieser Befehl startet die Anwendungs- und Datenbankcontainer im getrennten Modus, sodass Sie in Ihrem Browser auf Ihre Anwendung zugreifen können. Sie können auf Ihre Anwendung unter http://localhost:8000.

Um die Container zu stoppen, verwenden Sie den folgenden Befehl:

php artisan make:command GreetUser

Best Practices und fortgeschrittene Themen

Befehlsorganisation und Modularisierung

Wenn Ihre CLI-Anwendung wächst, ist es wichtig, Ihre Befehle organisiert und modular zu halten. Erwägen Sie, komplexe Befehle in kleinere, gezieltere Befehle aufzuteilen. Sie können Dienstanbieter und Fassaden verwenden, um Abhängigkeiten einzufügen und Logik zwischen Befehlen zu teilen.

Fehlerbehandlung und Protokollierung

Die Implementierung einer robusten Fehlerbehandlung und -protokollierung ist für das Debuggen und Überwachen Ihrer CLI-Anwendungen von entscheidender Bedeutung. Laravel bietet ein leistungsstarkes Protokollierungssystem, mit dem Sie Fehler, Warnungen und Informationsmeldungen protokollieren können. Für erweiterte Protokollierungsfunktionen können Sie auch externe Protokollierungstools wie Loggly oder Papertrail verwenden.

Testen von CLI-Anwendungen

Das Schreiben von Unit-Tests für Ihre Befehlslogik ist wichtig, um die Qualität und Wartbarkeit des Codes sicherzustellen. Sie können PHPUnit oder andere Test-Frameworks verwenden, um Tests zu schreiben, die verschiedene Szenarien und Randfälle abdecken.

Bereitstellung und CI/CD

Um Ihre Dockerized Laravel-Anwendung bereitzustellen, können Sie Container-Orchestrierungstools wie Kubernetes oder Docker Swarm verwenden. Mit diesen Tools können Sie Ihre Anwendung über mehrere Hosts hinweg verwalten und skalieren.
Sie können Ihre Anwendung auch mit CI/CD-Pipelines integrieren, um die Build-, Test- und Bereitstellungsprozesse zu automatisieren. Zu den beliebten CI/CD-Tools gehören Jenkins, GitLab CI/CD und CircleCI.

Indem Sie diese Best Practices und fortgeschrittenen Techniken befolgen, können Sie leistungsstarke und effiziente CLI-Anwendungen mit Laravel und Docker erstellen.

Abschluss

In diesem Artikel haben wir untersucht, wie man mit Laravel und Docker robuste und effiziente CLI-Anwendungen erstellt. Indem Sie die Leistungsfähigkeit dieser Tools nutzen, können Sie Befehlszeilentools erstellen, die Aufgaben automatisieren, Daten verarbeiten und mit der Infrastruktur Ihrer Anwendung interagieren.

Wir haben die Grundlagen zum Erstellen von Laravel-Befehlen, zum Schreiben von Befehlslogik und zum Containerisieren Ihrer Anwendung mit Docker behandelt. Wir haben auch Best Practices für die Befehlsorganisation, Fehlerbehandlung, Tests und Bereitstellung besprochen.

Denken Sie beim weiteren Erstellen und Verbessern Ihrer CLI-Anwendungen daran, dass Ihr Code sauber, gut getestet und wartbar bleibt. Indem Sie diese Richtlinien befolgen und die erweiterten Funktionen von Laravel und Docker erkunden, können Sie leistungsstarke und flexible CLI-Tools erstellen, die Ihre Arbeitsabläufe optimieren.

Das obige ist der detaillierte Inhalt vonErstellen einer CLI-Anwendung mit Laravel und Docker. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!