Install TYPO3 CMS on Kubernetes : Full Installation Guide

Published on :  
Starke Brandt
TYPO3 Install

Install TYPO3 CMS on Kubernetes : Full Installation Guide

Are you trying to install TYPO3 on Kubernetes but don’t know where to begin? You’re not alone! Whether you're a developer, system admin, or just exploring cloud-native solutions for your TYPO3 website, setting it up on Kubernetes might sound tricky at first.

But don’t worry—this guide is here to help. We’ll walk you through the entire process step by step, making sure you can install TYPO3 with Kubernetes smoothly and confidently. By the end, you’ll have a TYPO3 site running inside a Kubernetes cluster—ready to scale, update, and perform like a pro.

Wait ! Before moving further, are you considering launching or hosting your TYPO3 site on another platform? We recommend checking out our TYPO3 Installation Series below for step-by-step guides on various platforms.

Let’s dive in and build a powerful, secure TYPO3 environment — the right way — on Kubernetes.

What is Kubernetes?

Before we dive into the setup, let’s take a quick look at what Kubernetes actually is.

Kubernetes (often shortened to K8s) is a free, open-source platform designed to automate the deployment, scaling, and management of software inside containers. Think of it as the system that keeps your apps running properly—no matter how big they grow or how often they need updates.

When you install TYPO3 with Kubernetes, you get powerful features like:

  • High availability: Your TYPO3 site can stay online, even if something goes wrong.
  • Automatic scaling: More traffic? Kubernetes adds more resources.
  • Rolling updates: Update TYPO3 with zero downtime

In simple terms, Kubernetes helps run your applications smoothly—so you don’t have to worry about the messy behind-the-scenes work.

What is TYPO3?

What Is TYPO3?

TYPO3 is a free, open-source Content Management System (CMS) built to help businesses and organizations create, manage, and grow their websites. It was founded in 1997 by Kasper Skårhøj and has since become one of the most popular CMS platforms—especially across Europe.

TYPO3 is written in PHP and uses TypoScript, a powerful configuration language that allows for advanced customization and flexibility. You don’t need any special software—TYPO3 runs in your browser and outputs content using standard HTML and JavaScript.

Whether you’re running a small business site, a university portal, or a large enterprise website, TYPO3 can scale to fit your needs.

Imagine an enterprise CMS that evolves as your project grows—without piling on complexity. That’s TYPO3 for you! It’s an open-source powerhouse that excels at:

here are the key reasons that TYPO3 Developers, marketers, and agencies trust TYPO3 for its:

  • Modularity: Make your website do exactly what you need. No more, no less.
  • Security & Stability: Regular LTS (Long-Term Support) releases help you stay secure for years.
  • Scalability: From a tiny local site to a massive global platform, TYPO3 can handle it.
  • Community-Driven Development: Enjoy a lively global community that refines and evolves TYPO3 continuously.

Did You Know? TYPO3 powers over 500,000+ active websites around the world! 

Read more TYPO3 Facts.

Why use TYPO3?

TYPO3 offers advanced features like granular user roles, multisite management, and a strong ecosystem of extensions. It’s perfect for businesses and agencies that need scalability and long-term support.

Why Run TYPO3 on Kubernetes?

  • Scalability & High Availability: Spin up additional Pods (container replicas) to handle traffic spikes or failures.
  • Rolling Updates & Rollbacks: Deploy new TYPO3 releases with minimal downtime and easy rollback if needed.
  • Resource Efficiency: Use cluster resources more effectively by scheduling containers across nodes.
  • Ecosystem Integrations: Kubernetes works with numerous add-ons (e.g., Ingress controllers, service meshes, persistent storage providers).

Who’s This Guide For?

  • Intermediate to Advanced devs or sysadmins comfortable with Docker/containers.
  • Projects expecting higher traffic or requiring robust uptime.

Requirements to Run TYPO3 on Kubernetes Smoothly

1. Kubernetes Cluster

You need a functioning Kubernetes (K8s) cluster. This can be set up using:

  • Local tools like Minikube or Kind for testing and development
  • Managed cloud providers like Google Kubernetes Engine (GKE), Amazon EKS, Azure AKS, or DigitalOcean Kubernetes for production

2. Container Runtime
A container runtime such as Docker or containerd must be installed and supported by your Kubernetes environment. Most managed clusters include this by default.

3. TYPO3 Docker Image
Use a TYPO3 Docker image that includes the necessary components such as:

  • PHP

  • Apache or Nginx

  • TYPO3 Core

  • Required TYPO3 extensions

You can use official images or build a custom one tailored to your project needs.

4. Persistent Storage (PVCs)
TYPO3 needs persistent storage for:

  • Uploaded assets (images, documents)

  • Extension files

  • Configuration and temporary files

