---
title: Containerization and Cloud Deployment | Shopware Community Hub
description: >-
  Learn how Docker, Kubernetes, stateless containers, cloud deployment, and
  hosting decisions fit together in Shopware projects.
canonical_url: >-
  https://hub.shopware.comhttps://hub.shopware.com/learn/course/containerization-and-cloud-deployment
---

# Containerization and Cloud Deployment

# Containerization and Cloud Deployment

Modern Shopware projects often need to run in more than one environment: locally, in CI/CD, in Kubernetes, in cloud platforms, or on a managed hosting model. To make that possible, the application must be packaged, configured, started, replaced, and operated in a predictable way.

This course connects those ideas step by step. You start with Docker and local containers, then move into Kubernetes orchestration, cloud deployment principles, stateless runtime design, and finally the hosting decision itself.

<Callout title="Containers Teach an Operating Model" type="info">

Docker and Kubernetes make important operating concepts visible: packaging, runtime configuration, orchestration, replacement, and scaling. They are learning tools in this course, not a required production target for every Shopware project. A managed hosting setup or a virtual-machine based setup can be a better fit when it meets the project's deployment, scaling, monitoring, and recovery needs with less operational overhead.

</Callout>

Throughout the course, the learning flow moves from local runtime mechanics to real operating decisions:

- First, how Docker packages and runs a Shopware application.
- Then, how Docker Compose models a local multi-service runtime.
- Then, how Kubernetes schedules, exposes, and replaces containerized workloads.
- Then, how cloud deployments change responsibility, state, services, and operations.
- And finally, how SaaS, PaaS, and self-hosted models fit different project needs.

<LearningObjectives>

- Understand how Docker images, containers, Dockerfiles, and Docker Compose apply to Shopware projects.
- Build and inspect a local Shopware Docker Compose setup.
- Understand how Kubernetes uses Pods, Deployments, Services, networking, and storage to run containerized workloads.
- Deploy and inspect a small Shopware workload in a local Kubernetes cluster.
- Learn why cloud-ready Shopware containers should externalize cache, sessions, files, media, and locks.
- Compare Shopware hosting models by responsibility, platform fit, migration path, and operating effort.

</LearningObjectives>

## Learning Approach

This course combines conceptual learning with three focused practical labs.

The theory units build the mental models:

- What belongs in an image and what belongs in a runtime configuration.
- How orchestration differs from starting containers manually.
- Why cloud deployments are also responsibility and operations decisions.
- Why stateless application containers need shared services.
- How hosting models shift control and operational work.

The practical labs then make the core ideas visible:

- A local Shopware setup with Docker Compose.
- A small Shopware workload deployed to local Kubernetes.
- A local Docker Compose setup extended with Valkey and MinIO to show the stateless container pattern.

By the end of the course, you will not only know the individual tools, but also how they connect: Docker packages the application, Kubernetes operates containers as desired state, cloud platforms provide managed building blocks, and hosting models decide who owns which responsibilities.

Ready to connect containers, orchestration, cloud deployment, and hosting decisions? Then start with Unit 1 and follow the course from Docker fundamentals to a realistic Shopware hosting recommendation.

## Learning Units

## Units
- [Containerization With Docker](https://hub.shopware.com/learn/unit/containerization-with-docker): Learn how Docker packages Shopware into images, runs containers from those images, and models a local runtime environment with Docker Compose.
- [Practical Lab: Running Shopware Locally With Docker Compose](https://hub.shopware.com/learn/unit/practical-lab-running-shopware-locally-with-docker-compose): Build a small local Shopware Docker Compose setup, replace the generated Compose files for learning, and verify the app, database, logs, ports, and volume.
- [Orchestration with Kubernetes](https://hub.shopware.com/learn/unit/orchestration-with-kubernetes): Learn how Kubernetes uses desired state, Pods, Deployments, Services, networking, and storage to run containerized Shopware workloads.
- [Practical Lab: Deploying Shopware Locally With Kubernetes](https://hub.shopware.com/learn/unit/practical-lab-deploying-shopware-locally-with-kubernetes): Deploy a small Shopware training workload to local Kubernetes with a Deployment and Service, then inspect Pods, logs, and cleanup with kubectl.
- [Shopware Cloud Deployment Fundamentals](https://hub.shopware.com/learn/unit/shopware-cloud-deployment-fundamentals): Learn how Shopware cloud deployments differ by platform responsibility, operating principles, and stateless application design.
- [Practical Lab: Preparing Shopware for Stateless Containers](https://hub.shopware.com/learn/unit/practical-lab-preparing-shopware-for-stateless-containers): Extend a local Shopware Docker Compose setup with Valkey, MinIO, Redis-compatible storage, and S3-compatible file storage.
- [Overview and Comparison of Hosting Options](https://hub.shopware.com/learn/unit/overview-and-comparison-of-hosting-options): Compare Shopware hosting models by responsibility, platform fit, migration path, operating effort, and team capability.