Logo run_as_root - Magento B2B Agentur Würzburg

Magento 2 Entwicklung mit Nix und Rooter

Technical
Magento 2 Entwicklung mit Nix und Rooter

Inhalte

2023 bin ich von Linux auf macOS umgestiegen. Linux habe ich jahrelang benutzt, hauptsächlich weil es Docker nativ unterstützt. Doch während eines System-Updates bin ich auf ein Problem mit dem Videotreiber gestoßen, das mich einen ganzen Samstag lang Lösungen suchen ließ – ich habe Dateien angepasst, von deren Existenz ich vorher keine Ahnung hatte. Am Ende des Tages fand ich endlich einen Workaround, damit der verdammte Nvidia-Treiber wieder funktionierte.

Am Montagmorgen erzählte ich einem Kollegen von meinem Tech-Albtraum – der prompt fragte:

„Warum wechselst du nicht einfach zu macOS?"

Ich antwortete: „Weil es keinen nativen Docker-Support hat und ich keine virtuelle Maschine nutzen will."

Bei einer virtuellen Maschine musst du einen ordentlichen Chunk RAM reservieren – ganz zu schweigen vom langsameren Festplattenzugriff. Für viele Anwendungen mag das keine große Rolle spielen, aber für eine Magento 2 Umgebung macht das einen riesigen Unterschied.

„Warum brauchst du überhaupt Docker?" fragte er.

Das hat zu einem kurzen Gespräch geführt, in dem er mich mit Nix und Devenv bekannt gemacht hat.

Mit diesen Tools lässt sich eine vollständig reproduzierbare Entwicklungsumgebung aufbauen – und das nativ auf macOS!

Es war Liebe auf den ersten Blick! Als ich es in Aktion sah, hat es mich umgehauen!

Begeisterter Hund

In diesem Gespräch bin ich zum ersten Mal auf eine frühe Version von Rooter gestoßen.

Rooter ist ein leistungsstarkes CLI-Tool, das repetitive Aufgaben beim Erstellen und Verwalten von Entwicklungsumgebungen automatisiert.

Kurz darauf habe ich mir ein MacBook gekauft und angefangen, `rooter` für meine Projekte zu nutzen. Heute habe ich kein Docker mehr auf meinem Rechner – und ich könnte nicht glücklicher sein!

Voraussetzungen

Du brauchst macOS und die folgenden installierten Tools:

Folge einfach den Anweisungen in der `rooter` Dokumentation.

Hier eine kurze Einführung zu diesen Tools:

  • rooter ist ein CLI-Tool, das von Matthias Walter entwickelt wurde. Es wird dein bester Freund während deiner Entwicklung. Es ist vergleichbar mit Warden oder DDEV. Es kümmert sich um Dinge wie automatische DNS-Auflösung mit dnsmasq, die Verwaltung von Projektrouten mit Traefik, die Erstellung von SSL-Zertifikaten sowie nützliche Befehle zum Importieren und Exportieren von Datenbanken – und vieles mehr.
  • nix existiert seit 2003 und ist extrem zuverlässig. Es ist wie ein Werkzeugkasten mit vielen nützlichen Werkzeugen: eine Programmiersprache, ein Betriebssystem und ein Paketmanager. Es hilft dir, Software-Systeme konsistent und leicht reproduzierbar zu machen.
  • devenv ist so etwas wie docker-compose, aber viel mächtiger. Es ist, als könntest du eine Programmiersprache verwenden, um deine Umgebung einzurichten – mit noch mehr Kontrolle und Flexibilität.
  • direnv ist ein Tool, das automatisch alle benötigten Abhängigkeiten für dein aktuelles Projekt lädt, sobald du in dessen Ordner wechselst. Wie das genau funktioniert, werden wir gleich sehen.

Eine Magento 2 Entwicklungsumgebung erstellen

Kommen wir direkt zum Punkt – richten wir eine Entwicklungsumgebung für Magento 2 ein.