Configure PersistentVolumeClaims (PVCs) in your Kubernetes setup to ensure this data is retained across deployments.

5. Database (MySQL or MariaDB)
TYPO3 requires a database to function. You can deploy a MySQL or MariaDB database within the cluster or use an external managed service. Ensure the database has:

  • Proper credentials and user permissions

  • Persistent storage

  • Secure access from TYPO3 pods

6. Ingress Controller
Install an Ingress Controller like NGINX Ingress or Traefik to expose your TYPO3 application to the internet. This allows access via a domain name and supports SSL configuration.

7. PHP Configuration and Environment Variables
Ensure that the PHP environment is optimized for TYPO3, including:

  • Memory limits (256M or higher)

  • Maximum upload file size

  • Execution timeouts

Use ConfigMaps and Secrets to manage TYPO3-specific settings and sensitive environment variables such as database credentials, TYPO3 context, and SMTP settings.

8. Email Configuration
TYPO3 uses email for notifications, password recovery, and more. Set up a mail transport (SMTP) service using internal or third-party providers like SendGrid or Mailgun.

9. Monitoring and Logging
To maintain visibility into your TYPO3 instance, configure:

  • Monitoring tools like Prometheus and Grafana

  • Logging solutions such as the ELK stack or Loki

  • Health checks and pod logs via kubectl or a Kubernetes dashboard

10. Helm (Optional but Useful)
Helm is a package manager for Kubernetes that simplifies deployment. Helm charts can automate the installation of TYPO3, databases, ingress, and other dependencies.

TYPO3 Versions & Support Roadmap

TYPO3 Versions & Support

Before diving in, note TYPO3’s release cycles:

  • LTS (Long-Term Support): Typically three years of updates per major release.
  • ELTS (Extended LTS): Paid option if you need extra time beyond standard LTS.

Staying on a currently supported LTS means you’ll get important security patches and feature improvements.

View Roadmap

TYPO3 Version & PHP Compatibility for Composer Install

1. PHP & TYPO3 Compatibility

TYPO3 VersionPHP VersionsStatus
9 ELTS7.2–7.4Active ELTS
10 ELTS7.2–7.4Active ELTS
11 ELTS7.4, 8.0Active ELTS
12 LTS8.1–8.4Active ELTS
13 LTS8.2–8.4Active ELTS

2. System Requirements

  • Web Server: Apache or Nginx
  • Database: MariaDB/MySQL recommended
  • Composer: Recommended for a smoother TYPO3 experience

Always verify with TYPO3’s official System requirements to ensure you’re up to date.

Composer vs Classic TYPO3 Installation

Composer vs Classic TYPO3 Installation

Diagram Explanation:

  • Composer automates versioning, dependency management, and updates.
  • Classic is manual but sometimes easier on hosts without CLI access.

Understanding TYPO3 Architecture on Kubernetes

Running TYPO3 in Kubernetes typically involves:

  • A Deployment for the web + PHP container(s) running TYPO3 code.
  • A Service (type: ClusterIP or LoadBalancer) to expose the TYPO3 Pod(s) internally or externally.
  • A PersistentVolume (or PersistentVolumeClaim) to store file uploads and other persistent data.
  • A Database, either within the cluster (MariaDB Deployment/StatefulSet) or an external/managed DB service (e.g., AWS RDS, Azure Database, Cloud SQL).

Architecture of Kubernetes & TYPO3

Architecture of Kubernetes & TYPO3

Diagram Explanation:

  • Traffic enters the cluster via an Ingress or Service configured with a LoadBalancer (in a cloud environment).
  • The TYPO3 Pods run the web server + PHP-FPM. They share a Persistent Volume for user uploads, images, etc.
  • A separate MariaDB Deployment or an external database hosts the data, also typically backed by a persistent volume.

How to install TYPO3 on Kubernetes

Below, we’ll outline a simple local or cloud-based setup using YAML manifests. Adapt as needed for your environment (Minikube, EKS, GKE, AKS, etc.).

Step 1. Prerequisites

  • Docker to build your TYPO3 image (if you’re customizing).
  • A Kubernetes cluster (local using Minikube or a cloud provider).
  • kubectl CLI connected to your cluster.

Quick Tip: Want to install TYPO3 with Docker? Read this guide.

(Optional) Consider using Helm for packaging, but we’ll stick to raw Kubernetes YAML for clarity.

Step 2. Build a TYPO3 Docker Image

If you already have a Docker image that includes TYPO3 + PHP + Nginx/Apache, skip this step. Otherwise:

