tutorial

Monitoring TYPO3 CMS with Vigilmon

TYPO3 is an enterprise open source CMS widely deployed across Europe — here's how to monitor its frontend, backend, PHP-FPM, database, Redis cache, Scheduler jobs, file storage, and security update status with Vigilmon.

TYPO3 is a mature enterprise content management system with a particularly strong presence in European organizations — universities, government agencies, media companies, and large corporations across Germany, Austria, and Switzerland rely on it to power their public-facing websites. When you self-host TYPO3, you're running a PHP application with multiple interdependent components: PHP-FPM workers serving frontend pages, a MySQL or PostgreSQL database as the primary data store, a caching framework (often backed by Redis or Memcached), a background Scheduler for indexing and maintenance jobs, and file storage for uploaded media. A failure in any of these layers can silently serve stale pages, block content editors from working, or cause security vulnerabilities through outdated extensions. Vigilmon gives you end-to-end monitoring across every layer of the TYPO3 stack.

What You'll Set Up

  • HTTP uptime monitor for the TYPO3 frontend (public website)
  • HTTP uptime monitor for the TYPO3 backend admin interface
  • Database connectivity monitor (MySQL/MariaDB or PostgreSQL)
  • PHP-FPM worker utilization heartbeat
  • Redis cache health monitor
  • TYPO3 Scheduler job success heartbeat
  • File storage disk space heartbeat
  • SSL certificate expiry alerts
  • Alert thresholds calibrated for enterprise CMS availability

Prerequisites

  • TYPO3 12.x or later deployed with PHP 8.1+
  • A web server (nginx or Apache) with PHP-FPM
  • MySQL/MariaDB or PostgreSQL as the database
  • Optionally: Redis or Memcached as a cache backend
  • A free Vigilmon account

Step 1: Monitor the TYPO3 Frontend

The frontend is your public-facing website — what visitors, customers, and search engines see. A frontend outage affects your organization's public presence, and TYPO3 page rendering failures may return 5xx errors or blank pages that are easy to miss without active monitoring.

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. URL: https://www.yourdomain.com/ (your TYPO3 site's public homepage).
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Under Keyword check, enter a distinctive string from your homepage content (a site name, a heading, or a recognizable phrase) to confirm TYPO3 is rendering pages, not just that nginx is responding.
  7. Enable Monitor SSL certificate and set the expiry alert threshold to 21 days.
  8. Click Save.

For TYPO3 sites using page caching, the homepage monitor validates that cached pages are being served — add a second monitor on an uncacheable URL (such as a search results page or a form) to verify the uncached path works too.

Step 2: Monitor the TYPO3 Backend

The TYPO3 backend at /typo3/ is the administrative interface used by content editors every day. Backend downtime blocks all content publishing, page creation, and site configuration changes — even when the frontend continues serving cached pages.

  1. Click Add Monitor → HTTP / HTTPS.
  2. URL: https://www.yourdomain.com/typo3/ (the TYPO3 install tool or login endpoint).
  3. Check interval: 2 minutes
  4. Expected HTTP status: 200 (or 302 if your backend redirects to the login form — use the login page URL directly if so)
  5. Under Keyword check, enter TYPO3 to verify the backend login page content loads.
  6. Click Save.

A backend availability monitor is especially important when the frontend is heavily cached — TYPO3 can serve cached frontend pages for hours after the backend breaks, masking the failure until editors try to publish.

Step 3: Add a TYPO3 Health Check Endpoint

TYPO3 12+ includes a built-in system health check that verifies database connectivity, cache backends, file permissions, and extension compatibility. Add a monitor on this endpoint for a single-request check of the entire TYPO3 stack:

  1. Enable the TYPO3 system status API in your AdditionalConfiguration.php:
// typo3conf/AdditionalConfiguration.php
$GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSL'] = true;
// Enable health check endpoint (TYPO3 12+)
$GLOBALS['TYPO3_CONF_VARS']['SYS']['trustedHostsPattern'] = 'your-monitoring-ip';
  1. Click Add Monitor → HTTP / HTTPS.
  2. URL: https://www.yourdomain.com/typo3/ajax/status (adjust to your TYPO3 version's health endpoint).
  3. Check interval: 2 minutes
  4. Expected HTTP status: 200
  5. Click Save.

Alternatively, create a lightweight custom health controller in your site extension that checks database connectivity and returns a simple ok response — this is more stable across TYPO3 versions.

Step 4: Monitor the Database

TYPO3 stores all pages, content elements, users, file references, extension data, and Scheduler task records in its database. A database failure causes both the frontend (for uncached pages) and the backend to return errors.

For MySQL/MariaDB:

  1. Click Add Monitor → TCP Port.
  2. Host: localhost (or your DB host).
  3. Port: 3306
  4. Check interval: 1 minute
  5. Click Save.

