Zum Inhalt springen

MediaWiki-Dockerized: Docker Compose Setup mit Elasticsearch und Memcached

Aus LHlab Wiki

MediaWiki-Dockerized: In Minuten startklar mit Docker Compose und vorkonfigurierten Images. Inklusive Elasticsearch-Suche, Memcached-Performance, ClamAV Virenscanner, Short-URLs und automatischer Sitemap Generierung. Perfekt um schnell ein eigenes MediaWiki Setup in Minuten hochzuziehen.

Was dieses Setup bietet

  • Sofort startklar: MediaWiki als fertiges Docker-Image
  • Volltextsuche: Elasticsearch (Elastica) + CirrusSearch (inkl. RelatedArticles-Unterstützung)
  • Performance: Memcached als Objekt-Cache
  • Sicherheit: Uploads werden auf Viren geprüft
  • Schöne URLs: /wiki/Seitentitel (Short-URLs)
  • Sitemaps: automatische Generierung + Redirect von /sitemap.xml
  • Admin-Tools: MemcachePHP-Weboberfläche (per Reverse-Proxy via Wiki erreichbar)
  • Externe Links Prüfung: RottenLinks Extension, via cronjob steuerbar
  • MediaWiki Extensions inklusive: Lockdown, Description2, RelatedArticles, MobileFrontend, CirrusSearch, Elastica, HitCounters, TopTenPages, RottenLinks, WikiCategoryTagCloud, CookieConsent, DynamicPageList (*intersection)
  • Code in GitHub: https://github.com/alaub81/mediawiki

Voraussetzungen

  • Docker + Docker Compose
  • 1-2 GB RAM (für Elasticsearch; Heap standardmäßig 512 MB, bei Bedarf 1 GB)
  • rechnet mit eher 2-3GB RAM wenn ihr ClamAV mit starten möchtet

Schnellstart

1) Docker Compose Ordner anlegen

als erstes müssen wir den Projektordner anlegen und springen in diesen:

mkdir -p /opt/mediawiki
cd /opt/mediawiki

2) .env anlegen

Erstelle eine Datei .env mit mindestens:

/opt/mediawiki/.env

## MediaWiki Port Configuration
MW_HTTP_PORT=8080

# MW_SERVER=https://www.example.com
MW_SERVER_URL=http://localhost:8080

# Maria DB initial Root password
MARIADB_ROOT_PASSWORD=R00tPassword

# Enable ClamAV
COMPOSE_PROFILES=clamav
CLAMAV_ENABLED=true

# Timezone
TZ=Europe/Berlin

# (optional) MemcachePHP UI
# Memcache PHP Basic Auth
MEMCACHEPHP_ADMIN_USER=admin
MEMCACHEPHP_ADMIN_PASS=supersecret
# MemecachePHP Port Configuration
MEMCACHEPHP_HTTP_PORT=8097

# (optional) Elasticsearch Heap (an Container-RAM anpassen)
ES_JAVA_OPTS=-Xms512m -Xmx512m

Hinweis: Das Setup ist so gebaut, dass es beim ersten Start die LocalSettings.php automatisch erzeugt/ergänzt (Short-URLs, Cache, CirrusSearch-Basis etc.) wenn man noch eine .env.mwsetup mit den MediaWiki Setup Parametern anlegt. Ansonsten kommt der MediaWiki Webinstaller beim Aufruf der MediaWiki URL.

3) .env.mwsetup anlegen

Für den Schnellstart legen wir noch die MediaWiki Setup Konfiguration an mit mindestens:

/opt/mediawiki/.env.mwsetup

# MediaWiki Configurations when using mw-default-setup.sh
# don't change the file name, only the path!
MW_CONFIG_FILE="/var/www/html/conf/LocalSettings.php"
# MediWiki Site
MW_SITENAME="My Own Wiki"
MW_LANG=de
MW_ADMIN_USER=Admin
MW_ADMIN_PASS=AdminPass123

