Aufbau der Magento 2-Serie
Hier erstmal ein kurzer Überblick über die einzelnen Kapitel in der Blogserie:
- Vorbereitung
- Frontend – Templates, Layouts, Blöcke
- Controller und Actions
- Models, Service Layer, Einführung Dependency Injection
- Wichtige Objekte in Magento 2
- Install-Scripts und Observer
- Backend: Templates, XML Dateien und Layouts
- Javascript
Im heutigen Beitrag stelle ich das Grundgerüst für Magento 2 Module vor.
Installation von Magento 2
Bevor wir mit der Entwicklung von unserem neuen Modul starten können, brauchen wir natürlich eine Magento-Installation. Magento 2 lässt sich vollständig über Composer installieren und verwalten. Man sollte daher zunächst Composer installieren. Wir werden das Tool später auch nutzen, um unser Modul zu installieren und zu aktualisieren.
Danach folgenden Befehl ausführen um Magento 2 über Composer herunterzuladen:
composer create-project magento/community-edition magento2 -s dev --prefer-dist
Der Befehl erstellt ein neues Composer Projekt auf Basis des aktuellen CE Releases. Dieser Shop dient als Test-Shop für unser neues Modul.
Wir werden während des Herunterladens eventuell nach zwei Dingen gefragt:
- Magento Connect Zugang
Um einige der Magento Pakete herunterladen zu können, wird ein Magento Connect Key benötigt. Dafür bei Magento Connect anmelden und unter „My Account“ → Developers → Secure Keys ein neues Schlüsselpaar generieren. Der Public Key dient als Benutzername, der Private Key als Passwort. - github OAuth Key
Github hat beim Klonen der einzelnen Pakete eine Zugangsbeschränkung. Um diese zu umgehen, in den Einstellungen ein Token generieren.
Sobald der Shop heruntergeladen ist, können wir mit der Installation starten. Dafür wechseln wir in das Shop-Verzeichnis und führen diese Befehle aus:
find . -type d -exec chmod 775 {} \; && find . -type f -exec chmod 664 {} \;
chmod +x bin/magento
bin/magento setup:install \
--db-host=mysql \
--db-name=magento2 \
--db-user=magento2 \
--db-password=magento2 \
--backend-frontname=admin \
--admin-user=admin \
--admin-password=admin123 \
--admin-email=magento2@example.org \
--admin-firstname=Admin \
--admin-lastname=Admin \
--base-url="http://magento2.local" \
--base-url-secure="https://magento2.local" \
--language=en_US \
--currency=EUR \
--use-rewrites=1 \
--use-secure=0 \
--use-secure-admin=0 \
--cleanup-database
Hinweis:
Zuerst die Datenbank anlegen!
Zuerst werden die Berechtigungen im Verzeichnis korrigiert und danach führen wir das neue Magento CLI Tool aus, um den Shop zu installieren. Die einzelnen Parameter lassen sich natürlich alle anpassen und sind selbsterklärend.
Sobald die Installation abgeschlossen ist, können wir noch die Beispiel-Daten installieren, um den Shop mit ein wenig Leben zu füllen. Dafür stellt Magento jetzt einen einfachen Befehl zur Verfügung:
bin/magento sampledata:deploy
bin/magento setup:upgrade
Der Befehl lädt alle Beispiel-Module herunter und installiert sie. Der zweite Befehl führt danach alle Install- und Upgradescripte durch.
Der Beispiel-Shop ist somit eingerichtet und wir können mit der Modulentwicklung starten!
Unser neues Magento 2 Modul
Das neue Modul lässt sich am einfachsten direkt über Composer einrichten. Das Modul direkt im Shop zu entwickeln ist eher umständlich und wird nicht empfohlen.
Wir generieren also außerhalb des Shops ein neues Verzeichnis. In diesem Verzeichnis wird unser neues Modul liegen. Um das Modul nachher einfach mit Composer installieren zu können, sollte eine Versionsverwaltung benutzt werden. An dieser Stelle verwende ich dafür git.
Um unser Modul installieren zu können, müssen wir jetzt drei Dateien erstellen, die jedes Modul benötigt.
Als Erstes wird die composer.json angelegt:
{
"name": "tudock/helloworld",
"description": "Tutorial Modul für die Magento 2 Blogserie.",
"require": {
"magento/magento-composer-installer": "*"
},
"type": "magento2-module",
"version": "0.0.1",
"autoload": {
"files": [ "registration.php" ],
"psr-4": {
"Tudock\\HelloWorld\\": ""
}
}
}
Diese Datei ist die Paketdatei für Composer. Unter „name“ befindet sich der Name des Paketes. Dieser besteht nur aus Kleinbuchstaben und hat das Format (package)/(modulname).
Unter „version“ können wir die aktuelle Version unseres Moduls eintragen. Wichtig zu wissen ist, dass diese Version für Magento selbst keine Bedeutung hat (auch nicht für Upgrade-Scripts). Composer verwendet sie allerdings um festzustellen, wann eine neue Version des Moduls verfügbar ist.
Der Eintrag unter „autoload“ teilt Composer mit, unser Modul unter „vendor/“ im Shop zu installieren. Es wird nicht nach app/code kopiert, sondern bleibt direkt unter vendor/tudock/helloworld, dort können wir damit entwickeln.
Als Nächstes braucht Magento eine PHP-Datei, um das Modul zu entdecken. Magento scannt den Shop an einigen Schlüsseldateien nach Scripts mit dem Namen registration.php. Diese Datei legen wir jetzt für unser Modul an:
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
<module name="Tudock_HelloWorld" setup_version="0.0.1" />
</config>
Wie man sieht, ist diese stark abgespeckt worden. Unter „name“ einfach wieder den Modulnamen eintragen. Unter „setup_version“ folgt dann noch einmal die Version des Moduls.
Tipp:
Magento 2 benutzt XML Schema Definitionen für die verschiedenen XML Dateien. Der Link zur Schema-Datei steht unter „xsi:noNamespaceSchemaLocation“.
Dieser Link wird von Magento aufgelöst und vom eigenen IDE meist nicht verstanden. Um für phpstorm eine Datei zu erstellen, die die Pfade auflöst, bringt Magento direkt einen Befehl mit:
cd bin/magento dev:urn-catalog:generate /.idea/misc.xml
Dieser Befehl speichert die Datei gleich am richtigen Ort für phpstorm. Support für weitere IDEs soll in Zukunft folgen.
Das Magento 2 Modul installieren
Unser kleines Demo-Modul ist jetzt schon bereit für die Installation. Um das Modul zu installieren, müssen wir die composer.json im Shop anpassen. Dafür „repositories“ um einen Eintrag erweitern:
"repositories": [
{
"type": "composer",
"url": "https://repo.magento.com/"
},
{
"type": "vcs",
"url": "/pfad/zum/Modul/"
}
],
Wir tragen unser Paket als Composer Repository via Version Control System ein. So eingerichtet wird Composer mit jedem Commit eine neue Version des Moduls registrieren, das heißt, wir können mit jedem Commit updaten. Es ist auch möglich, Commits mit Versionen zu taggen. Wer mehr über das Zusammenspiel von Composer und git wissen möchte – eine Recherche zu diesem Thema ist lohnenswert.
Um unser Modul zum Shop hinzuzufügen, müssen wir jetzt folgende Befehle eingeben:
cd
# Installiere das Modul via Composer
composer require tudock/helloworld @dev # Name des Paketes in der composer.json unseres Moduls
# @dev zwingt Composer das Modul zu installieren obwohl es als zu instabil eingestuft wird
# Aktiviere das Modul
bin/magento module:enable Tudock_HelloWorld
# Upgrade Magento (richte Datenbanken etc. ein)
bin/magento setup:upgrade
Der letzte Befehl ist notwendig, da Magento Install- und Upgrade Logik nicht mehr automatisch ausführt. Wenn ein Modul aktiviert wird ohne den letzten Befehl auszuführen, kann dies den ganzen Shop lahmlegen.
Die Warnung am Ende darf im Entwicklungsmodus (Standard) ignoriert werden. Was sie genau bedeutet, erläutere ich in den nächsten Teilen der Blogserie.
Als Letztes ist es gut, den Cache zu leeren:
bin/magento cache:flush
Damit sind wir fertig! Um das Modul in Zukunft zu updaten (das geht mit jedem neuen Commit) folgende Befehle ausführen:
composer update
bin/magento setup:upgrade
Jetzt können wir sehen, ob unser Modul wirklich installiert wurde.
Hinweis:
Sollte beim Shop-Aufruf ein Fehler angezeigt werden, ist das wahrscheinlich ein Berechtigungsproblem. Dieses kann auftreten, wenn bin/magento über einen anderen Benutzer ausgeführt wird als der Webserver. Um das Problem zu lösen, müssen die Berechtigungen am var/generation Ordner korrigiert werden.
Testen
Wenn der Shop läuft, loggen wir uns ins Backend ein. Das Backend findet sich unter /admin.
Dort angemeldet finden wir unter STORES/Configuration (bzw. Konfiguration) die altbekannten Einstellungen wieder.
Unter Erweitert/Erweitert liegt – wie in Magento 1 auch – eine Liste von Modulen, um die Ausgabe von Blöcken der Module abzuschalten. Wenn wir in dieser Liste den Namen unseres Moduls finden, haben wir es geschafft:
Also, der erste Schritt ist abgeschlossen! Wir haben jetzt eine solide Grundlage, um einen Shop und ein Modul aufzusetzen.
Wer sich den Code der einzelnen Teile von diesem Tutorial noch einmal ansehen will, findet das HelloWorld Modul bei github. Die einzelnen Kapitel aus der Blogserie sind getaggt.
Im nächsten Beitrag gehe ich auf die Veränderungen in der Frontend-Entwicklung (Templates/Layouts) ein, ehe wir uns dann auf Models und Dependency Injection stürzen…
Update 20.04.2016:
Ich habe die composer.json für das Modul etwas an die „neue“ Art, Module in Magento 2 zu laden, angepasst. Statt wie vorher über „extra/map“ die Module nach „app/code“ zu kopieren, wird das Modul jetzt dank „autoload“ direkt aus dem vendor Verzeichnis geladen. Will man das Modul also im Shop bearbeiten, macht man dies direkt im vendor-Verzeichnis. Vorteil: Die Git-Versionierung bleibt vorhanden und es kann direkt im Shop entwickelt werden.
Der Unteschied zur alten Methode findet sich in diesem Commit.
Außerdem habe ich bei der Gelegenheit das „Inhaltsverzeichnis“ etwas aktualisiert.
Die weiteren Beiträge der Serie
- Magento 2 Modulentwicklung – Teil 2: Frontend Entwicklung
- Magento 2 Modulentwicklung – Teil 3: Controller und Actions
- Magento 2 Modulentwicklung – Teil 4: Models und Dependency Injection
- Magento 2 Modulentwicklung – Teil 5: Wichtige Objekte
- Magento 2 Modulentwicklung – Teil 6: Resource Models und Install-Scripts
- Magento 2 Modulentwicklung – Teil 7: Observer, Helper und Fazit