# Example Dockerfile
FROM php:8.1-apache
RUN apt-get update && apt-get install -y \
    libxml2-dev libzip-dev libpng-dev libjpeg-dev mariadb-client \
    && docker-php-ext-install mysqli gd zip xml mbstring
# Copy your TYPO3 code into /var/www/html or mount it as a volume
COPY . /var/www/html
RUN chown -R www-data:www-data /var/www/html


// Build & push (if hosting externally):

docker build -t your-registry/typo3:latest .
docker push your-registry/typo3:latest

Step 3. MariaDB (or External DB)

Option A: Deploy MariaDB inside your cluster:

# mariadb-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mariadb
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mariadb
  template:
    metadata:
      labels:
        app: mariadb
    spec:
      containers:
        - name: mariadb
          image: mariadb:10.5
          env:
            - name: MYSQL_ROOT_PASSWORD
              value: supersecret
            - name: MYSQL_DATABASE
              value: typo3db
            - name: MYSQL_USER
              value: typo3user
            - name: MYSQL_PASSWORD
              value: supersecret
          volumeMounts:
            - name: db-pv
              mountPath: /var/lib/mysql
      volumes:
        - name: db-pv
          persistentVolumeClaim:
            claimName: mariadb-pvc

Option B: Use an external or managed DB (e.g., Amazon RDS, Azure Database for MySQL, etc.). In this case, skip deploying MariaDB in-cluster. Just configure your TYPO3 environment to point to the external DB host and credentials.

# mariadb-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: mariadb-service
spec:
  selector:
    app: mariadb
  ports:
    - port: 3306
      name: mysql

// You’ll need a matching PersistentVolumeClaim:

# mariadb-pvc.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mariadb-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Step 4. TYPO3 Deployment & Service

Below is an example using Nginx + PHP-FPM in a single container (or an Apache-based image) to keep it simpler. Adjust the container image name to whatever you built or an existing image you prefer.

# typo3-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: typo3
spec:
  replicas: 2
  selector:
    matchLabels:
      app: typo3
  template:
    metadata:
      labels:
        app: typo3
    spec:
      containers:
        - name: typo3
          image: your-registry/typo3:latest
          ports:
            - containerPort: 80
          env:
            - name: TYPO3_DB_HOST
              value: mariadb-service
            - name: TYPO3_DB_NAME
              value: typo3db
            - name: TYPO3_DB_USER
              value: typo3user
            - name: TYPO3_DB_PASS
              value: supersecret
          volumeMounts:
            - name: typo3-files
              mountPath: /var/www/html/public/fileadmin
      volumes:
        - name: typo3-files
          persistentVolumeClaim:
            claimName: typo3-pvc

Persistent Volume Claim for user uploads, images, etc.:

# typo3-pvc.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: typo3-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 2Gi

Step 5. Ingress (Optional)

If you’d like an external domain or LoadBalancer, configure an Ingress or a Service of type LoadBalancer. For example:

# typo3-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: typo3-ingress
  annotations:
    kubernetes.io/ingress.class: "nginx"
spec:
  rules:
    - host: your-typo3.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: typo3-service
                port:
                  number: 80

Note: You’ll need an Ingress Controller (e.g., Nginx Ingress) installed in your cluster for this to work.

Step 6. Deploying to Kubernetes

Apply all YAML files in your cluster:

kubectl apply -f mariadb-pvc.yaml
kubectl apply -f mariadb-deployment.yaml
kubectl apply -f mariadb-service.yaml

kubectl apply -f typo3-pvc.yaml
kubectl apply -f typo3-deployment.yaml
kubectl apply -f typo3-service.yaml

# (Optional) Ingress
kubectl apply -f typo3-ingress.yaml

Check the status:
kubectl get pods
kubectl get svc
kubectl get ingress

Step 7. Finalizing TYPO3

Once pods are running:

  • Access the Service/Ingress: Go to the domain or external IP.
  • Installation Wizard: If your image didn’t already include a pre-configured LocalConfiguration.php, you’ll see the TYPO3 install wizard. Provide DB host (mariadb-service), DB name, user, and password.
  • Complete: Log into the backend and manage your TYPO3 site as usual.

How to Start TYPO3 Installation Wizard

Once all server configurations are complete, it’s time to finish the setup through the TYPO3 Installation Wizard. This user-friendly, step-by-step wizard helps you finalize the installation process directly in your browser.

Step 1. Check the System Environment (detect if any issues)

TYPO3 will scan your server for required PHP extensions, folder permissions, and system settings. Fix any issues listed before proceeding,

Check the System Environment

Step 2. Setup Your Database Credentials

Enter the database name, username, and password you created earlier. TYPO3 will use this to store your content and configurations.

Step 2. Setup Your Database Credentials

Step 3. Choose an Existing Database or Create a New