3) docker-compose.yml anlegen

nun legen wir die benötigte docker-compose.yml an:

/opt/mediawiki/docker-compose.yml

services:
  mediawiki:
    image: ghcr.io/alaub81/mediawiki-custom:${MW_VERSION:-latest}
    depends_on:
      - database
      - memcached
      - elasticsearch
    environment:
      MARIADB_ROOT_PASSWORD: ${MARIADB_ROOT_PASSWORD:-R00tPassword}
      MW_SERVER_URL: ${MW_SERVER_URL:-http://localhost:8080}
      TZ: ${TZ:-UTC}
    env_file:
      - .env.mwsetup
    ports:
      - ${MW_HTTP_PORT:-8080}:80
    volumes:
      - data_mw_images:/var/www/html/images
      # After initial setup, download LocalSettings.php to data/conf directory
      # and uncomment the following line and use compose to restart
      # the mediawiki service
      # - ./data/mediawiki/conf/LocalSettings.php:/var/www/html/LocalSettings.php:ro
      # or custom config file don't forget to set MW_CONFIG_FILE env var in .env
      - ./data/mediawiki/conf/mw_local_settings:/var/www/html/conf/:rw

  database:
    image: mariadb:${MARIADB_VERSION:-11.8}
    volumes:
      - data_db:/var/lib/mysql
    restart: unless-stopped
    environment:
      MARIADB_ROOT_PASSWORD: ${MARIADB_ROOT_PASSWORD:-R00tPassword}
      TZ: ${TZ:-UTC}

  clamav:
    image: clamav/clamav-debian:${CLAMAV_VERSION:-stable}
    restart: unless-stopped
    profiles: ["clamav"]
    volumes:
      - clamav_db:/var/lib/clamav
      # if you want to use custom clamd.conf, uncomment the following line
      # - ./data/clamav/conf/clamd.conf:/etc/clamav/clamd.conf:ro
    environment:
      - TZ=${TZ:-UTC}
    labels:
      com.centurylinklabs.watchtower.enable: true
    healthcheck:
      # Checks: clamd answers PONG to PING
      test: ["CMD-SHELL", "echo PING | nc -w 5 127.0.0.1 3310 | grep -q PONG"]
      interval: 30s
      timeout: 10s
      retries: 5
    networks:
      backend-nw:
      # need app-nw for fetching updates
      app-nw:

  memcached:
    image: memcached:${MEMCACHED_VERSION:-alpine}
    restart: unless-stopped
    command: ["-m", "${MEMCACHED_CACHE_MB:-16}"]
    environment:
      - TZ=${TZ:-UTC}

  memcachephp:
    image: ghcr.io/alaub81/memcachephp:${MEMCACHEPHP_VERSION:-latest}
    restart: unless-stopped
    depends_on:
      - memcached
    environment:
      TZ: ${TZ:-UTC}
      MEMCACHEPHP_ADMIN_USER: ${MEMCACHEPHP_ADMIN_USER:-admin}
      MEMCACHEPHP_ADMIN_PASS: ${MEMCACHEPHP_ADMIN_PASS:-supersecret}
    ports:
      - ${MEMCACHEPHP_HTTP_PORT:-8097}:80

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:${ES_VERSION:-7.10.2}
    restart: unless-stopped
    environment:
      "discovery.type": "single-node"
      ES_JAVA_OPTS: "-Xms${ES_HEAP_MIN:-512m} -Xmx${ES_HEAP_MAX:-512m}"
    volumes:
      - data_esdata:/usr/share/elasticsearch/data
    ulimits:
      memlock:
        soft: -1
        hard: -1

volumes:
  data_db:
  data_mw_images:
  clamav_db:  
  data_esdata:

4) Stack starten

# Stack Starten
docker compose up -d