Ich gehe davon aus, dass du `rooter` und alle notwendigen Tools bereits installiert und einsatzbereit hast. Los geht's!

  1. Das Projektverzeichnis erstellen
    mkdir -p ~/Sites/magento2
  2. In das erstellte Verzeichnis wechseln
    cd ~/Sites/magento2
  3. Die Umgebung mit rooter erstellen
    rooter env:create

    Rooter fragt dich, welchen Umgebungstyp du verwenden möchtest:

    Rooter Umgebungstyp-Auswahl

    Gib 2 ein und bestätige mit Enter für Magento 2.

    Es wurden 4 Dateien generiert:

    • .env
    • .envrc
    • devenv.nix
    • devenv.yaml
  4. direnv die Ausführung erlauben

    Du hast wahrscheinlich diese Meldung in deinem Terminal gesehen:

    direnv blockiert

    Du musst direnv die Ausführung erlauben. Führe den folgenden Befehl aus:

    direnv allow .

    Jetzt siehst du in deinem Terminal etwas wie das hier:

    devenv lädt

    In diesem Moment wird dein in der devenv.nix-Datei deklarierter Dev-Stack heruntergeladen und konfiguriert. Das ist der längste Schritt. Warte, bis der Installationsprozess abgeschlossen ist.

    Wenn der Prozess abgeschlossen ist, siehst du etwas wie das hier:

    envrc laden abgeschlossen

    Schau dir jetzt dieses Bild an:

    direnv wechselt PHP-Version beim cd

    Hast du's bemerkt? Wenn ich nicht im Projektordner bin, ist die PHP-Version im Terminal eine andere – nicht 8.2. Sobald ich aber in den Projektordner wechsle, macht direnv seine Magie und lädt das gesamte Setup in das Terminal. Ziemlich cool, oder?

  5. Das Magento 2 Repository klonen
    composer create-project --repository-url=https://repo.magento.com/ magento/project-community-edition:2.4.6-p4 magento2-codebase

    Dadurch wird das Magento 2 Repository in ein Verzeichnis namens magento2-codebase geklont. Danach kopierst du alles aus dem magento2-codebase-Ordner in das aktuelle Verzeichnis und kannst das magento2-codebase-Verzeichnis mit dem folgenden Befehl löschen:

    cp -R magento2-codebase/* . && rm -Rf magento2-codebase
  6. Den Umgebungs-Stack starten

    Ich starte die Umgebung beim ersten Mal gerne im Debug-Modus, weil das detaillierte Ausgaben über die Initialisierung liefert und bei Problemen sofort sichtbar ist, was schiefläuft:

    rooter env:start --debug

    Beim ersten Start lädt devenv alle Services herunter – also auch nginx, opensearch, rabbitmq etc.

    rooter env:start --debug Ausgabe

    Nach dem ersten Start stoppe ich die Umgebung (CMD + c) und starte sie ohne das Debug-Flag neu:

    rooter env:start

    Der Grund: Ohne --debug läuft die Umgebung im Hintergrund statt im Vordergrund.

    Um den Status der Umgebung zu sehen, führe folgenden Befehl aus:

    rooter env:status

    Das sieht dann ungefähr so aus:

    rooter env:status Ausgabe

    Wie bereits erwähnt nutzt es process-compose im Hintergrund. Es gibt einen Befehl, um process-compose aufzurufen und ein Kontrollpanel zu bekommen, mit dem du die verschiedenen gestarteten Prozesse überwachen kannst.

    rooter env:process-compose

    Wie du im Bild unten siehst, kannst du ganz einfach zwischen den verschiedenen Services wechseln und deren Logs live verfolgen.

    process-compose UI
  7. Die Datenbank einrichten

    Führe den folgenden Befehl aus, um die Datenbank einzurichten:

    rooter magento2:db-install

    Rooter löscht und erstellt die Datenbank neu und führt standardmäßig folgende Befehle aus:

    • bin/magento setup:install
    • bin/magento setup:upgrade
    • bin/magento indexer:reindex

    Ein Admin-Benutzer wird mit dem Benutzernamen admin und dem Passwort admin123 erstellt.

    Mit der Option --config-data-import wird zusätzlich der Befehl bin/magento config:data:import config/store dev/rooter ausgeführt.

    Hinweis: Der Befehl config:data:import wird vom Modul Magento2-ConfigImportExport bereitgestellt. Du musst es installieren, um die Option --config-data-import nutzen zu können.

    Du kannst den Reindex mit der Option --skip-reindex überspringen.

    Führe die folgenden Befehle aus, um zusätzliche Konfigurationen zu setzen:

    bin/magento config:set web/unsecure/base_url https://magento2.rooter.test/ && \
    bin/magento config:set web/secure/base_url https://magento2.rooter.test/ && \
    bin/magento config:set web/secure/offloader_header X-Forwarded-Proto && \
    bin/magento config:set web/secure/use_in_frontend 1 && \
    bin/magento config:set web/secure/use_in_adminhtml 1 && \
    bin/magento config:set web/seo/use_rewrites 1 && \
    bin/magento config:set catalog/search/enable_eav_indexer 1 && \
    bin/magento config:set dev/static/sign 0 && \
    bin/magento deploy:mode:set -s developer && \
    bin/magento cache:clean

    Das sind die URLs für Frontend und Admin:

    Tcharaaam!

    Erfolgsfeier

    Was mich wirklich umhaut, ist die Geschwindigkeit. Magento nativ auf dem Mac zu betreiben macht alles super schnell und reibungslos.

Rooter Anhang

Das .devenv Verzeichnis

Das .devenv-Verzeichnis enthält Daten über das Profil, den Nix Garbage Collector, den Stack-Zustand usw.

Das Verzeichnis .devenv/state enthält einen Teil des Stack-Codes, z.B. für elasticsearch, mysql, php-fpm, nginx, rabbitmq etc.

Diese Ordner und deren Dateien musst du nicht anfassen.

.devenv Ordnerstruktur

Versionierung

Die folgenden Dateien und Ordner musst du nicht versionieren – füge sie deiner .gitignore-Datei hinzu:

  • .devenv
  • .direnv
  • .env

Diese Dateien solltest du versionieren:

  • .devenv.flake.nix
  • .envrc
  • devenv.lock
  • devenv.nix
  • devenv.yaml

Hinweis: Keine dieser Dateien wird von rooter benötigt. Sie werden von devenv und direnv verwendet.

Die wichtigsten Dateien im Detail

.env Datei:

Enthält alle Umgebungsvariablen, die in deinem Projekt-Stack verwendet werden.

.env Dateiinhalt

ROOTER_ENV_TYPE definiert den Umgebungstyp, mögliche Werte sind:

  • magento1
  • magento2
  • php-plan
  • shopware6
  • symfony

DEVENV_HTTP_PORT definiert den HTTP-Port des Nginx-Webservers

DEVENV_HTTPS_PORT definiert den HTTPS (SSL)-Port des Nginx-Webservers

DEVENV_DB_PORT definiert den MySQL/MariaDB/Percona Datenbankport

Hinweis: In der aktuellen Version von rooter wird nur Mysql* unterstützt. Mysql* bedeutet alle Versionen und Forks, also z.B. MariaDB, Percona etc.

DEVENV_MAIL_SMTP_PORT definiert den mailpit SMTP-Port

DEVENV_MAIL_UI_PORT definiert den mailpit Benutzeroberflächen-Port

DEVENV_REDIS_PORT — der Name erklärt sich von selbst :)

DEVENV_AMQP_PORT definiert den RabbitMQ-Port, der in deiner Anwendung verwendet wird

DEVENV_AMQP_MANAGEMENT_PORT definiert das RabbitMQ-Adminpanel

DEVENV_ELASTICSEARCH_PORT definiert den ElasticSearch-Port, der in deiner Anwendung verwendet wird

DEVENV_ELASTICSEARCH_TCP_PORT — der Name erklärt sich von selbst :)

DEVENV_PROCESS_COMPOSE_PORT — der Name erklärt sich von selbst :)

Mehr über process-compose werden wir später sehen.

Falls du dich fragst, woher die Werte der in diesen Variablen definierten Ports stammen:

Rooter hat einen Mechanismus, der verfügbare Ports in deiner Umgebung ermittelt – unter Berücksichtigung der bereits von rooter erstellten Umgebungen.

Es werden Ports in bestimmten Bereichen vergeben. Wie das genau funktioniert, siehst du in dieser Datei:

PortManager Quellcode

.envrc Datei:

.envrc Dateiinhalt

Diese Datei wird vom direnv-Tool verwendet.

Sie lädt den gesamten deklarierten Stack in den aktuellen Terminal-Kontext.

devenv.nix Datei:

Diese Datei wird von devenv verwendet. Sie nutzt die Nix-Sprache, um die Umgebung zu deklarieren. Mehr Informationen dazu findest du hier.

Schauen wir uns die wichtigsten Teile dieser Datei genauer an:

{ pkgs, inputs, lib, config, ... }:

In Nix ist das wie die Definition einer Funktionsvorlage. Es besagt, dass die Funktion mindestens diese vier Dinge bekommt: pkgs, inputs, lib und config. Über das ... können aber auch weitere Parameter übergeben werden.

let
  rooterBin = if builtins.getEnv "ROOTER_BIN" != "" then builtins.getEnv "ROOTER_BIN" else "rooter";
  composerPhar = builtins.fetchurl{
    url = "https://github.com/composer/composer/releases/download/2.2.22/composer.phar";
    sha256 = "1lmibmdlk2rsrf4zr7xk4yi5rhlmmi8f2g8h2izb8x4sik600dbx";
  };
  magerun2Phar = builtins.fetchurl{
    url = "https://github.com/netz98/n98-magerun2/releases/download/7.2.0/n98-magerun2.phar";
    sha256 = "0z1dkxz69r9r9gf8xm458zysa51f1592iymcp478wjx87i6prvn3";
  };
in {

Der let...in-Block in der devenv.nix-Datei definiert einen Gültigkeitsbereich für lokale Definitionen, die später im Ausdruck verwendet werden können.

Ein Überblick über die Komponenten des let-Blocks:

  • rooterBin: Wird anhand der Umgebungsvariable ROOTER_BIN definiert. Falls gesetzt, wird deren Wert verwendet; andernfalls wird "rooter" als Standard genutzt. Ermöglicht flexible Konfiguration.
  • composerPhar/magerun2Phar: Lädt das Composer PHAR und das n98-magerun2 PHAR von GitHub herunter – mit URL und sha256-Hash zur Sicherheit.
dotenv.enable = true;
env = {
  PROJECT_NAME = "magento2";
  PROJECT_HOST = "magento2.rooter.test";

  NGINX_PKG_ROOT = pkgs.nginx;
  DEVENV_STATE_NGINX = "${config.env.DEVENV_STATE}/nginx";

  DEVENV_PHPFPM_SOCKET = "${config.env.DEVENV_STATE}/php-fpm.sock";

  DEVENV_DB_NAME = "app";
  DEVENV_DB_USER = "app";
  DEVENV_DB_PASS = "app";

  DEVENV_AMQP_USER = "guest";
  DEVENV_AMQP_PASS = "guest";
};

Der env-Block deklariert die Umgebungsvariablen.

Die Domain des Projekts wird durch die Variable PROJECT_HOST bestimmt. Das Projekt ist dann unter https://magento2.rooter.test erreichbar.

Falls du den Wert von PROJECT_HOST ändern möchtest, folge den Anweisungen hier.

Benutzerdefinierte Subdomains sind ebenfalls möglich. Mehr dazu hier.

Zur Info: Datenbankname, Benutzer und Passwort sind standardmäßig alle auf "app" gesetzt. Du kannst diese Einstellungen jederzeit anpassen.

Ebenso sind Benutzername und Passwort für RabbitMQ standardmäßig "guest". Ändere diese nach Bedarf.

PHP-Konfiguration in devenv.nix

Hier definieren und konfigurieren wir PHP. Wenn du die PHP-Version wechseln möchtest, ändere einfach den hervorgehobenen Bereich im Bild.

MariaDB-Konfiguration in devenv.nix

Genauso für die MariaDB-Version. Wenn du eine andere Version brauchst, änderst du es einfach.

Um zu sehen, welche Versionen unterstützt werden, kannst du direkt auf der Nix Packages-Seite suchen, zum Beispiel:

Nix Packages suchen

Hinweis: Wir verwenden den unstable-Channel – das ist der Standardkanal für devenv, weil er mehr und neuere Pakete enthält. Vergiss also nicht, beim Suchen den unstable-Channel auszuwählen.

OpenSearch-Konfiguration in devenv.nix

Zu guter Letzt haben wir die RabbitMQ-Deklaration. Falls dein Projekt es nicht verwendet, entferne es einfach aus der devenv.nix-Datei. Wir passen das an :)

RabbitMQ-Konfiguration in devenv.nix

devenv.yaml Datei:

Diese Datei wird von devenv verwendet und deklariert die Paketquellen. Du kannst mehrere Inputs mit verschiedenen Channels angeben.

Das traefik Dashboard aufrufen

Um das traefik Dashboard aufzurufen, führe einfach rooter traefik:dashboard aus.

Traefik Dashboard

Die mailpit UI aufrufen

Mailpit ist ein Fork von mailhog, wird aktiv weiterentwickelt und erhält regelmäßig Updates.

Jede Umgebung hat ihre eigene URL nach diesem Muster:

https://PROJECT_NAME-mail.rooter.test

In unserem Fall lautet sie:

https://magento2-mail.rooter.test/

Mailpit UI

Hinweis: Die Variable PROJECT_NAME wird in der devenv.nix-Datei definiert.

Rooter Befehle

Um alle verfügbaren rooter Befehle zu sehen, führe einfach rooter commands aus. Das liefert dir eine vollständige Liste. Viel Spaß beim Entdecken!

Rooter verfügbare Befehle

Xdebug

Das Einzige, was du für Xdebug konfigurieren musst, ist diese Umgebungsvariable in deinem Terminal zu setzen:

export XDEBUG_CONFIG="idekey=PHPSTORM-XDEBUG"

Du kannst sie dauerhaft mit diesem Befehl hinzufügen:

echo 'export XDEBUG_CONFIG="idekey=PHPSTORM-XDEBUG"' >> ~/.zshrc

Damit kannst du dein Magento 2 Store sowohl über CLI als auch im Browser debuggen – ganz ohne weitere Konfiguration.

In PHPStorm musst du beispielsweise nur auf den "Bug"-Button klicken, um auf Xdebug-Verbindungen zu hören:

PHPStorm Xdebug Bug-Button

Falls du spezifische Szenarien hast, zu denen du Hilfe brauchst – zum Beispiel Magento mit mehreren Websites oder Store Views einrichten – hinterlasse deine Frage gerne in den Kommentaren. Ich helfe so gut ich kann!

Ich hoffe, das war hilfreich! 👋


Image from Bill Jelen on Unsplash

Deine Magento 2 Entwicklungsumgebung optimieren?

Sprich mit unserem Magento-Experten und entdecke, welche alternativen Entwicklungsumgebungen mit Nix und Rooter für dein Projekt passen.

Buche jetzt deinen Termin

Weitere Beiträge

Technical
/images/blog/blog_INP_corewebvitals_thumbnail.webp
Jordy Scholing Avatar

Jordy Scholing

14.11.25

INP debuggen: Von DevTools zu RUM-Daten