Genau hier setzt devenv an und verändert grundlegend, wie du lokal mit Shopware entwickelst. Statt auf träge Container-Lösungen zu setzen, bringt devenv alle Dienste nativ auf deinem System zum Laufen – mit einer Geschwindigkeit, die dich begeistern wird.
devenv steht für "development environment" und ist ein modernes Entwicklungs-Tool, das auf dem Nix-Paketmanager basiert. Anders als Docker oder andere Virtualisierungstechnologien verzichtet devenv komplett auf Container und führt stattdessen alle Dienste nativ auf deinem Betriebssystem aus.
Das Besondere: devenv erstellt für jedes Projekt eine isolierte Umgebung, ohne dabei die Performance zu beeinträchtigen. PHP, MySQL, Redis und alle anderen Komponenten laufen mit voller Systemgeschwindigkeit, während trotzdem jedes Projekt seine eigenen, spezifischen Versionen nutzen kann.
| Aspekt | devenv | Docker/MAMP |
|---|---|---|
| Startzeit | 2-3 Sekunden | 30-60 Sekunden |
| Performance | Native Systemgeschwindigkeit | Virtualisiert, langsamer |
| Ressourcenverbrauch | Minimal | Hoch (Container-Overhead) |
| Hot Reloading | Automatisch ohne Browser-Refresh | Manuelles Neuladen nötig |
| Versionsverwaltung | Pro Projekt unterschiedlich | Global oder komplex konfigurierbar |
Bevor du mit devenv durchstarten kannst, benötigst du Nix als Grundlage. Auf macOS und Linux installierst du Nix mit einem einzigen Befehl:
sh <(curl -L https://nixos.org/nix/install) --daemonWindows-Nutzer müssen zuerst WSL2 (Windows Subsystem for Linux) aktivieren und können dann über das Ubuntu-Terminal die gleichen Schritte durchführen.
Nach der Installation startest du ein neues Terminal und verifizierst die Installation:
nix --versionUm die Installation zu beschleunigen, konfigurierst du Cachix – einen Service, der vorgefertigte Pakete bereitstellt:
nix-env -iA cachix -f https://cachix.org/api/v1/install
cachix use devenv
cachix use shopwareZusätzlich trägst du deinen Benutzernamen in die Nix-Konfiguration ein:
echo "trusted-users = root DEINBENUTZERNAME" | sudo tee -a /etc/nix/nix.conf && sudo pkill nix-daemonJetzt installierst du devenv selbst:
nix profile install --accept-flake-config github:cachix/devenv/latestFalls du bereits ein laufendes Shopware-Projekt hast, das bisher mit MAMP, XAMPP oder Docker lief, kannst du devenv nahtlos integrieren. Dazu erstellst du im Hauptverzeichnis deines Shopware-Projekts vier neue Dateien:
devenv.nix – Das Herzstück der Konfiguration:
{ pkgs, ... }:
{
packages = [
pkgs.php81
pkgs.php81Packages.composer
pkgs.nodejs
];
services.mysql = {
enable = true;
package = pkgs.mysql80;
};
services.nginx = {
enable = true;
};
scripts.setup.exec = ''
composer install
php bin/console system:install --create-database --basic-setup
'';
}devenv.yaml – Projektspezifische Einstellungen:
inputs:
nixpkgs:
url: github:NixOS/nixpkgs/nixpkgs-unstable.envrc – Automatische Umgebungsaktivierung:
use devenvdevenv.lock – Versionsfixierung (wird automatisch generiert)
Nach dem Erstellen der Konfigurationsdateien navigierst du im Terminal in dein Projektverzeichnis und aktivierst die devenv-Umgebung:
devenv shellDu erkennst eine aktive devenv-Umgebung daran, dass am Anfang jeder Terminal-Zeile [devenv] in lila Schrift erscheint. Innerhalb dieser Umgebung nutzt du automatisch die projektspezifisch konfigurierten PHP-, Node.js- und MySQL-Versionen.
In einem zweiten Terminal startest du die Dienste:
devenv upSchon nach wenigen Sekunden ist dein Shopware-Shop unter http://localhost:8000 erreichbar – das Backend findest du unter http://localhost:8000/admin mit den Zugangsdaten admin/shopware.
Wenn du komplett neu startest, kannst du direkt ein Shopware-Projekt mit devenv-Integration erstellen:
composer create-project shopware/production mein-shop-projekt
cd mein-shop-projektDann fügst du die devenv-Konfiguration hinzu und installierst die Abhängigkeiten:
devenv init
devenv shell
composer install
bin/console system:install --create-database --basic-setupEines der beeindruckendsten Features von devenv ist die Watcher-Funktion. Sie überwacht automatisch Änderungen an deinen Dateien und lädt das Frontend und Backend in Echtzeit neu – ohne dass du den Browser manuell aktualisieren musst.
Um den Watcher zu aktivieren, führst du in der devenv-Shell folgende Befehle aus:
bin/console theme:compile
bin/console asset:install
bin/console cache:clear
bin/watch storefrontAb sofort siehst du Änderungen an Templates, Styles oder JavaScript-Dateien sofort im Browser – ein enormer Produktivitätsgewinn beim Entwickeln von Themes oder Frontend-Funktionen.
Die Geschwindigkeitsunterschiede zwischen devenv und container-basierten Lösungen sind dramatisch:
devenv nutzt deutlich weniger RAM, da keine Container-Virtualisierung stattfindet. Während Docker-basierte Entwicklungsumgebungen schnell 2-4 GB RAM verbrauchen, benötigt devenv nur den Speicher für die tatsächlich laufenden Dienste.
Wenn du eine Fehlermeldung wie "Package 'nodejs-16.20.2' is marked as insecure" erhältst, passt du die devenv.nix an:
# Statt einer festen Version
packages = [ pkgs.nodejs ]; # Nutzt die aktuelle stabile VersionFür verschiedene Shopware-Projekte benötigst du unterschiedliche PHP-Versionen. In devenv änderst du einfach die entsprechende Zeile:
packages = [
pkgs.php82 # Für Shopware 6.5+
# pkgs.php81 # Für ältere Shopware-Versionen
];Wenn du von MAMP oder Docker zu devenv wechselst, möchtest du vermutlich deine bestehenden Datenbanken übernehmen:
# Export aus der alten Umgebung
mysqldump -u root -p shopware_db > backup.sql
# Import in devenv (in der devenv shell)
mysql -u root shopware < backup.sqlFür die Entwicklung von Shopware-Themes bietet devenv mit dem Watcher perfekte Bedingungen:
# Terminal 1: devenv-Services
devenv up
# Terminal 2: Theme-Entwicklung
devenv shell
bin/console theme:compile --sync
bin/watch storefrontÄnderungen an SCSS-Dateien oder Twig-Templates werden automatisch kompiliert und im Browser angezeigt.
Beim Entwickeln von Shopware-Plugins unterstützt devenv durch schnelle Neuinstallationen:
# Plugin refreshen
bin/console plugin:refresh
bin/console plugin:install --activate MeinPlugin
bin/console cache:clearDie nativen Geschwindigkeiten von devenv machen diese Zyklen deutlich angenehmer als in virtualisierten Umgebungen.
Du kannst problemlos mehrere Shopware-Projekte parallel mit devenv betreiben. Jedes Projekt läuft in seiner eigenen Umgebung auf unterschiedlichen Ports:
# In devenv.nix verschiedene Ports konfigurieren
services.nginx = {
enable = true;
virtualHosts."localhost" = {
listen = [ { addr = "127.0.0.1"; port = 8001; } ]; # Projekt 1
};
};Auf macOS mit Apple Silicon (M1/M2) kann es hilfreich sein, Rosetta-Kompatibilität zu aktivieren:
# In devenv.nix für bessere Kompatibilität
nixpkgs.config.allowUnsupportedSystem = true;Unter Windows mit WSL2 solltest du darauf achten, dass deine Projektdateien im Linux-Dateisystem liegen, nicht auf dem Windows-Laufwerk:
# Gut: /home/username/projects/shopware
# Schlecht: /mnt/c/Users/username/projects/shopwaredevenv kann über die Zeit viele Pakete akkumulieren. Mit diesen Befehlen räumst du auf:
# Nicht mehr benötigte Pakete entfernen
nix-collect-garbage -d
# Ältere Generationen löschen
nix-collect-garbage --delete-older-than 30dFüge die generierten devenv-Dateien zu deiner .gitignore hinzu:
# devenv
.devenv/
devenv.lock
.direnv/Die Konfigurationsdateien devenv.nix, devenv.yaml und .envrc sollten dagegen versioniert werden, damit das ganze Team die gleiche Umgebung nutzt.
devenv eignet sich auch hervorragend für Continuous Integration. In GitHub Actions oder GitLab CI nutzt du die gleiche Umgebung wie lokal:
# .github/workflows/test.yml
- name: Setup devenv
uses: cachix/install-nix-action@v20
- name: Install devenv
run: nix profile install --accept-flake-config github:cachix/devenv/latest
- name: Run tests
run: devenv shell -- bin/phpunitFür professionelle Shopware-Entwicklung konfigurierst du Redis als Session-Store:
services.redis = {
enable = true;
port = 6379;
};Auch Elasticsearch lässt sich nahtlos einbinden:
services.elasticsearch = {
enable = true;
package = pkgs.elasticsearch7;
};Um ausgehende E-Mails während der Entwicklung zu testen:
services.mailpit = {
enable = true;
uiListenAddress = "127.0.0.1:8025";
};devenv macht es einfach, Xdebug für Performance-Analysen zu nutzen:
services.php = {
enable = true;
extensions = [ "xdebug" ];
extraConfig = ''
xdebug.mode = profile
xdebug.output_dir = /tmp/xdebug
'';
};MySQL-Performance lässt sich projektspezifisch optimieren:
services.mysql = {
enable = true;
settings = {
mysqld = {
innodb_buffer_pool_size = "256M";
query_cache_size = "32M";
};
};
};Wenn du devenv in einem bestehenden Entwicklungsteam einführst, gehst du am besten schrittweise vor:
devenv spielt gut mit anderen Entwicklungstools zusammen:
Ein typischer Entwickler startet seine lokale Umgebung 5-10 Mal pro Tag. Bei einer Zeitersparnis von 30-60 Sekunden pro Start summiert sich das auf 15-30 Minuten täglich. Das entspricht bei einem 5-köpfigen Team etwa 6-12 Stunden pro Woche – Zeit, die für wertschöpfende Entwicklungsarbeit genutzt werden kann.
Schnellere Feedback-Zyklen führen zu weniger Unterbrechungen im Entwicklungsflow. Entwickler bleiben länger "im Flow" und sind produktiver und zufriedener.
Mit devenv arbeiten alle Teammitglieder mit exakt denselben Tool-Versionen. Das reduziert "funktioniert bei mir"-Probleme und verkürzt Debugging-Zeiten erheblich.
Die Entwicklung moderner E-Commerce-Lösungen erfordert Geschwindigkeit, Flexibilität und Zuverlässigkeit. devenv bietet all das in einem Tool, ohne die Komplexität von Container-Orchestrierung oder die Limitierungen globaler Entwicklungsumgebungen.
Die native Performance, kombiniert mit der Flexibilität projektspezifischer Konfigurationen, macht devenv zur idealen Lösung für professionelle Shopware-Entwicklung. Teams, die auf devenv setzen, berichten von deutlich gesteigerter Produktivität und weniger technischen Problemen.
Besonders die Watcher-Funktion revolutioniert die Frontend-Entwicklung: Änderungen an Templates oder Styles werden ohne Verzögerung sichtbar, was iterative Design-Prozesse erheblich beschleunigt.
Stell dir vor, du entwickelst ein neues Shopware-Theme. Mit traditionellen Setups bedeutet jede CSS-Änderung: Speichern, zum Browser wechseln, Seite neu laden, prüfen, zurück zum Editor. Mit devenv und dem Watcher siehst du Änderungen sofort – der kreative Flow wird nicht unterbrochen.
Bei der Plugin-Entwicklung ermöglichen die schnellen Neuinstallations-Zyklen ein viel iterativeres Vorgehen. Statt lange über Code nachzudenken, testest du schnell verschiedene Ansätze und findest so oft elegantere Lösungen.
devenv transformiert die Art, wie du mit Shopware entwickelst – von einer manchmal trägen, frustrierenden Erfahrung hin zu einem schnellen, flüssigen Workflow, der Spaß macht und produktiv ist. Die initiale Lernkurve amortisiert sich bereits nach wenigen Tagen durch die gesparte Zeit und reduzierte Frustration.
Wenn du bereit bist, deine Shopware-Entwicklung auf das nächste Level zu heben, ist devenv der Schlüssel dazu. Die Technologie ist ausgereift, die Community wächst, und die Vorteile sind sofort spürbar. Deine Kunden werden die schnelleren Entwicklungszyklen zu schätzen wissen, und du wirst nie wieder zu trägen Container-Setups zurückkehren wollen.