Hinweis: Würde man jetzt die URL des MediaWiki im Browser öffnen, kommt der MediaWiki Webinstaller. Gerne kann man diesen auch nun einfach durchklicken und am Ende die LocalSettings.php herunterladen und ablegen in /opt/mediawiki/data/mediawiki/conf/LocalSettings.php . Mehr dazu hier: MediaWiki Web Setup

5) mw-default-setup.sh starten

Nun starten wir das Setup Script mw-default-setup.sh

# www-data Rechte geben auf den Ordner, damit LocalSettings.php
# geschrieben werden kann
chown www-data:www-data data/mediawiki/conf/mw_local_settings/
# ausführen des Installers mit user www-data
docker compose exec -T -u www-data mediawiki sh -lc '
    /usr/local/bin/mw-default-setup.sh'

6) Wiki aufrufen

Nun sollte das Wiki unter der in der in .env (MW_SERVER_URL) konfigurierten URL aufrufbar sein.

MediaWiki Web Setup

Möchtet ihr lieber das Web Setup nutzen, dann lasst einfach den Step 5) mw-default-setup.sh starten weg und öffnet die Website, klickt euch einfach durch den Assistenten durch. Zu beachten ist dabei folgendes:

  • MariaDB, MySQL (oder kompatible Datenbanksysteme) auswählen
  • Datenbankserver: database
  • Root Passwort: aus eurer .env von der Variable MARIADB_ROOT_PASSWORD (R00tPassword)
  • auf der nächsten Seite, Datenbankkonto für den Webzugriff empfehle ich einen eigenen User für das Web anzulegen, für Tests könnt ihr aber auch einfach den Haken bei "Dasselbe Datenbankkonto wie während des Installationsvorgangs verwenden" lassen
  • auf der nächsten Seite konfiguriert ihr euren "Admin User" und alles weitere was mit dem Wiki zu tun hat. Ihr könnt nun untern entscheiden ob euch das erst einmal reicht an Konfiguration, oder ob ihr noch mehr Details wie zum Beispiel das Auswählen der Extensions, des Standard Skins, der Lizenz etc. einrichten wollt. Alles kann auch später über das Anpassen der LocalSettings.php gemacht werden. Was ihr bei Erweiterte Konfiguration machen solltet ist das Konfigurieren des memached, hierfür einfach memcached:11211 eintragen

Hat dann alles gepasst solltet ihr das hier sehen und in einem nächsten Schritt die vorgefertigte LocalSettings.php downloaden können.

Die heruntergeladene LocalSettings.php legt ihr nun bitte in /opt/mediawiki/data/mediawiki/conf/ ab und gebt ihr die richtigen Rechte.

chown www-data:www-data /opt/mediawiki/data/mediawiki/conf/LocalSettings.php

nun müssen wir in der docker-compose.yml den .env.mwsetup part entfernen oder auskommentieren und den volume mount auf unsere LocalSettings.php herstellen: /opt/mediawiki/docker-compose.yml

...

    #env_file:
    #  - .env.mwsetup
    ports:
      - ${MW_HTTP_PORT:-8080}:80
    volumes:
      - data_mw_images:/var/www/html/images
      # After initial setup, download LocalSettings.php to data/conf directory
      # and uncomment the following line and use compose to restart
      # the mediawiki service
      - ./data/mediawiki/conf/LocalSettings.php:/var/www/html/LocalSettings.php:ro
      # or custom config file don't forget to set MW_CONFIG_FILE env var in .env
      #- ./data/mediawiki/conf/mw_local_settings:/var/www/html/conf/:rw

...

danach starten wir den Docker Compose Stack erneut:

docker compose up -d

Nun solltet ihr bei Aufruf der URL euer MediaWiki sehen!

Vollständiges Setup (via GitHub Repo)

wollt ihr das gesamte Paket und alle Konfigurationsmöglichkeiten, dann nutzt am besten das gesamte GitHub Repository

cd /opt/
git clone https://github.com/alaub81/mediawiki.git
cd /opt/mediawiki

