Introduction

Shopware 6.7 represents a significant evolution in the platform's architecture, introducing tighter integration with modern PHP standards, enhanced CLI tooling, and refined performance optimizations that cater to enterprise-grade deployments. At the core of this release is a Composer-first philosophy that ensures dependency consistency, reproducible environments, and streamlined security patching. While graphical installers once dominated early e-commerce setups, Composer-based installation has become the industry standard for developers and DevOps teams who value version control, automated deployments, and infrastructure-as-code principles.

This guide walks through the conceptual workflow of installing Shopware 6.7 via Composer. Rather than treating installation as a series of blind copy-paste actions, we will explore the architectural decisions behind each step, explain how Symfony's component ecosystem interacts with Shopware's core, and provide practical insights that bridge development and production readiness.

Prerequisites & System Architecture Context

Before invoking any Composer commands, understanding your environment's role is crucial. Shopware 6.7 enforces strict runtime requirements to leverage modern PHP features like typed properties, immutable objects, and improved JIT compilation. You will need:

  • PHP 8.2 or higher: The platform heavily utilizes PHP 8.x syntax, extension stability, and performance improvements. Older versions will fail Composer's constraint checks.
  • Composer 2.x: Required for lock file consistency, dependency resolution algorithms, and security vulnerability scanning integration.
  • MySQL 8.0+ or MariaDB 10.5+: Shopware's Doctrine ORM layer expects modern SQL modes, JSON column support, and optimized indexing strategies available in these versions.
  • Web Server: Nginx or Apache with FastCGI/PHP-FPM configuration, ready to point to the public directory where front controllers reside.
  • Git & CLI Access: Necessary for version tracking, script execution, and automated deployment pipelines.

The installation process fundamentally relies on Composer's dependency management system. Shopware is distributed as a collection of tightly coupled packages (shopware/platform, shopware/storefront, etc.), and Composer resolves their transitive dependencies, autoload configurations, and asset paths automatically. This eliminates manual file merging and ensures that every installed version aligns with the platform's internal contracts.

Step 1: Composer Initialization & Project Scaffolding

The foundation of a reliable Shopware installation begins with proper project scaffolding. When you run composer create-project, you are not just downloading files; you are triggering a structured package resolution process that evaluates compatibility, generates autoload maps, and prepares Symfony's configuration directories.

composer create-project shopware/platform:^6.7 ./shopware --no-dev

The ^6.7 constraint ensures you receive the latest stable patch within the 6.7 minor version, which is critical for security updates without introducing breaking API changes. The --no-dev flag is deliberate: it skips development dependencies like PHPUnit, PHPStan, and debugging tooling, resulting in a leaner production environment with reduced attack surface and faster file I/O operations. The output directory ./shopware follows conventional project structure patterns, making CI/CD integration straightforward.

During this phase, Composer downloads the platform's core, configures route loaders, sets up Doctrine bundle mappings, and generates initial cache directories. Understanding this behind-the-scenes work helps troubleshoot issues like missing service definitions or broken autoloading later in deployment.

Step 2: Environment Configuration & Runtime Variables

Shopware 6.7 relies on Symfony's environment abstraction to decouple configuration from codebase logic. After scaffolding, you will find a .env.dist file containing template variables that define database connections, cache backends, mail transport settings, and application mode.

Copy this file to .env and adjust the values to match your infrastructure:

cp .env.dist .env

Key variables to prioritize include DATABASE_URL, which follows Doctrine's connection string format (mysql://user:pass@host:port/dbname?serverVersion=8.0). Misconfiguring this parameter will halt the installation wizard and trigger runtime exceptions in the kernel boot phase. The APP_ENV variable typically defaults to prod in production setups, but during initial setup, keeping it at dev or test allows Symfony to display detailed error pages, which accelerates debugging before final deployment.

Environment variables are loaded via Dotenv component and are intentionally kept out of version control. This practice supports multi-environment deployments (staging, QA, production) without modifying code, aligning with twelve-factor app methodology.

Step 3: Database Initialization & Platform Installation

With dependencies resolved and environment variables set, the next phase triggers Shopware's boot sequence and database provisioning. The platform uses a migration-based approach rather than hardcoded SQL dumps, ensuring schema versioning across updates.

Execute the installation command via Symfony console:

bin/console system:install --basic-setup

This single command orchestrates multiple internal processes. First, it validates the database connection, creates missing schemas, and runs Doctrine migrations to establish core tables. Next, it populates baseline data: storefront themes, payment and shipping methods, tax rules, default languages, and admin user credentials. The --basic-setup flag is recommended for standard deployments, as it bypasses advanced multi-store configurations while establishing a fully functional e-commerce foundation.

Under the hood, Shopware's installer leverages Symfony's command bus pattern to break down operations into discrete steps: database validation, schema generation, fixture loading, cache initialization, and final kernel warmup. Understanding this flow helps when troubleshooting partial installations or rolling back corrupted data states.

Step 4: Permissions, Caching & Deployment Readiness

Shopware 6.7, like other Symfony-based applications, requires strict directory permissions to separate read-only assets from writable runtime directories. The platform divides files into cache, logs, downloads, and uploads folders, each serving distinct lifecycle purposes.

Correct permissions are enforced through:

chmod -R 750 .
chown -R www-data:www-data .
umask 002

The 750 permission model grants the web server read/write access while restricting external execution, reducing vulnerability exposure from uploaded scripts. The umask adjustment ensures new files created during runtime inherit appropriate group-write permissions, which is critical for Docker or multi-user deployments.

Cache warming is the final optimization step:

bin/console cache:warmup --env=prod

This compiles Twig templates, regenerates router configurations, and prebuilds serializer metadata. Skipping this step forces Symfony to compile on first request, causing latency spikes during initial user traffic. Once warmed, your deployment is structurally production-ready. Configure your web server's document root to point at public/index.php, enable HTTPS via Let's Encrypt or reverse proxy, and set up Redis or Memcached for session and query caching if not already configured in .env.

Pro Tips & Common Pitfalls

  • PHP Extensions: Shopware 6.7 requires intl, mbstring, xml, pdo_mysql, json, zip, and curl. Missing extensions will trigger fatal Composer checks or runtime Symfony exceptions.
  • Migration Conflicts: If you restore backups or merge branches, run bin/console database:migrate --dry-run before applying changes to preview schema shifts.
  • Composer Integrity: Always commit your composer.lock file. It guarantees that every team member and deployment server resolves identical package versions, preventing "works on my machine" discrepancies.
  • First Login Flow: After installation, the admin dashboard will guide you through shop configuration. The CLI installer creates a default super administrator; change credentials immediately via bin/console user:change-password.

Conclusion

Installing Shopware 6.7 via Composer is more than a setup ritual; it is an exercise in modern application architecture. By leveraging Composer's dependency resolution, Symfony's environment abstraction, and Doctrine's migration-driven schema management, you establish a repeatable, secure, and scalable foundation. The steps outlined here emphasize understanding over memorization, ensuring that when infrastructure evolves or deployments scale, you can confidently troubleshoot, optimize, and maintain your e-commerce platform without reverting to manual file manipulation or opaque installers. As Shopware 6.7 continues to mature, this Composer-first approach will remain the cornerstone of professional deployment strategies.