For PostgreSQL:

  1. Click Add Monitor → TCP Port.
  2. Host: localhost
  3. Port: 5432
  4. Check interval: 1 minute
  5. Click Save.

If you have read replicas serving TYPO3 frontend traffic, add TCP monitors for each replica host too — a replica failure that TYPO3 doesn't automatically retry causes slow or failing page loads without any obvious signal.

Step 5: Monitor Redis Cache Health

If you've configured TYPO3's caching framework to use Redis as a backend (a common configuration for high-traffic TYPO3 sites), Redis availability directly affects page cache hit rate. A Redis failure forces TYPO3 to fall back to database-backed caching or no caching at all — causing significant DB load spikes.

Monitor Redis TCP port:

  1. Click Add Monitor → TCP Port.
  2. Host: localhost (or your Redis host).
  3. Port: 6379
  4. Check interval: 1 minute
  5. Click Save.

Monitor Redis memory usage via heartbeat:

Redis Out-of-Memory (OOM) conditions cause cache write failures without taking the TCP port down. Monitor Redis memory utilization with a heartbeat:

#!/bin/bash
# /usr/local/bin/check-redis-typo3.sh
REDIS_MAX_MB=512  # your configured maxmemory in MB
REDIS_USED=$(redis-cli info memory | grep "used_memory:" | awk -F: '{print $2}' | tr -d 'rn')
REDIS_USED_MB=$((REDIS_USED / 1048576))

if [ "$REDIS_USED_MB" -lt "$REDIS_MAX_MB" ]; then
  curl -sf "https://vigilmon.online/heartbeat/your-redis-heartbeat-id" > /dev/null
fi

Add to crontab:

*/5 * * * * /usr/local/bin/check-redis-typo3.sh

Step 6: Monitor PHP-FPM Worker Utilization

TYPO3 is a PHP application served by PHP-FPM. When all PHP-FPM workers are busy (pool exhaustion), new requests queue and then time out — causing frontend and backend HTTP errors even though the server is healthy and the database is up.

  1. Click Add Monitor → Cron Heartbeat.
  2. Set the expected interval to 5 minutes.
  3. Copy the heartbeat URL.
  4. Create a script that checks PHP-FPM pool utilization:
#!/bin/bash
# /usr/local/bin/check-phpfpm-typo3.sh
# Requires PHP-FPM status page enabled in your pool config
POOL_STATUS=$(curl -sf "http://localhost/fpm-status?json" 2>/dev/null)

if [ -z "$POOL_STATUS" ]; then
  echo "PHP-FPM status unavailable" >&2
  exit 1
fi

ACTIVE=$(echo "$POOL_STATUS" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('active processes', 0))")
TOTAL=$(echo "$POOL_STATUS" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('max children reached', 0) + d.get('total processes', 0))")
MAX_CHILDREN=$(echo "$POOL_STATUS" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('max children reached', 0))")

# Alert if pool has hit max children (exhaustion signal)
if [ "$MAX_CHILDREN" -eq 0 ]; then
  curl -sf "https://vigilmon.online/heartbeat/your-phpfpm-heartbeat-id" > /dev/null
fi

Enable the PHP-FPM status page in your pool configuration (/etc/php/8.x/fpm/pool.d/typo3.conf):

pm.status_path = /fpm-status

*/5 * * * * /usr/local/bin/check-phpfpm-typo3.sh

Step 7: Monitor TYPO3 Scheduler Job Success

The TYPO3 Scheduler runs critical background tasks: cache clearing, search indexing, link validation, import jobs, and newsletter sending. Silent Scheduler failures accumulate as outdated indexes, stale caches, and missed imports — without any user-visible error.

  1. Click Add Monitor → Cron Heartbeat.
  2. Set the expected interval to match your most critical Scheduler task frequency (typically 60 minutes for hourly tasks, 1440 minutes for daily).
  3. Copy the heartbeat URL.
  4. Add a Vigilmon ping to your Scheduler task wrapper via a custom TYPO3 task:
<?php
// In your TYPO3 extension: Classes/Task/HealthCheckTask.php
namespace YourVendor\YourExtension\Task;

use TYPO3\CMS\Scheduler\Task\AbstractTask;

class HealthCheckTask extends AbstractTask
{
    public function execute(): bool
    {
        // Run after your critical tasks succeed
        $url = 'https://vigilmon.online/heartbeat/your-scheduler-heartbeat-id';
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_TIMEOUT, 5);
        curl_exec($ch);
        curl_close($ch);
        return true;
    }
}

Register the task in your extension's ext_localconf.php and add it to the Scheduler with the appropriate frequency. When the Scheduler stops running (due to a PHP error, locked task, or Scheduler daemon failure), the heartbeat stops and Vigilmon alerts you.

Step 8: Monitor fileadmin Storage Space