hier könnt ihr euch dann einfach die Beispiel Konfigurationen kopieren:

  • .env.example
  • docker-compose.yml
  • (Optional) data/mediawiki/conf/LocalSettings.php.example
cp .env.example .env
cp docker-compose.example.yml docker-compose.yml
# Optional: nur wenn du eine komplett vorkonfigurierte LocalSettings.php nutzen möchtest
cp data/mediawiki/conf/LocalSettings.php.example data/mediawiki/conf/LocalSettings.php
# Optional: .htaccess
cp data/mediawiki/conf/.htaccess.example data/mediawiki/conf/.htaccess
# Optional: robots.txt
cp data/mediawiki/conf/robots.txt.example data/mediawiki/conf/robots.txt

passt alle Dateien nach euren Wünschen an, es gibt hier wieder mehrere Optionen des Setups:

  • via Web Setup: wenn alles eingestellt ist, fahrt den Stack einfach hoch:
    docker compose up -d
    und haltet euch dann an das Kapitel MediaWiki Web Setup
  • via mw-default-setup: hier nutzen wir wieder die .env.mwsetup, nicht vergessen in der docker-compose.yml die .env.mwsetup als env_file: einzulesen und den Konfigurationsordner bei volumes: zu mounten - einfügen, bzw. einkommentieren:
    ...
    env_file:
      - .env.mwsetup
...    

    volumes:
...
      - ./data/mediawiki/conf/mw_local_settings:/var/www/html/conf/:rw
...
    dann fahren wir den Stack hoch
    docker compose up -d
    und installieren wir das Wiki indem wir mw-default-setup.sh starten.
  • (Optional) via LocalSettings.php (Hinweis: hier müsst ihr, vorher die MediaWiki Datenbank im MariaDB Container anlegen!) .env ergänzen bzw, einkommentieren:
    ## Optional:
MARIADB_DATABASE=wiki
MARIADB_USER=wikiuser
MARIADB_PASSWORD=w1k1pass
    dann in der docker-compose.yml die Zeile bei volumes: einfügen, bzw. einkommentieren: 
          - ./data/mediawiki/conf/LocalSettings.php:/var/www/html/LocalSettings.php:ro
    dann starten wir und legen wir die DB an:
    # Stack hochfahren
docker compose up -d
# DB anlegen
docker compose exec -T -u www-data mediawiki sh -lc '
  php maintenance/run.php installPreConfigured'

Nun solltet ihr bei Aufruf der URL euer MediaWiki sehen!

Next Steps

Volltextsuche (Elastic Search + CirrusSearch)

Die Kombination aus Elastic Search und den beiden Extensions CirrusSearch und Elastica, schafft die Grundlage für das Anzeigen automatischer Related Articles und Verbessert die Suchfunktionalität des MediaWiki enorm. Damit hier alles funktioniert muss ein Index in Elastic Search aufgebaut werden und dieser immer wieder aktualisiert werden. Die Konfigurationen dazu findet ihr in der .env:

## --- MediaWiki CirrusSearch Index Configuration ---
MW_CS_INDEX_UPDATE=true
MW_CS_INDEX_CRON=*/15 * * * *
MW_CS_INDEX_RUN_ON_START=false

Hier müsst ihr eigentlich nichts machen, da alle nötigen Jobs im Hintergrund ablaufen, das einzige was man regelmäßig aktualisieren muss sind die Such Indexe, dies geschieht automatisch via supercron cron Job. oder beim Start des Containers mit MW_CS_INDEX_RUN_ON_START=true . Dadurch verlängert sich der Start des Containers, deshalb meine Empfehlung lasst es auf false.

Sollte doch etwas nicht funktionieren und die Suche Fehler ausgeben liegt es sicher am Elastic Search Index. Ihr könnt zum Neuaufbau des Indexes dieses helper Script im MediaWiki Container ausführen. Auch Hilfreich wenn ihr bereits ein laufendes System habt und ihr nun diesen Stack mit den alten Daten verwenden möchtet.