Select an existing empty database or let TYPO3 create a new one for you.

Choose an Existing Database or Create a New

Step 4. Create backend user & Site

Set up the backend administrator account. Make sure to choose a secure password—you’ll use this to log into the TYPO3 dashboard.

Create backend user & Site in TYPO3

Step 5. Installation Process Start

Define your site name and initial setup options. You can also choose to load a distribution or start with a blank site.

You did it! Now you have a running TYPO3 site on AWS.

TYPO3 Installation Process Start

Step 6. Get Start with Backend Login

TYPO3 will complete the setup and redirect you to the backend login page.

Get Start with TYPO3 Backend Login

DevOps Tips for Running TYPO3 on Kubernetes

  • Use a Custom Docker Image - Build a TYPO3 image tailored to your project with the right PHP version, extensions, and configuration. Keep it lightweight and version-controlled.
  • Leverage Helm Charts - Use Helm to package your TYPO3 application, database, and ingress settings. This simplifies deployment and rollback across environments.
  • Implement GitOps Practices - Manage TYPO3 Kubernetes deployments using GitOps tools like Argo CD or Flux. This ensures version control, traceability, and automated syncing.
  • Optimize Persistent Storage - Use PersistentVolumeClaims for fileadmin, uploads, and typo3temp folders. Choose a fast and reliable storage class for performance.
  • Externalize Configuration with ConfigMaps and Secrets - Store environment variables, TYPO3 context, and credentials securely using Kubernetes ConfigMaps and Secrets.
  • Enable Horizontal Pod Autoscaling - Scale TYPO3 pods automatically based on CPU or memory usage to handle traffic spikes without manual intervention.
  • Use Readiness and Liveness Probes - Define probes to check TYPO3 health and prevent traffic from being routed to failing containers.
  • Centralized Logging and Monitoring - Integrate tools like Prometheus, Grafana, Loki, or the ELK stack for better observability of TYPO3 containers, PHP errors, and database performance.

Conclusion

Running TYPO3 on Kubernetes offers a robust, scalable foundation for your CMS. By splitting out the web front end, PHP runtime, and database, you gain greater control over resource allocation, updates, and resiliency. Though Kubernetes has a steeper learning curve than simpler single-VM or Docker Compose setups, it pays off in advanced features like rolling updates, auto-scaling, and multi-cluster deployments.

Happy TYPO3ing on Kubernetes!

FAQ

Many prefer splitting these into separate containers for best-practice microservices. Our example lumps them for simplicity, but you can have one container for Nginx and another for PHP-FPM and link them in the same Pod.

Store them in Kubernetes Secrets rather than hardcoding in YAML. Then reference via env variables in your Deployment.

It can be done for small setups. For production or large-scale environments, consider an external/managed database service for reliability and performance.

Absolutely. Update your Docker image or Deployment definition, and Kubernetes will handle rolling updates. If something goes wrong, you can easily roll back.

Use a storage solution that supports ReadWriteMany (e.g., NFS, GlusterFS, or cloud file storage). That ensures all Pods can read/write to the same volume simultaneously.

Update your Docker image with the new TYPO3 version, push it to your registry, then modify the image tag in your Deployment’s YAML. K8s handles the rolling update.

Enable the Horizontal Pod Autoscaler (HPA) to scale up/down your TYPO3 deployment based on CPU or custom metrics. This is particularly beneficial for high-traffic sites.

Logs typically go to stdout/stderr. Use kubectl logs <pod> or a logging system (e.g., EFK stack—Elasticsearch, Fluentd, Kibana) for central log management.

Helm can simplify packaging and versioning. You might find existing charts for TYPO3 or create your own for a more streamlined workflow.

Point your domain’s DNS to the Ingress Controller’s external IP or LoadBalancer. Then specify that domain in the Ingress resource’s host.

Starke Brandt

Starke Brandt

Brand & Communication Lead

Starke shapes the voice of T3Planet — and it shows. With years of TYPO3 experience in marketing and product branding, he ensures everything we publish reflects clarity, credibility, and purpose. He’s the reason our content…

More From Author

Previous Article
T3AS - AI Powered Solr Search for TYPO3
Next Article
Install TYPO3 on Debian: A Beginner’s Guide

Post a Comment

×

You May Also Like

Install TYPO3 on Platform.sh

Deploy TYPO3 on Platform.sh in 7 Simple Steps

Starke Brandt
TYPO3 Install
Install TYPO3 with MAMP on macOS - Complete Tutorial

Beginner's Guide to Install TYPO3 on macOS (MAMP)

Starke Brandt
TYPO3 Install
Install TYPO3 on Debian

Install TYPO3 on Debian: A Beginner’s Guide

Starke Brandt
TYPO3 Install