One place for hosting & domains

      Seeders

      So verwenden Sie Datenbankmigrationen und Seeders für die abstrakte Datenbank-Einrichtung in Laravel


      Migrationen und Seeders sind leistungsfähige Datenbank-Dienstprogramme, die vom Laravel-PHP-Framework bereitgestellt werden, um Entwicklern einen schnellen Bootstrap, eine schnelle Löschung und neue Erstellung der Datenbank einer Anwendung zu ermöglichen. Diese Dienstprogramme minimieren Probleme der Datenbankinkonsistenz, die auftreten können, wenn mehrere Entwickler an derselben Anwendung arbeiten: Neue Mitwirkende müssen nur ein paar artisan-Befehle ausführen, um die Datenbank auf einer neuen Installation einzurichten.

      In diesem Leitfaden erstellen Sie Migrationen und Seeders, um eine Datenbank einer Laravel-Demo-Anwendung mit Beispieldaten zu füllen. Am Ende können Sie Ihre Datenbank-Tabellen nur mit artisan-Befehlen so oft Sie möchten löschen und neu erstellen.

      Voraussetzungen

      Um diesen Leitfaden auszuführen, benötigen Sie:

      Anmerkung: In diesem Leitfaden verwenden wir eine containerisierte Entwicklungsumgebung, die von Docker Compose verwaltet wird, um die Anwendung auszuführen. Sie können die Anwendung jedoch auch auf einem LEMP-Server ausführen. Um dies einzurichten, können Sie unseren Leitfaden So installieren und konfigurieren Sie Laravel mit LEMP unter Ubuntu 18.04 ausführen.

      Schritt 1 – Erhalt der Demo-Anwendung

      Zu Beginn rufen wir die Demoversion der Laravel-Anwendung aus dem Github Repository ab. Wir beschäftigen uns mit dem Zweig tutorial-02, der eine Docker-Compose-Einrichtung beinhaltet, um die Anwendung auf Containern auszuführen. In diesem Beispiel laden wir die Anwendung in unseren Home-Ordner herunter, aber Sie können jedes Verzeichnis Ihrer Wahl verwenden:

      • cd ~
      • curl -L https://github.com/do-community/travellist-laravel-demo/archive/tutorial-2.0.1.zip -o travellist.zip

      Da wir den Anwendungscode als .zip-Datei heruntergeladen haben, benötigen wir den Befehl unzip, um ihn zu entpacken. Wenn Sie es nicht vor Kurzem getan haben, aktualisieren den lokalen Paketindex Ihres Rechners:

      Installieren Sie dann das unzip-Paket:

      Entzippen Sie danach den Inhalt der Anwendung:

      Benennen Sie dann das entpackte Verzeichnis für einen leichteren Zugriff in travellist-demo​​ um:

      • mv travellist-laravel-demo-tutorial-2.0.1 travellist-demo

      Im nächsten Schritt erstellen wir eine .env Konfigurationsdatei, um die Anwendung einzurichten.

      Schritt 2 – Einrichten der .env Datei der Anwendung

      In Laravel wird eine .env-Datei verwendet, um umgebungsabhängige Konfigurationen einzurichten, wie Anmeldeangaben und alle Informationen, die zwischen Bereitstellungen variieren können. Diese Datei ist nicht Teil der Revisionskontrolle.

      Warnung: Die Umgebungs-Konfigurationsdatei enthält sensible Informationen über Ihren Server, einschließlich Anmeldedaten zur Datenbank und Sicherheitsschlüssel. Aus diesem Grund sollten Sie diese Datei nie öffentlich teilen.

      Die Werte in der .env-Datei haben Vorrang vor den Werten, die in regelmäßigen Konfigurationsdateien festgelegt sind, die sich im Verzeichnis config befinden. Jede Installation in einer neuen Umgebung erfordert eine maßgeschneiderte Umgebungsdatei, um Dinge wie Datenbank-Verbindungseinstellungen, Debug-Optionen, Anwendungs-URL und andere Objekte festzulegen, die je nach der Umgebung variieren können.

      Navigieren Sie zum Verzeichnis travellist-demo:

      Jetzt erstellen wir eine neue .env Datei, um die Konfigurationsoptionen für die Entwicklungsumgebung anzupassen, die wir einrichten. Laravel wird mit einer .env-Musterdatei geliefert, die wir zur Erstellung unserer eigenen kopieren können:

      Öffnen Sie diese Datei mit nano oder dem Texteditor Ihrer Wahl:

      So sieht Ihre .env-Datei jetzt aus:

      .env

      APP_NAME=Travellist
      APP_ENV=dev
      APP_KEY=
      APP_DEBUG=true
      APP_URL=http://localhost:8000
      
      LOG_CHANNEL=stack
      
      DB_CONNECTION=mysql
      DB_HOST=db
      DB_PORT=3306
      DB_DATABASE=travellist
      DB_USERNAME=travellist_user
      DB_PASSWORD=password

      Die aktuelle .env-Datei aus der Demo-Anwendung travellist enthält Einstellungen, um die containerisierte Umgebung zu verwenden, die wir im letzten Teil dieser Serie mit Docker Compose erstellt haben. Sie müssen keine dieser Werte ändern, aber Sie können gerne DB_DATABASE, DB_USERNAME und DB_PASSWORD ändern, da diese von unserer Datei docker-compose.yml automatisch abgerufen werden, um die Entwicklungsdatenbank einzurichten. Stellen Sie jedoch sicher, dass die Variable DB_HOST unverändert bleibt, da sie auf den Namen unseres Datenbank-Dienstes innerhalb der Docker-Compose-Umgebung verweist.

      Wenn Sie Änderungen an der Datei vornehmen, stellen Sie sicher, dass Sie sie durch Drücken von STRG + X, Y, dann der EINGABETASTE gespeichert und geschlossen haben.

      Anmerkung: Wenn Sie sich dafür entschieden haben, die Anwendung auf einem LEMP-Server auszuführen, müssen Sie die hervorgehobenen Werte ändern, um Ihre eigenen Datenbankeinstellungen, einschließlich der Variablen DB_HOST, zu berücksichtigen.

      Schritt 3 – Installieren von Anwendungsabhängigkeiten mit Composer

      Jetzt verwenden wir Composer, das Abhängigkeitsmanagement-Tool von PHP, um die Abhängigkeiten der Anwendung zu installieren und sicherzustellen, dass wir artisan-Befehle ausführen können.

      Rufen Sie Ihre Docker-Compose-Umgebung mit dem folgenden Befehl auf. Dadurch werden das Image travellist für den app-Dienst erstellt und die zusätzlichen Docker-Images eingefügt, die von den Diensten nginx und db benötigt werden, um die Anwendungsumgebung zu erstellen:

      Output

      Creating network "travellist-demo_travellist" with driver "bridge" Building app Step 1/11 : FROM php:7.4-fpm ---> fa37bd6db22a Step 2/11 : ARG user ---> Running in 9259bb2ac034 … Creating travellist-app ... done Creating travellist-nginx ... done Creating travellist-db ... done

      Dies kann einige Minuten dauern. Sobald der Vorgang abgeschlossen ist, können wir Composer ausführen, um die Abhängigkeiten der Anwendung zu installieren.

      Um composer und andere Befehle im app-Dienstcontainer auszuführen, verwenden wir docker-compose exec. Der Befehl exec ermöglicht es uns, jeden Befehl unserer Wahl auf Containern auszuführen, die von Docker Compose verwaltet werden. Es verwendet die folgende Syntax: docker-compose exec service_name command.

      Anmerkung: Falls Sie sich entschieden haben, einen LEMP-Server zu verwenden, um die Demo-Anwendung auszuführen, sollten Sie den Teil docker-compose exec app der Befehle in diesem Leitfaden ignorieren. Statt beispielsweise den folgenden Befehl auszuführen, wie er geschrieben ist, würden Sie nur Folgendes ausführen:

      Um composer install im app-Container auszuführen, führen Sie Folgendes aus:

      • docker-compose exec app composer install

      Output

      Loading composer repositories with package information Installing dependencies (including require-dev) from lock file Package operations: 85 installs, 0 updates, 0 removals - Installing doctrine/inflector (1.3.1): Downloading (100%) - Installing doctrine/lexer (1.2.0): Downloading (100%) - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%) …

      Wenn Composer die Installation der Anwendungsabhängigkeiten abgeschlossen hat, können Sie artisan-Befehle ausführen. Um zu testen, ob die Anwendung eine Verbindung mit der Datenbank herstellen kann, führen Sie folgenden Befehl aus, der alle bereits vorhandenen Tabellen bereinigen wird:

      • docker-compose exec app php artisan db:wipe

      Dieser Befehl verwirft alle bereits vorhandenen Tabellen auf der konfigurierten Datenbank. Wenn er erfolgreich ausgeführt wird und die Anwendung eine Verbindung mit der Datenbank herstellen kann, sehen Sie eine Ausgabe wie diese:

      Output

      Dropped all tables successfully.

      Nachdem Sie nun die Anwendungsabhängigkeiten mit Composer installiert haben, können Sie das artisan-Tool verwenden, um Migrationen und Seeders zu erstellen.

      Schritt 4 – Datenbank-Migrationen erstellen

      Das artisan-Befehlszeilentool, das mit Laravel geliefert wird, enthält eine Reihe von Hilfsbefehlen, die zur Verwaltung der Anwendung und dem Bootstrap neuer Klassen verwendet werden können. Um eine neue Migrationsklasse zu generieren, können wir den Befehl make:migration wie folgt verwenden:

      • docker-compose exec app php artisan make:migration create_places_table

      Laravel leitet die auszuführende Operation (create), den Namen der Tabelle (places) und ob diese Migration eine neue Tabelle erstellt oder nicht basierend auf dem beschreibenden Namen ab, der dem Befehl make:migration bereitgestellt wird.

      Sie werden eine Ausgabe sehen, die dieser ähnelt:

      Output

      Created Migration: 2020_02_03_143622_create_places_table

      Dadurch wird eine neue Datei im Verzeichnis database/migrations der Anwendung generiert. Der in der automatisch generierten Datei enthaltene Zeitstempel wird von Laravel verwendet, um zu bestimmen, in welcher Reihenfolge Migrationen ausgeführt werden sollen.

      Verwenden Sie den Texteditor Ihrer Wahl, um die generierte Migrationsdatei zu öffnen. Vergessen Sie nicht, den hervorgehobenen Wert durch Ihren eigenen Migrationsdatei-Namen zu ersetzen:

      • nano database/migrations/2020_02_03_143622_create_places_table.php

      Die generierte Migrationsdatei enthält eine Klasse namens CreatePlacesTable:

      database/migrations/2020_02_03_143622_create_places_table.php

      <?php
      
      use IlluminateDatabaseMigrationsMigration;
      use IlluminateDatabaseSchemaBlueprint;
      use IlluminateSupportFacadesSchema;
      
      class CreatePlacesTable extends Migration
      {
          /**
           * Run the migrations.
           *
           * @return void
           */
          public function up()
          {
              Schema::create('places', function (Blueprint $table) {
                  $table->bigIncrements('id');
                  $table->timestamps();
              });
          }
      
          /**
           * Reverse the migrations.
           *
           * @return void
           */
          public function down()
          {
              Schema::dropIfExists('places');
          }
      }
      
      

      Diese Klasse verfügt über zwei Methoden: up und down. Beide Methoden enthalten Bootstrap-Code, den Sie erweitern können, um das anzupassen, was geschieht, wenn die Migration ausgeführt wird und wenn sie zurückgesetzt wird.

      Wir ändern die Methode up, damit die Tabelle places die Struktur wiedergibt, die wir bereits in der aktuellen Version der Anwendung verwenden:

      • id: primäres Schlüsselfeld
      • name: Name des Ortes
      • visited: ob dieser Ort bereits besucht wurde oder nicht

      Der Laravel Schema Builder macht Methoden zum Erstellen, Aktualisieren und Löschen von Tabellen in einer Datenbank verfügbar. Die Klasse Blueprint definiert die Struktur der Tabelle und bietet verschiedene Methoden, um die Definition jedes Tabellenfeldes zusammenzufassen.

      Der automatisch generierte Code richtet ein primäres ID-Feld namens id ein. Die Methode timestamps erstellt zwei datetime-Felder, die automatisch von den zugrunde liegenden Datenbank-Klassen aktualisiert werden, wenn Daten in diese Tabelle eingefügt oder aktualisiert werden. Zusätzlich müssen wir einen Namen und ein visited-Feld aufnehmen.

      Unser Namens-Feld ist vom Typ Zeichenfolge und unser visited-Feld vom Typ Boolean. Außerdem geben wir einen Standardwert von 0 für das visited-Feld ein. Wenn kein Wert übergeben wird, bedeutet es dann, dass der Ort noch nicht besucht wurde. So sieht die Methode up jetzt aus:

      database/migrations/2020_02_03_143622_create_places_table.php

      …
          public function up()
          {
              Schema::create('places', function (Blueprint $table) {
                  $table->bigIncrements('id');
                  $table->string('name', 100);
                  $table->boolean('visited')->default(0);
                  $table->timestamps();
              });
          }
      …
      

      Anmerkung: Die vollständige Liste der verfügbaren Spaltentypen finden Sie in der Laravel-Dokumentation.

      Nachdem Sie die beiden hervorgehobenen Zeilen auf Ihrem eigenen Migrations-Skript inkludiert haben, speichern und schließen Sie die Datei.

      Ihre Migration kann jetzt über artisan migrate ausgeführt werden. Dies würde jedoch nur eine leere Tabelle erstellen; Sie müssen auch Beispieldaten für Entwicklung und Test einfügen können. Im nächsten Schritt sehen Sie, wie Sie das mithilfe von Datenbank-Seeders tun können.

      Schritt 5 – Databank-Seeders erstellen

      Ein Seeder ist eine spezielle Klasse, die zum Generieren und Einfügen von Beispieldaten (Seeds) in einer Datenbank verwendet wird. Dies ist ein wichtiges Merkmal in Entwicklungsumgebungen, denn damit können Sie die Anwendung mit einer frischen Datenbank neu erstellen – mit Beispielwerten, die Sie sonst jedes Mal manuell einfügen müssen, wenn die Datenbank neu erstellt wird.

      Wir verwenden jetzt den Befehl artisan, um eine neue Seeder-Klasse für unsere Tabelle places namens PlacesTableSeeder zu generieren:

      • docker-compose exec app php artisan make:seeder PlacesTableSeeder

      Der Befehl erstellt eine neue Datei namens PlacesTableSeeder.php im Verzeichnis database/seeds. Öffnen Sie diese Datei mit dem Texteditor Ihrer Wahl:

      • nano database/seeds/PlacesTableSeeder.php

      So sieht die automatisch generierte Datei PlacesTableSeeder.php aus:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      
      class PlacesTableSeeder extends Seeder
      {
          /**
           * Run the database seeds.
           *
           * @return void
           */
          public function run()
          {
              //
          }
      }
      
      

      Unsere neue Seeder-Klasse enthält eine leere Methode namens run. Diese Methode wird aufgerufen, wenn der Artisan-Befehl db:seed ausgeführt wird.

      Sie müssen die Methode run bearbeiten, um Anweisungen zum Einfügen von Beispieldaten in die Datenbank aufzunehmen. Wir verwenden den Laravel query builder​​​, um diesen Vorgang zu optimieren.

      Der Laravel query builder bietet eine fließende Schnittstelle für Datenbankoperationen wie Einfügen, Aktualisieren, Löschen und Abrufen von Daten. Er schützt zudem vor SQL-Injection-Angriffen. Der query builder wird von der DB facade​​​ verfügbar gemacht – ein statischer Proxy für zugrunde liegende Datenbank-Klassen im Dienstcontainer.

      Jetzt erstellen wir eine statische Klassen-Variable, um alle Beispielorte aufzunehmen, die wir als Array in die Datenbank einfügen möchten. Dadurch können wir eine foreach-Schleife verwenden, um alle Werte zu durchlaufen und jeden einzelnen mit dem query builder in die Datenbank einzufügen.

      Wir nennen diese Variable $places:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      
      class PlacesTableSeeder extends Seeder
      {
          static $places = [
              'Berlin',
              'Budapest',
              'Cincinnati',
              'Denver',
              'Helsinki',
              'Lisbon',
              'Moscow',
              'Nairobi',
              'Oslo',
              'Rio',
              'Tokyo'
          ];

      Als Nächstes müssen wir eine use-Anweisung am Anfang unserer PlacesTableSeeder-Klasse aufnehmen, um die Referenzierung der DB facade im gesamten Code zu erleichtern:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      use IlluminateSupportFacadesDB;
      
      class PlacesTableSeeder extends Seeder
      …
      

      Wir können jetzt die Array-Werte $places mit einer foreach-Schleife durchlaufen und jeden einzelnen mit dem query builder in unsere Tabelle places einfügen:

      database/seeds/PlacesTableSeeder.php

      …
          public function run()
          {
              foreach (self::$places as $place) {
                  DB::table('places')->insert([
                      'name' => $place,
                      'visited' => rand(0,1) == 1
                  ]);
              }
          }
      
      

      Die foreach-Schleife durchläuft jeden Wert des statischen Arrays $places. Bei jedem Durchlauf verwenden wir die DB facade, um eine neue Zeile in der Tabelle places einzufügen. In das Namens-Feld geben wir den Namen des Ortes ein, den wir gerade aus dem Array $places erhalten haben, und in das visited-Feld einen beliebigen Wert von entweder 0 oder 1.

      So sieht die volle Klasse PlacesTableSeeder nach allen Aktualisierungen aus:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      use IlluminateSupportFacadesDB;
      
      class PlacesTableSeeder extends Seeder
      {
          static $places = [
              'Berlin',
              'Budapest',
              'Cincinnati',
              'Denver',
              'Helsinki',
              'Lisbon',
              'Moscow',
              'Nairobi',
              'Oslo',
              'Rio',
              'Tokyo'
          ];
      
          /**
           * Run the database seeds.
           *
           * @return void
           */
          public function run()
          {
              foreach (self::$places as $place) {
                  DB::table('places')->insert([
                      'name' => $place,
                      'visited' => rand(0,1) == 1
                  ]);
              }
          }
      }
      

      Speichern und schließen Sie die Datei, wenn Sie diese Änderungen vorgenommen haben.

      Seeder-Klassen werden nicht automatisch im der Anwendung geladen. Bearbeiten Sie die Hauptklasse von DatabaseSeeder, um einen Aufruf zu dem Seeder aufzunehmen, den wir gerade erstellt haben.

      Öffnen Sie die Datei database/seeds/DatabaseSeeder.php mit nano oder Ihrem bevorzugten Editor:

      • nano database/seeds/DatabaseSeeder.php

      Die Klasse DatabaseSeeder sieht wie jeder andere Seeder aus: sie erweitert die Seeder-Klasse und hat eine run-Methode. Diese Methode aktualisieren wir, um einen Aufruf von PlacesTableSeeder aufzunehmen.

      Aktualisieren Sie die aktuelle run-Methode in Ihrer Klasse DatabaseSeeder, indem Sie die auskommentierte Zeile löschen und sie durch den folgenden hervorgehobenen Code ersetzen:

      database/seeds/DatabaseSeeder.php

      …
          public function run()
          {
              $this->call(PlacesTableSeeder::class);
          }
      ...
      

      So sieht die volle Klasse DatabaseSeeder nach der Aktualisierung aus:

      database/seeds/DatabaseSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      
      class DatabaseSeeder extends Seeder
      {
          /**
           * Seed the application's database.
           *
           * @return void
           */
          public function run()
          {
              $this->call(PlacesTableSeeder::class);
          }
      }
      
      
      

      Speichern und schließen Sie die Datei, wenn Sie mit der Aktualisierung des Inhalts fertig sind.

      Jetzt sind wir mit der Einrichtung einer Migration und eines Seeders für unsere Tabelle places fertig. Im nächsten Schritt sehen wir uns ihre Ausführung an.

      Schritt 6 – Datenbank-Migrationen und Seeders ausführen

      Vergewissern Sie sich zuerst, dass Ihre Anwendung ausgeführt wird. Wir richten den Verschlüsselungsschlüssel der Anwendung ein und greifen dann von einem Browser auf die Anwendung zu, um den Webserver zu testen.

      Um den für Laravel erforderlichen Verschlüsselungsschlüssel zu generieren, können Sie den Befehl artisan key:generate verwenden:

      • docker-compose exec app php artisan key:generate

      Sobald der Schlüssel generiert wurde, können Sie auf die Anwendung zugreifen, indem Sie Ihren Browser auf Ihren Server-Hostname oder die IP-Adresse auf Port 8000 verweisen:

      http://server_host_or_ip:8000
      

      Sie sehen in etwa folgende Seite:

      MySQL error

      Das bedeutet, dass die Anwendung eine Verbindung mit der Datenbank herstellen kann, jedoch keine Tabelle namens places finden konnte. Wir erstellen jetzt die Tabelle places mit dem folgenden artisan-Befehl migrate:

      • docker-compose exec app php artisan migrate

      Sie sehen eine Ausgabe, die dieser ähnelt:

      Output

      Migration table created successfully. Migrating: 2014_10_12_000000_create_users_table Migrated: 2014_10_12_000000_create_users_table (0.06 seconds) Migrating: 2014_10_12_100000_create_password_resets_table Migrated: 2014_10_12_100000_create_password_resets_table (0.06 seconds) Migrating: 2019_08_19_000000_create_failed_jobs_table Migrated: 2019_08_19_000000_create_failed_jobs_table (0.03 seconds) Migrating: 2020_02_10_144134_create_places_table Migrated: 2020_02_10_144134_create_places_table (0.03 seconds)

      Sie werden feststellen, dass einige weitere Migrationen zusammen mit der Migration create_places_table ausgeführt wurden, die wir eingerichtet haben. Diese Migrationen werden automatisch generiert, wenn Laravel installiert ist. Obwohl wir diese zusätzlichen Tabellen jetzt nicht verwenden, werden sie in Zukunft benötigt, wenn wir die Anwendung um registrierte Benutzer und geplante Aufträge erweitern. Jetzt können Sie sie vorerst so belassen.

      Zu diesem Zeitpunkt ist unsere Tabelle noch leer. Wir müssen den Befehl db:seed​​​ ausführen, um Seeding für die Datenbank mit unseren Beispielorten durchzuführen.

      • docker-compose exec app php artisan db:seed

      Dadurch werden unser Seeder ausgeführt und die Beispielwerte eingefügt, die wir in unserer Klasse PlacesTableSeeder definiert haben. Sie sehen eine Ausgabe, die dieser ähnelt:

      Output

      Seeding: PlacesTableSeeder Seeded: PlacesTableSeeder (0.06 seconds) Database seeding completed successfully.

      Laden Sie jetzt die Anwendungsseite in Ihrem Browser neu. Sie sehen eine Seite, die so ähnlich wie die folgende aussieht:

      Demoversion der Laravel-Anwendung

      Wann immer Sie wieder von vorne beginnen müssen, können Sie alle Datenbank-Tabellen folgendermaßen verwerfen:

      • docker-compose exec app php artisan db:wipe

      Output

      Dropped all tables successfully.

      Um die Anwendungs-Migrationen auszuführen und Seeding für die Tabellen mit einem einzelnen Befehl durchzuführen, können Sie Folgendes verwenden:

      • docker-compose exec app php artisan migrate --seed

      Output

      Migration table created successfully. Migrating: 2014_10_12_000000_create_users_table Migrated: 2014_10_12_000000_create_users_table (0.06 seconds) Migrating: 2014_10_12_100000_create_password_resets_table Migrated: 2014_10_12_100000_create_password_resets_table (0.07 seconds) Migrating: 2019_08_19_000000_create_failed_jobs_table Migrated: 2019_08_19_000000_create_failed_jobs_table (0.03 seconds) Migrating: 2020_02_10_144134_create_places_table Migrated: 2020_02_10_144134_create_places_table (0.03 seconds) Seeding: PlacesTableSeeder Seeded: PlacesTableSeeder (0.06 seconds) Database seeding completed successfully.

      Wenn Sie eine Migration zurücksetzen möchten, können Sie Folgendes ausführen:

      • docker-compose exec app php artisan migrate:rollback

      Dadurch wird die Methode down für jede Migrationsklasse im Ordner migrations ausgelöst. Üblicherweise werden alle Tabellen entfernt, die durch Migrations-Klassen erstellt wurden, und es bleiben nur jene Tabellen übrig, die von Hand erstellt wurden. Die Ausgabe sieht dann so aus:

      Output

      Rolling back: 2020_02_10_144134_create_places_table Rolled back: 2020_02_10_144134_create_places_table (0.02 seconds) Rolling back: 2019_08_19_000000_create_failed_jobs_table Rolled back: 2019_08_19_000000_create_failed_jobs_table (0.02 seconds) Rolling back: 2014_10_12_100000_create_password_resets_table Rolled back: 2014_10_12_100000_create_password_resets_table (0.02 seconds) Rolling back: 2014_10_12_000000_create_users_table Rolled back: 2014_10_12_000000_create_users_table (0.02 seconds)

      Der Befehl Zurücksetzen ist besonders nützlich, wenn Sie Änderungen an Anwendungsmodellen vornehmen und ein Befehl db:wipe nicht verwendet werden kann – beispielsweise wenn mehrere Systeme von der gleichen Datenbank abhängen.

      Zusammenfassung

      In diesem Leitfaden haben Sie gelernt, wie Sie das Einrichten von Entwicklungs- und Test-Datenbänken für eine Laravel-6-Anwendung mithilfe von Datenbank-Migrationen und Seeders erleichtern können.

      In der Laravel-Dokumentation finden Sie weitere Informationen zur Verwendung des query builder​​​ und von Eloquent models, um das Datenbank-Schema Ihrer Anwendung noch weiter zusammenzufassen.



      Source link

      Como usar o Migrations de banco de dados e o Seeders para abstrair a configuração do banco de dados em Laravel


      Migrations [Migrações] e seeders [Propagadores] são utilitários de banco de dados eficazes, fornecidos pela framework do Laravel para PHP, que permite que os desenvolvedores façam a inicialização, destruição e recriação do banco de dados de um aplicativo rapidamente. Esses utilitários ajudam a minimizar problemas de inconsistência de banco de dados que podem surgir com vários desenvolvedores trabalhando no mesmo aplicativo: novos colaboradores precisam apenas executar alguns comandos do artisan para definir o banco de dados em uma nova instalação.

      Neste guia, vamos criar migrations (migrações) e seeders (propagadores) para preencher o banco de dados de um aplicativo de demonstração do Laravel com dados de amostra. No final, você poderá destruir e recriar as tabelas de seu banco de dados quantas vezes quiser, usando apenas comandos do artisan.

      Pré-requisitos

      Para seguir este guia, você vai precisar do seguinte:

      Nota: neste guia, utilizaremos um ambiente de desenvolvimento em contêiner, gerenciado pelo Docker Compose para executar o aplicativo, mas você também pode optar por executar o aplicativo em um servidor LEMP. Para configurar isso, siga nosso guia sobre Como instalar e configurar o Laravel com LEMP no Ubuntu 18.04.

      Passo 1 — Obtendo o aplicativo Demo

      Para começar, iremos buscar o aplicativo de demonstração do Laravel a partir de seu repositório do GitHub. Estamos interessados na ramificação do tutorial-02, que inclui uma Configuração do Docker Compose para executar o aplicativo em contêineres. Neste exemplo, baixaremos o aplicativo para nossa pasta base, mas também é possível usar qualquer diretório de sua escolha:

      • cd ~
      • curl -L https://github.com/do-community/travellist-laravel-demo/archive/tutorial-2.0.1.zip -o travellist.zip

      Como baixamos o código do aplicativo como um arquivo .zip, precisaremos do comando unzip para desempacotá-lo. Se não tiver feito isso recentemente, atualize o índice de pacotes local de sua máquina:

      Depois, instale o pacote unzip:

      Em seguida, descompacte o conteúdo do aplicativo:

      Em seguida, renomeie o diretório descompactado como travellist-demo para facilitar o acesso:

      • mv travellist-laravel-demo-tutorial-2.0.1 travellist-demo

      No próximo passo, vamos criar um arquivo de configuração .env para configurar o aplicativo.

      Passo 2 — Configurando o arquivo .env do aplicativo

      No Laravel, o arquivo .env é usado para configurar as configurações dependentes de ambiente, como credenciais e quaisquer informações que possam variar entre as implantações. Esse arquivo não está incluído no controle de revisão.

      Aviso: o arquivo de configuração de ambiente contém informações confidenciais sobre o seu servidor, incluindo credenciais para o banco de dados e chaves de segurança. Por esse motivo, nunca compartilhe esse arquivo publicamente.

      Os valores contidos no arquivo .env terão precedência sobre os valores definidos nos arquivos de configuração regulares, localizados no diretório config. Cada instalação em um novo ambiente exige um arquivo de ambiente personalizado para definir coisas como as configurações de conexão com o banco de dados, as opções de depuração, o URL do aplicativo, entre outros itens que possam variar, dependendo do ambiente em que o aplicativo esteja funcionando.

      Navegue até o diretório travellist-demo:

      Agora, vamos criar um novo arquivo .env para personalizar as opções de configuração do ambiente de desenvolvimento que estamos preparando. O Laravel vem com um exemplo de arquivo do .env que podemos copiar para criar o nosso:

      Abra este arquivo, usando o nano ou outro editor de texto de sua escolha:

      Esta é a aparência do seu arquivo .env agora:

      .env

      APP_NAME=Travellist
      APP_ENV=dev
      APP_KEY=
      APP_DEBUG=true
      APP_URL=http://localhost:8000
      
      LOG_CHANNEL=stack
      
      DB_CONNECTION=mysql
      DB_HOST=db
      DB_PORT=3306
      DB_DATABASE=travellist
      DB_USERNAME=travellist_user
      DB_PASSWORD=password

      O arquivo .env atual do aplicativo de demonstração travellist contém configurações para usar o ambiente em contêiner que criamos com o Docker Compose na última parte desta série. Você não precisa alterar nenhum desses valores, mas fique à vontade para modificar o DB_DATABASE, o DB_USERNAME e o DB_PASSWORD se quiser, uma vez que eles são puxados automaticamente pelo nosso arquivo docker-compose.yml para configurar o banco de dados de desenvolvimento. Certifique-se apenas de que a variável DB_HOST permaneça inalterada, uma vez que ela faz referência ao nome do nosso serviço de banco de dados dentro do ambiente do Docker Compose.

      Caso faça quaisquer alterações no arquivo, certifique-se de salvar e fechar ele pressionando CTRL + X, Y e, então, ENTER.

      Nota: caso tenha optado por executar o aplicativo em um servidor LEMP, será necessário alterar os valores destacados para refletir as configurações do seu próprio banco de dados, incluindo a variável DB_HOST.

      Agora, usaremos o Composer, uma ferramenta de gerenciamento de dependências do PHP, para instalar as dependências do aplicativo e garantir que possamos executar os comandos do artisan.

      Abra seu ambiente do Docker Compose com o comando a seguir. Isso compilará a imagem do travellist para o serviço do app e extrairá imagens adicionais do Docker – exigidas pelos serviços nginx e db, para criar o ambiente do aplicativo:

      Output

      Creating network "travellist-demo_travellist" with driver "bridge" Building app Step 1/11 : FROM php:7.4-fpm ---> fa37bd6db22a Step 2/11 : ARG user ---> Running in 9259bb2ac034 … Creating travellist-app ... done Creating travellist-nginx ... done Creating travellist-db ... done

      Esta operação pode levar alguns minutos para completar. Assim que o processo terminar, podemos executar o Composer para instalar as dependências do aplicativo.

      Para executar o composer e outros comandos no contêiner de serviço do app, utilizaremos o docker-compose exec. O comando exec permite que executemos qualquer comando de nossa escolha em contêineres gerenciados pelo Docker Compose. Ele usa a seguinte sintaxe: docker-compose exec service_name command.

      Nota: caso tenha optado por usar um servidor LEMP para executar o aplicativo de demonstração, ignore a parte do docker-compose exec app dos comandos listados durante todo este guia. Por exemplo, em vez de executar o seguinte comando como ele está escrito, você apenas executaria:

      Para executar o composer install no contêiner do app, execute:

      • docker-compose exec app composer install

      Output

      Loading composer repositories with package information Installing dependencies (including require-dev) from lock file Package operations: 85 installs, 0 updates, 0 removals - Installing doctrine/inflector (1.3.1): Downloading (100%) - Installing doctrine/lexer (1.2.0): Downloading (100%) - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%) …

      Quando o Composer terminar de instalar as dependências do aplicativo, você poderá executar os comandos do artisan. Para testar se o aplicativo consegue se conectar ao banco de dados, execute o seguinte comando que limpará quaisquer tabelas pré-existentes:

      • docker-compose exec app php artisan db:wipe

      Esse comando removerá quaisquer tabelas pré-existentes do banco de dados configurado. Se ele foi executado com sucesso e o aplicativo conseguiu se conectar ao banco de dados, você verá um resultado parecido com este:

      Output

      Dropped all tables successfully.

      Agora que você tem as dependências do aplicativo instaladas com o Composer, você pode utilizar a ferramenta artisan para criar migrations e seeders.

      Passo 4 — Criando migrations de banco de dados

      A ferramenta de linha de comando do artisan que vem com o Laravel contém uma série de comandos auxiliares que podem ser usados para gerenciar o aplicativo e inicializar novas classes. Para gerar uma nova classe de migration, podemos usar o comando make:migration como segue:

      • docker-compose exec app php artisan make:migration create_places_table

      O Laravel deduz a operação a ser executada (create), o nome da tabela (places) e se essa migration criará uma nova tabela ou não, com base no nome descritivo fornecido para o comando make:migration.

      Você verá um resultado semelhante a este:

      Output

      Created Migration: 2020_02_03_143622_create_places_table

      Isso gerará um novo arquivo no diretório database/migrations do aplicativo. O carimbo de data/hora no arquivo gerado automaticamente é utilizado pelo Laravel para determinar em qual ordem as migrations devem ser executadas.

      Utilize seu editor de texto preferido para abrir o arquivo migration gerado. Lembre-se de substituir o valor destacado pelo nome de arquivo de migration de sua escolha:

      • nano database/migrations/2020_02_03_143622_create_places_table.php

      O arquivo de migration gerado contém uma classe chamada CreatePlacesTable:

      database/migrations/2020_02_03_143622_create_places_table.php

      <?php
      
      use IlluminateDatabaseMigrationsMigration;
      use IlluminateDatabaseSchemaBlueprint;
      use IlluminateSupportFacadesSchema;
      
      class CreatePlacesTable extends Migration
      {
          /**
           * Run the migrations.
           *
           * @return void
           */
          public function up()
          {
              Schema::create('places', function (Blueprint $table) {
                  $table->bigIncrements('id');
                  $table->timestamps();
              });
          }
      
          /**
           * Reverse the migrations.
           *
           * @return void
           */
          public function down()
          {
              Schema::dropIfExists('places');
          }
      }
      
      

      Essa classe tem dois métodos: up e down. Ambos os métodos contêm o código de inicialização que podem ser estendidos para personalizar o que acontece quando essa migration for executada e também o que acontece quando ela for revertida.

      Vamos modificar o método up, de modo que a tabela places reflita a estrutura que já estamos usando na versão atual do aplicativo:

      • id: campo de chave primária.
      • name: nome do lugar.
      • visited: se este lugar já foi visitado ou não.

      O compilador de esquemas do Laravel expõe métodos para a criação, atualização e exclusão de tabelas em um banco de dados. A classe Blueprint define a estrutura da tabela e ela proporciona vários métodos para abstrair a definição de cada campo da tabela.

      O código gerado automaticamente define um campo de id primário chamado id. O método timestamps cria dois campos de datetime que são atualizados automaticamente pelas classes de banco de dados subjacentes, quando os dados são inseridos ou atualizados dentro dessa tabela. Além disso, precisaremos incluir um campo name e um visited.

      Nosso campo name será do tipo string e nosso campo visited será definido com o tipo boolean. Também vamos definir um valor padrão de 0 para o campo visited, de modo que se nenhum valor for transferido, significa que o lugar ainda não foi visitado. É assim que o método up se parecerá agora:

      database/migrations/2020_02_03_143622_create_places_table.php

      …
          public function up()
          {
              Schema::create('places', function (Blueprint $table) {
                  $table->bigIncrements('id');
                  $table->string('name', 100);
                  $table->boolean('visited')->default(0);
                  $table->timestamps();
              });
          }
      …
      

      Nota: você pode encontrar a lista completa dos tipos de coluna disponíveis na documentação do Laravel.

      Após incluir as duas linhas destacadas em seu próprio script de migration, salve e feche o arquivo.

      Agora, sua migration está pronta para ser executada através do artisan migrate. No entanto, isso criaria apenas uma tabela vazia; também precisamos conseguir inserir dados da amostra para o desenvolvimento e teste. No próximo passo, veremos como fazer isso usando os seeders de banco de dados.

      Passo 5 — Criando os Seeders de banco de dados

      Um seeder é uma classe especial utilizada para gerar e inserir dados de amostra (seeds) em um banco de dados. Essa é uma característica importante em ambientes de desenvolvimento, uma vez que permite que você recrie o aplicativo com um banco de dados novo, usando valores de amostra que, de qualquer forma você teria que inserir manualmente toda vez que o banco de dados fosse recriado.

      Agora, utilizaremos o comando artisan para gerar uma nova classe de seeders para nossa tabela de places chamada PlacesTableSeeder:

      • docker-compose exec app php artisan make:seeder PlacesTableSeeder

      O comando criará um novo arquivo chamado PlacesTableSeeder.php dentro do diretório database/seeds. Abra aquele arquivo usando seu editor de texto preferido:

      • nano database/seeds/PlacesTableSeeder.php

      É assim que o arquivo PlacesTableSeeder.php, gerado automaticamente, se parece:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      
      class PlacesTableSeeder extends Seeder
      {
          /**
           * Run the database seeds.
           *
           * @return void
           */
          public function run()
          {
              //
          }
      }
      
      

      Nossa nova classe de seeder contém um método vazio chamado run. Esse método será chamado quando o comando db:seed do Artisan for executado.

      Precisamos editar o método run para incluir instruções para inserir dados de amostra no banco de dados. Vamos utilizar o compilador de consultas do Laravel para simplificar esse processo.

      O compilador de consultas do Laravel oferece uma interface fluente para as operações de banco de dados como a inserção, atualização e recuperação de dados. Ele também introduz proteções contra ataques de injeção de SQL. O compilador de consulta é exposto pela facade do DB – um proxy estático para as classes de banco de dados subjacentes no contêiner de serviço.

      Para começar, criaremos uma variável de classe estática para reter todos os locais das amostras que desejamos inserir no banco de dados como uma matriz. Isso nos permitirá usar um loop foreach para iterar em todos os valores, inserindo cada um no banco de dados utilizando o compilador de consulta.

      Chamaremos essa variável de $places:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      
      class PlacesTableSeeder extends Seeder
      {
          static $places = [
              'Berlin',
              'Budapest',
              'Cincinnati',
              'Denver',
              'Helsinki',
              'Lisbon',
              'Moscow',
              'Nairobi',
              'Oslo',
              'Rio',
              'Tokyo'
          ];

      Em seguida, precisaremos incluir uma instrução use no topo de nossa classe PlacesTableSeeder para facilitar a referência da facade DB em todo o código:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      use IlluminateSupportFacadesDB;
      
      class PlacesTableSeeder extends Seeder
      …
      

      Agora, podemos iterar através dos valores da matriz $places, usando um loop foreach e inserir cada um deles em nossa tabela places com o compilador de consultas:

      database/seeds/PlacesTableSeeder.php

      …
          public function run()
          {
              foreach (self::$places as $place) {
                  DB::table('places')->insert([
                      'name' => $place,
                      'visited' => rand(0,1) == 1
                  ]);
              }
          }
      
      

      O loop foreach itera através de cada valor da matriz estática $places. Em cada iteração, usamos a facade DB para inserir uma nova linha na tabela places. Definimos o campo name para o nome do lugar que acabamos de obter da matriz $places e definimos o campo visited para um valor aleatório de 0 ou 1.

      É assim que a classe PlacesTableSeeder completa se parecerá após todas as atualizações:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      use IlluminateSupportFacadesDB;
      
      class PlacesTableSeeder extends Seeder
      {
          static $places = [
              'Berlin',
              'Budapest',
              'Cincinnati',
              'Denver',
              'Helsinki',
              'Lisbon',
              'Moscow',
              'Nairobi',
              'Oslo',
              'Rio',
              'Tokyo'
          ];
      
          /**
           * Run the database seeds.
           *
           * @return void
           */
          public function run()
          {
              foreach (self::$places as $place) {
                  DB::table('places')->insert([
                      'name' => $place,
                      'visited' => rand(0,1) == 1
                  ]);
              }
          }
      }
      

      Salve e feche o arquivo quando terminar de fazer essas alterações.

      As classes do seeder não são carregadas automaticamente no aplicativo. Precisamos editar a classe principal, DatabaseSeeder, para incluir uma chamada para o seeder que acabamos de criar.

      Abra o arquivo database/seeds/DatabaseSeeder.php com o nano ou com o seu editor favorito:

      • nano database/seeds/DatabaseSeeder.php

      A classe DatabaseSeeder se parece com qualquer outro seeder: ela se estende a partir da classe Seeder e tem um método run. Atualizaremos esse método para incluir uma chamada para o PlacesTableSeeder.

      Atualize o método run atual, dentro da classe DatabaseSeeder, excluindo a linha comentada e substituindo-a pelo código destacado a seguir:

      database/seeds/DatabaseSeeder.php

      …
          public function run()
          {
              $this->call(PlacesTableSeeder::class);
          }
      ...
      

      É assim que a classe DatabaseSeeder completa se parecerá após a atualização:

      database/seeds/DatabaseSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      
      class DatabaseSeeder extends Seeder
      {
          /**
           * Seed the application's database.
           *
           * @return void
           */
          public function run()
          {
              $this->call(PlacesTableSeeder::class);
          }
      }
      
      
      

      Salve e feche o arquivo quando terminar de atualizar seu conteúdo.

      Agora, terminamos a configuração da migration e de um seeder para nossa tabela places. No próximo passo, veremos como executá-las.

      Passo 6 — Executando as migrations e os seeders do banco de dados

      Antes de prosseguir, precisamos garantir que seu aplicativo esteja em funcionamento. Vamos configurar a chave de criptografia do aplicativo e, depois, acessar o aplicativo a partir de um navegador para testar o servidor Web.

      Para gerar a chave de criptografia que o Laravel exige, utilize o comando artisan key:generate:

      • docker-compose exec app php artisan key:generate

      Assim que a chave tiver sido gerada, você poderá acessar o aplicativo, apontando seu navegador para o nome do host ou endereço IP do servidor na porta 8000:

      http://server_host_or_ip:8000
      

      Você verá uma página como esta:

      Erro do MySQL

      Isso significa que o aplicativo conseguiu conectar-se ao banco de dados, mas que não encontrou uma tabela chamada places. Vamos criar a tabela places agora, utilizando o comando do artisan migrate:

      • docker-compose exec app php artisan migrate

      Você obterá um resultado parecido com este:

      Output

      Migration table created successfully. Migrating: 2014_10_12_000000_create_users_table Migrated: 2014_10_12_000000_create_users_table (0.06 seconds) Migrating: 2014_10_12_100000_create_password_resets_table Migrated: 2014_10_12_100000_create_password_resets_table (0.06 seconds) Migrating: 2019_08_19_000000_create_failed_jobs_table Migrated: 2019_08_19_000000_create_failed_jobs_table (0.03 seconds) Migrating: 2020_02_10_144134_create_places_table Migrated: 2020_02_10_144134_create_places_table (0.03 seconds)

      Você verá que algumas outras migrations foram executadas junto com a migration create_places_table que configuramos. Essas migrations são geradas automaticamente quando o Laravel é instalado. Embora não estejamos usando essas tabelas adicionais agora, elas serão necessárias no futuro quando expandirmos o aplicativo para ele ter usuários registrados e trabalhos agendados. Por enquanto, deixe-as como estão.

      Neste ponto, nossa tabela ainda está vazia. Precisamos executar o comando db:seed para propagar o banco de dados com nossas amostras de locais:

      • docker-compose exec app php artisan db:seed

      Isso executará nosso seeder e irá inserir os valores da amostra que definimos dentro da nossa classe PlacesTableSeeder. Você verá um resultado semelhante a este:

      Output

      Seeding: PlacesTableSeeder Seeded: PlacesTableSeeder (0.06 seconds) Database seeding completed successfully.

      Agora, recarregue a página do aplicativo no seu navegador. Você verá uma página parecida com esta:

      Demo do aplicativo Laravel

      Sempre que precisar começar do zero, você poderá remover todas as tabelas de banco de dados com:

      • docker-compose exec app php artisan db:wipe

      Output

      Dropped all tables successfully.

      Para executar o aplicativo migrations e propagar as tabelas em um único comando, utilize:

      • docker-compose exec app php artisan migrate --seed

      Output

      Migration table created successfully. Migrating: 2014_10_12_000000_create_users_table Migrated: 2014_10_12_000000_create_users_table (0.06 seconds) Migrating: 2014_10_12_100000_create_password_resets_table Migrated: 2014_10_12_100000_create_password_resets_table (0.07 seconds) Migrating: 2019_08_19_000000_create_failed_jobs_table Migrated: 2019_08_19_000000_create_failed_jobs_table (0.03 seconds) Migrating: 2020_02_10_144134_create_places_table Migrated: 2020_02_10_144134_create_places_table (0.03 seconds) Seeding: PlacesTableSeeder Seeded: PlacesTableSeeder (0.06 seconds) Database seeding completed successfully.

      Se quiser reverter uma migration, você pode executar:

      • docker-compose exec app php artisan migrate:rollback

      Isso acionará o método down para cada classe de migration dentro da pasta migrations. Normalmente, ele removerá todas as tabelas que foram criadas através das classes de migration, deixando sozinha quaisquer outras tabelas que possam ter sido criadas manualmente. Você verá um resultado como este:

      Output

      Rolling back: 2020_02_10_144134_create_places_table Rolled back: 2020_02_10_144134_create_places_table (0.02 seconds) Rolling back: 2019_08_19_000000_create_failed_jobs_table Rolled back: 2019_08_19_000000_create_failed_jobs_table (0.02 seconds) Rolling back: 2014_10_12_100000_create_password_resets_table Rolled back: 2014_10_12_100000_create_password_resets_table (0.02 seconds) Rolling back: 2014_10_12_000000_create_users_table Rolled back: 2014_10_12_000000_create_users_table (0.02 seconds)

      O comando de reversão é especialmente útil quando estiver fazendo alterações nos modelos do aplicativo e um comando db:wipe não puder ser usado – por exemplo, caso vários sistemas dependerem de um mesmo banco de dados.

      Conclusão

      Neste guia, vimos como usar as migrations e os seeders de banco de dados para facilitar a configuração de bancos de dados para desenvolvimento e teste para um aplicativo Laravel 6.

      Como um passo seguinte, talvez você queira conferir a documentação do Laravel para obter mais informações sobre como usar o compilador de consultas e como usar os Modelos eloquentes para se concentrar ainda mais no esquema do banco de dados do seu aplicativo.



      Source link

      How To Use Database Migrations and Seeders to Abstract Database Setup in Laravel


      Migrations and seeders are powerful database utilities provided by the Laravel PHP framework to allow developers to quickly bootstrap, destroy and recreate an application’s database. These utilities help to minimize database inconsistency problems that can arise with multiple developers working on the same application: new contributors need only to run a couple artisan commands to set the database up on a fresh install.

      In this guide, we’ll create migrations and seeders to populate a Laravel demo application’s database with sample data. At the end, you will be able to destroy and recreate your database tables as many times as you want, using only artisan commands.

      Prerequisites

      In order to follow this guide, you’ll need:

      Note: In this guide, we’ll use a containerized development environment managed by Docker Compose to run the application, but you may also opt to run the application on a LEMP server. To set this up, you can follow our guide on How to Install and Configure Laravel with LEMP on Ubuntu 18.04.

      Step 1 — Obtaining the Demo Application

      To get started, we’ll fetch the demo Laravel application from its GitHub repository. We’re interested in the tutorial-02 branch, which includes a Docker Compose setup to run the application on containers. In this example, we’ll download the application to our home folder, but you can use any directory of your choice:

      • cd ~
      • curl -L https://github.com/do-community/travellist-laravel-demo/archive/tutorial-2.0.1.zip -o travellist.zip

      Because we downloaded the application code as a .zip file, we’ll need the unzip command to unpack it. If you haven’t done so recently, update your machine’s local package index:

      Then install the unzip package:

      Following that, unzip the contents of the application:

      Then rename the unpacked directory to travellist-demo for easier access:

      • mv travellist-laravel-demo-tutorial-2.0.1 travellist-demo

      In the next step, we’ll create a .env configuration file to set up the application.

      Step 2 — Setting Up the Application’s .env File

      In Laravel, a .env file is used to set up environment-dependent configurations, such as credentials and any information that might vary between deployments. This file is not included in revision control.

      Warning: The environment configuration file contains sensitive information about your server, including database credentials and security keys. For that reason, you should never share this file publicly.

      The values contained in the .env file will take precedence over the values set in regular configuration files located in the config directory. Each installation on a new environment requires a tailored environment file to define things such as database connection settings, debug options, and the application URL, among other items that may vary depending on which environment the application is running.

      Navigate to the travellist-demo directory:

      We’ll now create a new .env file to customize the configuration options for the development environment we’re setting up. Laravel comes with an example.env file that we can copy to create our own:

      Open this file using nano or your text editor of choice:

      This is how your .env file looks like now:

      .env

      APP_NAME=Travellist
      APP_ENV=dev
      APP_KEY=
      APP_DEBUG=true
      APP_URL=http://localhost:8000 
      
      LOG_CHANNEL=stack
      
      DB_CONNECTION=mysql
      DB_HOST=db
      DB_PORT=3306
      DB_DATABASE=travellist
      DB_USERNAME=travellist_user
      DB_PASSWORD=password

      The current .env file from the travellist demo application contains settings to use the containerized environment we’ve created with Docker Compose in the last part of this series. You don’t need to change any of these values, but you are free to modify the DB_DATABASE, DB_USERNAME and DB_PASSWORD if you wish, since these are pulled by our docker-compose.yml file automatically to set up the development database. Just make sure the DB_HOST variable remains unchanged, since it references the name of our database service within the Docker Compose environment.

      If you make any changes to the file, make sure to save and close it by pressing CTRL + X, Y, then ENTER.

      Note: If you have opted to run the application on a LEMP server, you’ll need to change the highlighted values to reflect your own database settings, including the DB_HOST variable.

      Step 3 — Installing Application Dependencies with Composer

      We’ll now use Composer, PHP’s dependency management tool, to install the application’s dependencies and make sure we’re able to execute artisan commands.

      Bring up your Docker Compose environment with the following command.
      This will build the travellist image for the app service and pull in the additional Docker images required by the nginx and db services, in order to create the application environment:

      Output

      Creating network "travellist-demo_travellist" with driver "bridge" Building app Step 1/11 : FROM php:7.4-fpm ---> fa37bd6db22a Step 2/11 : ARG user ---> Running in 9259bb2ac034 … Creating travellist-app ... done Creating travellist-nginx ... done Creating travellist-db ... done

      This operation might take a few minutes to complete. Once the process is finished, we can run Composer to install the application’s dependencies.

      To execute composer and other commands in the app service container, we’ll use docker-compose exec. The exec command allows us to execute any command of our choice on containers managed by Docker Compose. It uses the following syntax: docker-compose exec service_name command.

      Note: In case you have opted to use a LEMP server to run the demo application, you should ignore the docker-compose exec app portion of the commands listed throughout this guide. For example, instead of running the following command as it’s written, you would just run:

      To execute composer install in the app container, run:

      • docker-compose exec app composer install

      Output

      Loading composer repositories with package information Installing dependencies (including require-dev) from lock file Package operations: 85 installs, 0 updates, 0 removals - Installing doctrine/inflector (1.3.1): Downloading (100%) - Installing doctrine/lexer (1.2.0): Downloading (100%) - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%) …

      When Composer is finished installing the application’s dependencies, you’ll be able to execute artisan commands. To test that the application is able to connect to the database, run the following command which will clean up any pre-existing tables:

      • docker-compose exec app php artisan db:wipe

      This command will drop any pre-existing tables on the configured database. If it ran successfully and the application is able to connect to the database, you’ll see output like this:

      Output

      Dropped all tables successfully.

      Now that you have installed the application dependencies with Composer, you can use the artisan tool to create migrations and seeders.

      Step 4 — Creating Database Migrations

      The artisan command line tool that ships with Laravel contains a series of helper commands that can be used to manage the application and bootstrap new classes. To generate a new migration class, we can use the make:migration command as follows:

      • docker-compose exec app php artisan make:migration create_places_table

      Laravel infers the operation to be executed (create), the name of the table (places), and whether this migration will create a new table or not, based on the descriptive name provided to the make:migration command.

      You’ll see output similar to this:

      Output

      Created Migration: 2020_02_03_143622_create_places_table

      This will generate a new file in the application’s database/migrations directory. The timestamp included in the auto-generated file is used by Laravel to determine in which order migrations should be executed.

      Use your text editor of choice to open the generated migration file. Remember to replace the highlighted value with your own migration file name:

      • nano database/migrations/2020_02_03_143622_create_places_table.php

      The generated migration file contains a class called CreatePlacesTable:

      database/migrations/2020_02_03_143622_create_places_table.php

      <?php
      
      use IlluminateDatabaseMigrationsMigration;
      use IlluminateDatabaseSchemaBlueprint;
      use IlluminateSupportFacadesSchema;
      
      class CreatePlacesTable extends Migration
      {
          /**
           * Run the migrations.
           *
           * @return void
           */
          public function up()
          {
              Schema::create('places', function (Blueprint $table) {
                  $table->bigIncrements('id');
                  $table->timestamps();
              });
          }
      
          /**
           * Reverse the migrations.
           *
           * @return void
           */
          public function down()
          {
              Schema::dropIfExists('places');
          }
      }
      
      

      This class has two methods: up and down. Both methods contain bootstrap code that you can extend to customize what happens when that migration is executed and also what happens when it is rolled back.

      We’ll modify the up method so that the places table reflects the structure we’re already using in the current application’s version:

      • id: primary key field.
      • name: name of the place.
      • visited: whether or not this place was already visited.

      The Laravel schema builder exposes methods for creating, updating and deleting tables in a database. The Blueprint class defines the table’s structure and it provides several methods to abstract the definition of each table field.

      The auto-generated code sets up a primary id field called id. The timestamps method creates two datetime fields that are automatically updated by the underlying database classes when data is inserted or updated within that table. In addition to these, we’ll need to include a name and a visited field.

      Our name field will be of type string, and our visited field will be set with the boolean type. We’ll also set a default value of 0 for the visited field, so that if no value is passed, it means the place was not visited yet. This is how the up method will look like now:

      database/migrations/2020_02_03_143622_create_places_table.php

      …
          public function up()
          {
              Schema::create('places', function (Blueprint $table) {
                  $table->bigIncrements('id');
                  $table->string('name', 100);
                  $table->boolean('visited')->default(0);
                  $table->timestamps();
              });
          }
      …
      

      Note: You can find the full list of available column types in the Laravel documentation.

      After including the two highlighted lines on your own migration script, save and close the file.

      Your migration is now ready to be executed via artisan migrate. However, that would only create an empty table; we also need to be able to insert sample data for development and testing. In the next step, we’ll see how to do that using database seeders.

      Step 5 — Creating Database Seeders

      A seeder is a special class used to generate and insert sample data (seeds) in a database. This is an important feature in development environments, since it allows you to recreate the application with a fresh database, using sample values that you’d otherwise have to manually insert each time the database is recreated.

      We’ll now use the artisan command to generate a new seeder class for our places table called PlacesTableSeeder:

      • docker-compose exec app php artisan make:seeder PlacesTableSeeder

      The command will create a new file called PlacesTableSeeder.php inside the database/seeds directory. Open that file using your text editor of choice:

      • nano database/seeds/PlacesTableSeeder.php

      This is what the auto-generated PlacesTableSeeder.php file looks like:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      
      class PlacesTableSeeder extends Seeder
      {
          /**
           * Run the database seeds.
           *
           * @return void
           */
          public function run()
          {
              //
          }
      }
      
      

      Our new seeder class contains an empty method named run. This method will be called when the db:seed Artisan command is executed.

      We need to edit the run method in order to include instructions to insert sample data in the database. We’ll use the Laravel query builder to streamline this process.

      The Laravel query builder offers a fluent interface for database operations such as inserting, updating, deleting, and retrieving data. It also introduces safeguards against SQL injection attacks. The query builder is exposed by the DB facade - a static proxy to underlying database classes in the service container.

      To get started, we’ll create a static class variable to hold all the sample places we want to insert into the database as an array. This will allow us to use a foreach loop to iterate through all values, inserting each one in the database using the query builder.

      We’ll call this variable $places:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      
      class PlacesTableSeeder extends Seeder
      {
          static $places = [
              'Berlin',
              'Budapest',
              'Cincinnati',
              'Denver',
              'Helsinki',
              'Lisbon',
              'Moscow',
              'Nairobi',
              'Oslo',
              'Rio',
              'Tokyo'
          ];

      Next, we’ll need to include a use statement at the top of our PlacesTableSeeder class to facilitate referencing the DB facade throughout the code:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      use IlluminateSupportFacadesDB;
      
      class PlacesTableSeeder extends Seeder
      …
      

      We can now iterate through the $places array values using a foreach loop, and insert each one in our places table using the query builder:

      database/seeds/PlacesTableSeeder.php

      …
          public function run()
          {
              foreach (self::$places as $place) {
                  DB::table('places')->insert([
                      'name' => $place,
                      'visited' => rand(0,1) == 1
                  ]);
              }
          }
      
      

      The foreach loop iterates through each value of the $places static array. At each iteration, we use the DB facade to insert a new row at the places table. We set the name field to the name of the place we just obtained from the $places array, and we set the visited field to a random value of either 0 or 1.

      This is what the full PlacesTableSeeder class will look like after all the updates:

      database/seeds/PlacesTableSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      use IlluminateSupportFacadesDB;
      
      class PlacesTableSeeder extends Seeder
      {
          static $places = [
              'Berlin',
              'Budapest',
              'Cincinnati',
              'Denver',
              'Helsinki',
              'Lisbon',
              'Moscow',
              'Nairobi',
              'Oslo',
              'Rio',
              'Tokyo'
          ];
      
          /**
           * Run the database seeds.
           *
           * @return void
           */
          public function run()
          {
              foreach (self::$places as $place) {
                  DB::table('places')->insert([
                      'name' => $place,
                      'visited' => rand(0,1) == 1
                  ]);
              }
          }
      }
      

      Save and close the file when you’re done making these changes.

      Seeder classes aren’t automatically loaded in the application. We need to edit the main DatabaseSeeder class to include a call to the seeder we’ve just created.

      Open the database/seeds/DatabaseSeeder.php file using nano or your favorite editor:

      • nano database/seeds/DatabaseSeeder.php

      The DatabaseSeeder class looks like any other seeder: it extends from the Seeder class and has a run method. We’ll update this method to include a call to PlacesTableSeeder.

      Update the current run method inside your DatabaseSeeder class by deleting the commented-out line and replacing it with the following highlighted code:

      database/seeds/DatabaseSeeder.php

      …
          public function run()
          {
              $this->call(PlacesTableSeeder::class);
          }
      ...
      

      This is how the full DatabaseSeeder class will look like after the update:

      database/seeds/DatabaseSeeder.php

      <?php
      
      use IlluminateDatabaseSeeder;
      
      class DatabaseSeeder extends Seeder
      {
          /**
           * Seed the application's database.
           *
           * @return void
           */
          public function run()
          {
              $this->call(PlacesTableSeeder::class);
          }
      }
      
      
      

      Save and close the file when you’re done updating its content.

      We have now finished setting up both a migration and a seeder for our places table. In the next step, we’ll see how to execute them.

      Step 6 — Running Database Migrations and Seeders

      Before proceeding, we need to make sure your application is up and running. We’ll set up the application encryption key and then access the application from a browser to test the web server.

      To generate the encryption key required by Laravel, you can use the artisan key:generate command:

      • docker-compose exec app php artisan key:generate

      Once the key has been generated, you’ll be able to access the application by pointing your browser to your server hostname or IP address on port 8000:

      http://server_host_or_ip:8000
      

      You’ll see a page like this:

      MySQL error

      That means the application is able to connect to the database, but it couldn’t find a table called places. We’ll create the places table now, using the following migrate artisan command:

      • docker-compose exec app php artisan migrate

      You’ll get output similar to this:

      Output

      Migration table created successfully. Migrating: 2014_10_12_000000_create_users_table Migrated: 2014_10_12_000000_create_users_table (0.06 seconds) Migrating: 2014_10_12_100000_create_password_resets_table Migrated: 2014_10_12_100000_create_password_resets_table (0.06 seconds) Migrating: 2019_08_19_000000_create_failed_jobs_table Migrated: 2019_08_19_000000_create_failed_jobs_table (0.03 seconds) Migrating: 2020_02_10_144134_create_places_table Migrated: 2020_02_10_144134_create_places_table (0.03 seconds)

      You’ll notice that a few other migrations were executed along with the create_places_table migration we’ve set up. These migrations are auto generated when Laravel is installed. Although we won’t be using these additional tables now, they will be needed in the future when we expand the application to have registered users and scheduled jobs. For now, you can just leave them as is.

      At this point our table is still empty. We need to run the db:seed command to seed the database with our sample places:

      • docker-compose exec app php artisan db:seed

      This will run our seeder and insert the sample values we defined within our PlacesTableSeeder class. You’ll see output similar to this:

      Output

      Seeding: PlacesTableSeeder Seeded: PlacesTableSeeder (0.06 seconds) Database seeding completed successfully.

      Now, reload the application page on your browser. You’ll see a page similar to this:

      Demo Laravel Application

      Whenever you need to start from scratch, you can drop all your database tables with:

      • docker-compose exec app php artisan db:wipe

      Output

      Dropped all tables successfully.

      To run the app migrations and seed the tables in a single command, you can use:

      • docker-compose exec app php artisan migrate --seed

      Output

      Migration table created successfully. Migrating: 2014_10_12_000000_create_users_table Migrated: 2014_10_12_000000_create_users_table (0.06 seconds) Migrating: 2014_10_12_100000_create_password_resets_table Migrated: 2014_10_12_100000_create_password_resets_table (0.07 seconds) Migrating: 2019_08_19_000000_create_failed_jobs_table Migrated: 2019_08_19_000000_create_failed_jobs_table (0.03 seconds) Migrating: 2020_02_10_144134_create_places_table Migrated: 2020_02_10_144134_create_places_table (0.03 seconds) Seeding: PlacesTableSeeder Seeded: PlacesTableSeeder (0.06 seconds) Database seeding completed successfully.

      If you want to roll back a migration, you can run:

      • docker-compose exec app php artisan migrate:rollback

      This will trigger the down method for each migration class inside the migrations folder. Typically, it will remove all the tables that were created through migration classes, leaving alone any other tables that might have been manually created. You’ll see output like this:

      Output

      Rolling back: 2020_02_10_144134_create_places_table Rolled back: 2020_02_10_144134_create_places_table (0.02 seconds) Rolling back: 2019_08_19_000000_create_failed_jobs_table Rolled back: 2019_08_19_000000_create_failed_jobs_table (0.02 seconds) Rolling back: 2014_10_12_100000_create_password_resets_table Rolled back: 2014_10_12_100000_create_password_resets_table (0.02 seconds) Rolling back: 2014_10_12_000000_create_users_table Rolled back: 2014_10_12_000000_create_users_table (0.02 seconds)

      The rollback command is especially useful when you’re making changes to application models and a db:wipe command can’t be used - for instance, if multiple systems depend on the same database.

      Conclusion

      In this guide, we’ve seen how to use database migrations and seeders to facilitate setting up development and testing databases for a Laravel 6 application.

      As a next step, you might want to check the Laravel documentation for more details on how to use the query builder, and how to use Eloquent models to abstract your application’s database schema even further.



      Source link