Indizes einmalig aufbauen:

docker compose exec -T mediawiki sh -lc '/usr/local/bin/generate-elasticindex.sh'

Das Script richtet die Cirrus-Metadaten und durchläuft das Indexieren. Danach sind Suche/Autocomplete und (falls aktiviert) RelatedArticles funktionsfähig. Die Dazugehörigen Konfigurationszeilen der LocalSettings.php sind dann im übrigen:

# Laden der Extensions
wfLoadExtension( 'Elastica' );
wfLoadExtension( 'CirrusSearch' );

# Konfiguration und Aktivierung
$wgSearchType = 'CirrusSearch';
$wgCirrusSearchServers = [ 'elasticsearch' ];
$wgCirrusSearchUseCompletionSuggester = true;

Sitemaps aktivieren (optional)

Die Sitemap Generierung wird über das .env file gesteuert:

## --- MediaWiki Sitemap Configuration ---
MW_SITEMAP_GENERATION=true
MW_SITEMAP_CRON=20 */12 * * *
MW_SITEMAP_RUN_ON_START=true
## for testing every minute
# MW_SITEMAP_CRON=* * * * *
MW_SITEMAP_URLPATH=sitemap
MW_SITEMAP_SKIP_REDIRECTS=true
## Optional:
# MW_SITEMAP_SERVER=${MW_SERVER:-http://localhost:8080}
# MW_SITEMAP_IDENTIFIER=wiki

Die Standard Einstellungen können so beibehalten werden. Die Sitemap wird immer beim Start des Containers erstellt, ansonsten um 00:20 Uhr und um 12:20 Uhr, also alle 12h was vollkommen ausreichend ist. Solltet ihr ein richtig großes Setup haben, ist es sicherlich gut, wenn ihr die Generierung beim Start deaktiviert, damit der Container schneller verfügbar ist - MW_SITEMAP_RUN_ON_START=false

Sitemap sofort erzeugen:

docker compose exec -T mediawiki sh -lc '/usr/local/bin/generate-sitemap.sh'
  • Aufruf: /sitemap.xml → 301-Redirect zur aktuellen Sitemap-Datei
  • Automatischer Rhythmus per Cron ist vorkonfigurierbar (MW_SITEMAP_CRON ).

Die RottenLinks Extension ist sinnvoll, wenn man sehen möchte welche extern verlinkten Seiten nicht mehr existieren oder erreichbar sind. Sollte man aus SEO Sicht öfters einmal nachschauen und Links, die nicht mehr funktionieren austauschen oder löschen.

Ähnliche er Sitemap kann die Generierung dieser Liste auch über die .env gesteuert werden:

## --- MediaWiki RottenLinks Configuration ---
MW_ROTTENLINKS_GENERATION=true
MW_ROTTENLINKS_CRON=30 */12 * * *
## for testing every minute
# MW_ROTTENLINKS_CRON=* * * * *
MW_ROTTENLINKS_RUN_ON_START=false

Da die Generierung sehr lange dauern kann, empfiehlt es sich die Option MW_ROTTENLINKS_RUN_ON_START auf false zu lassen. Die Liste kann dann unter Spezial:RottenLinks angeschaut werden. Die Extension sollte in der LocalSettings.php geladen werden:

# Laden der Extension RottenLinks
wfLoadExtension( 'RottenLinks' );

hier ist eigentlich nichts zu tun, die Konfiguration dazu spielt sich rein in der LocalSettings.php ab:

# Laden der Extension RelatedArticles
wfLoadExtension( 'RelatedArticles' );

# Related Articles using CirrusSearch
$wgRelatedArticlesDescriptionSource = 'pagedescription';
$wgRelatedArticlesUseCirrusSearchApiUrl = '/api.php';
$wgRelatedArticlesUseCirrusSearch = true;
$wgRelatedArticlesCardLimit = 6;