TYPO3 stores all user-uploaded media — images, PDFs, documents — in the fileadmin/ directory (or your configured file storage paths). Storage exhaustion causes silent upload failures: editors see error messages, but the public site continues serving existing cached media.

  1. Click Add Monitor → Cron Heartbeat.
  2. Set the expected interval to 60 minutes.
  3. Copy the heartbeat URL.
  4. Create a script that checks disk usage and emits a heartbeat while space is available:
#!/bin/bash
# /usr/local/bin/check-typo3-storage.sh
FILEADMIN_PATH="/var/www/typo3/fileadmin"
USAGE=$(df -h "$FILEADMIN_PATH" | awk 'NR==2 {print $5}' | tr -d '%')

if [ "$USAGE" -lt 80 ]; then
  curl -sf "https://vigilmon.online/heartbeat/your-storage-heartbeat-id" > /dev/null
fi

0 * * * * /usr/local/bin/check-typo3-storage.sh

When usage hits 80%, the heartbeat stops and Vigilmon alerts you — giving you time to archive media or expand storage before uploads start failing.

Step 9: Monitor TYPO3 Extension Security Status via Heartbeat

Outdated TYPO3 extensions with known security vulnerabilities are a common attack vector. TYPO3's Security Advisory feed tracks vulnerable extensions. Monitor for insecure extensions using a heartbeat that checks the TYPO3 extension update status.

  1. Click Add Monitor → Cron Heartbeat.
  2. Set the expected interval to 1440 minutes (daily).
  3. Copy the heartbeat URL.
  4. Use the TYPO3 CLI to check for insecure extensions:
#!/bin/bash
# /usr/local/bin/check-typo3-extensions.sh
TYPO3_PATH="/var/www/typo3"

# Use TYPO3 console (typo3) or extension manager CLI
INSECURE=$(cd "$TYPO3_PATH" && php typo3 extension:list \
  --format=json 2>/dev/null | \
  python3 -c "import sys,json; exts=json.load(sys.stdin); print(sum(1 for e in exts if e.get('state')=='insecure'))" 2>/dev/null || echo "0")

if [ "$INSECURE" -eq 0 ]; then
  curl -sf "https://vigilmon.online/heartbeat/your-extensions-heartbeat-id" > /dev/null
fi

0 6 * * * /usr/local/bin/check-typo3-extensions.sh

When a TYPO3 security advisory flags an installed extension as insecure, the heartbeat stops pinging and Vigilmon notifies you — prompting immediate extension update before the vulnerability is exploited.

Step 10: Configure Alert Channels and Thresholds

  1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook.
  2. For the frontend HTTP monitor, set Consecutive failures before alert to 2 — brief transient errors during deployments or cache clears are normal.
  3. For the backend HTTP monitor, set to 2 for the same reason.
  4. For the database TCP monitors, set to 1 — database loss causes immediate frontend 500 errors for uncached pages and total backend failure.
  5. For the Redis TCP monitor, set to 1 — cache loss causes immediate DB load spike that can cascade into performance degradation.
  6. For all cron heartbeats (PHP-FPM, Scheduler, storage, extensions), leave at the default heartbeat expiry window.
  7. Route extension security alerts to your development team as a P2 — they require code changes (extension updates), not infrastructure action.

Docker Compose Integration

If you run TYPO3 via Docker Compose, add health checks to your service definitions so Vigilmon's external view aligns with Docker's restart policies:

services:
  typo3:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost/"]
      interval: 30s
      timeout: 10s
      retries: 3

  db:
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 3s
      retries: 3

Vigilmon provides the external signal — confirming your TYPO3 site is reachable from outside the container network — while Docker health checks handle internal service restart orchestration.

Summary

| Monitor | Target | What It Catches | |---|---|---| | Frontend HTTP | https://www.domain.com/ | Page rendering failure, 5xx errors | | Backend HTTP | https://www.domain.com/typo3/ | CMS admin interface unavailable | | MySQL/MariaDB TCP | :3306 | Database connectivity loss | | PostgreSQL TCP | :5432 | Database connectivity loss | | Redis TCP | :6379 | Cache backend connectivity loss | | Redis memory heartbeat | redis-cli info check | OOM causing cache write failures | | PHP-FPM heartbeat | FPM status page | Worker pool exhaustion | | Scheduler heartbeat | Custom Scheduler task | Background job failure | | fileadmin storage heartbeat | Disk usage check | Storage >80% blocking uploads | | Extension security heartbeat | TYPO3 CLI check | Insecure extensions installed |

TYPO3's enterprise feature set comes with an enterprise-grade dependency stack — PHP-FPM, a relational database, a multi-layer caching framework, a Scheduler daemon, and growing fileadmin storage all need to stay healthy for editors and visitors to get a reliable experience. With Vigilmon monitoring the full stack, you catch failures at every layer before they surface as content editor complaints, slow page loads, or security vulnerabilities in production.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles