---
title: DevOps for Shopware | Shopware Community Hub
description: >-
  Learn how DevOps foundations, containers, CI/CD, observability, security,
  scaling, recovery, Helm, and GitOps fit together in Shopware projects.
canonical_url: >-
  https://hub.shopware.comhttps://hub.shopware.com/learn/path/devops-for-shopware
---

# DevOps for Shopware

# DevOps for Shopware

Reliable Shopware projects need more than working application code. They also need predictable environments, automated checks, observable systems, safe access, scaling plans, recoverable data, and deployment workflows that a team can understand under pressure.

This learning path teaches the DevOps foundations behind those responsibilities. You start with the operating mindset, then move into containers, cloud deployment, CI/CD, observability, security, scaling, recovery, Helm, and GitOps.

The goal is not to memorize every tool. The goal is to understand how the parts connect in a real Shopware project, so you can decide what to build, what to operate, what to verify, and what to keep intentionally simple.

<Callout title="Use the Tooling That Fits the Project" type="info">

You do not need to adopt the full toolchain from this learning path for every Shopware project. A managed hosting setup, a simple deployment workflow, or a hosting partner can be the right choice when the project requirements and responsibilities are clear.

Docker, Kubernetes, Helm, GitOps, observability, scaling, and recovery workflows are used here as learning and decision models. They help you understand the trade-offs, ask better questions, verify platform behavior, and work with hosting or platform teams without replacing every working setup with the most complex option.

</Callout>

Whenever we mention "Shopware," we are referring to Shopware 6.

By the end of this learning path, you will be able to:

- Explain how DevOps practices reduce hidden operating assumptions in Shopware projects.
- Use Docker and Docker Compose to understand local Shopware runtime responsibilities.
- Describe how Kubernetes runs, exposes, replaces, and scales containerized Shopware workloads.
- Build focused GitHub Actions workflows for Shopware QA and security checks.
- Use observability signals to understand what a Shopware system is doing.
- Plan Kubernetes Secrets, RBAC, scaling, and backup workflows with clear responsibility boundaries.
- Compare Shopware hosting models by control, operational effort, and project fit.
- Explain how raw Kubernetes manifests, Helm charts, and GitOps with ArgoCD build on each other.

This learning path is based on Shopware 6.7 and reflects the DevOps patterns used throughout the practical labs.

## Who This Is For

- Developers who want to understand how their Shopware code is built, checked, deployed, and operated.
- DevOps engineers and system administrators who need Shopware-specific context for containers, CI/CD, Kubernetes, observability, security, scaling, and recovery.
- Technical leads and solutions architects who compare hosting models, platform responsibilities, and operational trade-offs in Shopware projects.

## Prerequisites

Before diving into this learning path, make sure you have:

- Completed [Shopware Backend Development Essentials](/learn/path/shopware-backend-development-essentials) or have equivalent hands-on Shopware backend practice.
- Confidence using a Linux or macOS CLI for everyday project work.
  - On Windows, use WSL2.
- Basic knowledge of Git workflows, including commits, branches, remotes, and pull requests or merge requests.
- Basic knowledge of Composer and dependency management.
- Basic understanding of web application runtime concepts, including HTTP, databases, environment variables, and web server responsibilities.

You do not need Kubernetes, Helm, GitOps, observability, or cloud platform experience before starting. Those concepts are introduced step by step in the learning path.

<Callout title="Tooling for Practical Labs" type="info">

Some practical labs use tools such as Shopware CLI, Docker, GitHub Actions, `kubectl`, Helm, and ArgoCD. You do not need to understand these tools before starting the learning path, but you should be able to install and run them when a lab asks for them.

Several labs use Shopware CLI 0.18.3 or newer to create fresh Shopware project states or run project-level Composer commands. The labs explain when Shopware CLI is used directly and when a Shopware CLI container image is used instead.

Docker Desktop is the reference setup for several local practical labs because it is a common way to run Docker, Docker Compose, and a small Kubernetes cluster on a development machine. For private learning or educational lab work, Docker Desktop is enough to follow these labs. If Docker Desktop asks you to sign in, you can use a personal Docker account for your learning setup. If you use a company-managed device, follow your company's Docker policy.

If you use another local container runtime or Kubernetes training cluster, the concepts stay the same, but some commands, networking behavior, image handling, service exposure, or resource settings may need small adjustments.

Use the official setup sources for your operating system:

- [Docker installation documentation](https://docs.docker.com/get-started/get-docker/) or another local container runtime.
- [Shopware CLI documentation](https://developer.shopware.com/docs/products/tools/cli/) for labs that create or prepare Shopware projects.
- [GitHub Actions documentation](https://docs.github.com/en/actions) and a GitHub account for workflow labs.
- [Kubernetes `kubectl` installation documentation](https://kubernetes.io/docs/tasks/tools/) for Kubernetes labs.
- [Helm installation documentation](https://helm.sh/docs/intro/install/) for the Helm lab.
- [ArgoCD getting started documentation](https://argo-cd.readthedocs.io/en/stable/getting_started/) for the GitOps lab.

</Callout>

<Callout title="Practical Lab Reminders" type="info">

Each practical lab includes a **Reminder: Prerequisites** section before the hands-on steps. These reminders help you check the concrete setup needed for that lab, such as ports, folders, images, commands, access rights, or previous lab results.

</Callout>

## Learning Approach

The learning path moves from operating decisions to implementation patterns:

- First, you learn the DevOps and operational readiness questions that every later tool must support.
- Then, you learn how Shopware can be packaged and operated with Docker, Docker Compose, Kubernetes, cloud services, and hosting models, so you can compare when each model fits.
- Then, you connect Git, CI/CD, automated testing, and GitHub Actions workflows to concrete quality checks.
- Then, you add observability, security scanning, Kubernetes Secrets, and RBAC to make operation safer and easier to debug.
- Then, you study scaling, high availability, pod splitting, and backup workflows for Shopware workloads.
- Finally, you move from raw Kubernetes manifests to Helm charts and GitOps with ArgoCD.

The practical labs are intentionally focused. They do not build one giant production platform in a single repository. Instead, each lab isolates one operational idea so you can understand the responsibility, run it locally or in GitHub Actions, verify the result, and transfer the pattern to a real project.

## Courses

## Courses
- [DevOps Fundamentals for Shopware](https://hub.shopware.com/learn/course/devops-fundamentals-for-shopware): Learn how DevOps principles, Infrastructure as Code, and operational readiness prepare Shopware projects for reliable delivery and operation.
- [Containerization and Cloud Deployment](https://hub.shopware.com/learn/course/containerization-and-cloud-deployment): Learn how Docker, Kubernetes, stateless containers, cloud deployment, and hosting decisions fit together in Shopware projects.
- [Version Control and CI/CD](https://hub.shopware.com/learn/course/version-control-and-cicd): Learn how Git workflows, CI/CD concepts, automated testing, and a practical GitHub Actions QA setup fit together in Shopware projects.
- [Observability and Security](https://hub.shopware.com/learn/course/observability-and-security): Learn how observability, CI/CD security checks, Kubernetes Secrets, and RBAC help teams operate Shopware projects with clearer signals and safer access.
- [Scaling and Recovery](https://hub.shopware.com/learn/course/scaling-and-recovery): Learn how Kubernetes scaling, Shopware pod splitting, backup planning, and local database backup workflows support reliable Shopware operations.
- [Advanced Kubernetes Deployments](https://hub.shopware.com/learn/course/advanced-kubernetes-deployments): Learn how raw manifests, Helm charts, and GitOps workflows with ArgoCD turn Shopware Kubernetes deployments into visible, reusable, and reconciled desired…