Diese Konfiguration lädt die MediaWiki-Extension RelatedArticles und konfiguriert sie so, dass verwandte Artikel über CirrusSearch ermittelt werden. Als Beschreibung wird die Seitenauskunft (pagedescription) genutzt, die API liegt unter /api.php, und es werden bis zu 6 Karten angezeigt.

ShortUrls

Auch die Short Urls werden standardmäßig vom Stack vorkonfiguriert und müssen nur noch in der LocalSettings.php wie folgt aktiviert werden:

$actions = [
        'edit',
        'watch',
        'unwatch',
        'delete',
        'revert',
        'rollback',
        'protect',
        'unprotect',
        'markpatrolled',
        'render',
        'submit',
        'history',
        'purge',
        'info',
];

foreach ( $actions as $action ) {
  $wgActionPaths[$action] = "/wiki/$action/$1";
}
$wgActionPaths['view'] = "/wiki/$1";
$wgArticlePath = "/wiki/$1";

Der ArticlePath oder $wgActionPaths ist nicht änderbar und muss /wiki/ sein, da dazu eine apache configuration im Hintergrund gehört. /wiki/ ist best practice!

robots.txt und .htaccess

Was man auch bei einer offenen Webseite einrichten sollte ist eine robots.txt. hier ein gutes Beispiel für MediaWiki Installationen:

/opt/mediawiki/data/mediawiki/conf/robots.txt

User-agent: *
Disallow: /index.php
Disallow: /Index.php
Disallow: /*Spezial:
Disallow: /*Diskussion:
Sitemap: https://www.example.com/sitemap/sitemap-index-wiki.xml

Passt die Sitemap URL an! und dann mountet die Datei in euer MediaWiki Root Verzeichnis als volume: mount: docker-compose.yml

- ./data/mediawiki/conf/robots.txt:/var/www/html/robots.txt:ro

Das gleiche kann man auch mit einer .htaccess machen, die zum Beispiel einen redirect auf das favicon.ico und das apple-touch-icon.png macht: /opt/mediawiki/data/mediawiki/conf/.htaccess

Redirect 301 /favicon.ico /favicon/favicon.ico
Redirect 301 /apple-touch-icon.png /favicon/apple-touch-icon.png

docker-compose.yml

      - ./data/mediawiki/conf/.htaccess:/var/www/html/.htaccess:ro

dann zum Aktivieren den Stack neu Starten:

docker compose up -d

ClamAV Virenscanning

Hinweis: ClamAV benötigt von sich aus schon mehr als 1GB Ram. Optional kann man auch einen Shared ClamAV Service betreiben:

Möchtet ihr beim Upload von Dateien, diese auf Viren prüfen, übernimmt das ClamAV. Zum aktiveren müsst ihr lediglich in der .env schauen, das die folgenden Zeilen zu finden sind:

.env

COMPOSE_PROFILES=clamav
CLAMAV_ENABLED=true
## ClamAV Host and Port (optional, default values)
CLAMAV_HOST=clamav
CLAMAV_PORT=3310

Dann sollte in der LocalSettings.php dieser Abschnitt zu finden sein:

# Antivirus integration (ClamAV)
$clamavEnabled = filter_var(getenv('CLAMAV_ENABLED') ?: 'false', FILTER_VALIDATE_BOOLEAN);
if ($clamavEnabled) {
    $wgAntivirus = 'clamav';
    $wgAntivirusRequired = true;
    $wgAntivirusSetup['clamav'] = [
        'command' => '/usr/bin/clamdscan --no-summary --stdout --config-file=/etc/clamav/clamd.remote.conf %f',
        'codemap' => [
            0 => AV_NO_VIRUS,
            1 => AV_VIRUS_FOUND,
            2 => AV_SCAN_FAILED,
            '*' => AV_SCAN_FAILED,
        ],
    ];
} else {
    $wgAntivirus = false;
}

und wenn ihr dann noch Uploads größer 25Mb erlauben wollt, kopiert euch die Sample Config und startet den ClamAV Container neu:

cp data/clamav/conf/clamd.conf.example data/clamav/conf/clamd.conf
docker compose restart clamav

data/clamav/conf/clamd.conf

## Example clamd.conf file for ClamAV daemon
## TCP socket for clamd to listen on
TCPSocket 3310
## Uncomment and set the TCP address to bind to
# TCPAddr 0.0.0.0

## Log file location
# LogFile /var/log/clamav/clamd.log

## Lower concurrency → less per-thread memory
MaxThreads 2             # default often 12; lower = smaller footprint

## Avoid double RAM usage during DB reloads
ConcurrentDatabaseReload no   # reduces peak RAM during freshclam reload

## Reduce engine features (saves RAM, small detection tradeoffs)
Bytecode no              # disable bytecode engine (saves memory)
DisableCache yes         # drop internal caches (more CPU, less RAM)

## Keep stream scanning, but cap worst-case memory per request
StreamMaxLength 100M     # align with your MediaWiki uploads (e.g., 200M)
MaxScanSize 100M         # hard cap for total scanned data per file
MaxFileSize 100M         # cap single file size to inspect
MaxRecursion 16          # avoid deep archive recursion blowups

Weiteres...

Debugging

Die folgenden Debugging Optionen können in der LocalSettings.php gesetzt werden

LocalSettings.php

## Debuging Settings
# $wgShowExceptionDetails = true;
# $wgShowDBErrorBacktrace = true;
# $wgShowSQLErrors = true;
## Deprecated Messages
# $wgShowDebug = true;
# $wgDevelopmentWarnings = true;
# $wgDeprecationReleaseLimit = '1.43';
# error_reporting(0);

Aktualisieren des Stacks

Möchte man nun ein Update des gesamten Stacks einspielen, muss man zunächst die Versionsnummer der Docker Images prüfen und ggf. einen neuen Docker Image Tag konfigurieren. dies passiert in der .env

## --- Docker Image Versions ---
## MediaWiki-Custom Docker image version tag
MW_VERSION=1.44
## if you are switching to a new release,
## don't forget to enable MW_AUTO_UPDATE (to true)
## switch back (false), after first run is completed
MW_AUTO_UPDATE=false

## Check compatibility depending to the MediaWiki version
## MariaDB Docker image version Tag
MARIADB_VERSION=11.8
## ClamAV Docker image version tag
CLAMAV_VERSION=stable
## ElasticSearch Docker image version tag
ES_VERSION=7.10.2
## Memcached Docker image version Tag
MEMCACHED_VERSION=alpine
## MemcachePHP Docker image version Tag
MEMCACHEPHP_VERSION=${MW_VERSION}

Meine Empfehlung, nutzt im besten Fall nicht den Tag latest in einem Produktivsystem, sondern pinnt immer die Versionsnummer fest. Da ich immer einen Build mache vom Image mediawiki-custom und memcachePHP und beide immer den selben Tag haben, könnt ihr einfach bei MEMCACHEPHP_VERSION=${MW_VERSION} stehen lassen. Zu beachten ist hier auf jeden Fall, das alle anderen Versionen Kompatibel sein müssen, also nicht einfach wahllos erhöhen. Nun zum eigentlichen Update. Kommt es zu einem MediaWiki Update, muss zwingend in der .env MW_AUTO_UPDATE auf true gesetzt werden! Dann wie folgt:

cd /opt/mediawiki

# falls aus GitHub gezogen:
git pull

# Images ziehen
docker compose pull

# Stack neu starten
docker compose up -d

und nach dem Start in der .env wieder MW_AUTO_UPDATE auf false setzen.

Backup

hier verweise ich auf die folgenden Artikel:

Abgerufen von „https://lhlab.wiki/index.php?title=MediaWiki-Dockerized:_Docker_Compose_Setup_mit_Elasticsearch_und_Memcached&oldid=10275“