Dieses Tutorial ist VALID.

Bitte lies Dir den Disclaimer durch, bevor Du eine Anleitung umsetzt...

Haftungsausschluss / Disclaimer

Matomo Docker Image erstellen

Warum bauen wir ein eigenes Image für Matomo?

Matomo hieß früher mal Piwik und ist ein User-Tracker. Ich verwende ihn, um damit in meinen WordPress Blogs die Benutzer zu zählen. Du brauchst einfach ein Vehikel das Dir sagt, welche Beiträge am meisten gelesen wurden. Und nützlich ist zu sehen, ob die geneigten Leser mit dem Smartphone oder dem PC auf unsere Seiten kommen, um entsprechend das Layout anzupassen.

Früher hab ich einfach – wie der Rest der Welt heute noch – Google Analytics benutzt. GA ist deutlich mächtiger als Matomo und wird zudem noch bei Google gehostet, also kein Aufwand für uns. Aufgrund der schäbigen EU-DSGVO, die nur dazu da ist, uns vom Rest der Welt überholen zu lassen, sind wir gezwungen, auf eine Alternative ausweichen.

Nutzen wir Matomo, behalten wir alle Daten auf unseren eigenen Servern. Die Verarbeitung wird auch komplett von uns erledigt. Das sichert uns ein wenig gegen die unverschämte DSGVO ab.

Matomo versendet „out of the Box“ keine Mails, weswegen wir für ihn auch ein eigenes Image bauen. Und ab geht die Party…

Verzeichnisse anlegen und Config-Dateien laden

Wie legen unterhalb von „/root/docker“ ein Verzeichnis „matomo-php73-apache“ an, in dem wir die Config-Dateien und das „Dockerfile“ herunterladen bzw. erstellen. Das „Dockerfile“ ist die Steuerdatei, in der Instruktionen stehen, wie das Image „gebaut“ werden soll.

Die meisten Docker Images gibt es in verschiedenen Ausführungen. Beispielsweise mit php 7.1, 7.2 oder 7.3. Oder dem Webserver apache oder fpm. Damit wir auf den ersten Blick sehen, welches Image wir bauen möchten, schreibe ich diese Bezeichnungen mit in den Verzeichnisnamen. Sollte dann zum Beispiel php 7.4 herauskommen, legen wir dafür ein neues Verzeichnis an und sind in der Lage, zwei Images parallel zu erstellen, bis wir sicher sind, dass die neue php 7.4 Version auch vernünftig funktioniert…

Achtung: die „wget“ Befehlszeile ist sehr lang und erstreckt sich hier über mehrere Zeilen. Diese müssen bitte komplett per Copy/Paste kopiert und im Terminal in einer einzigen Kommandozeile ausgeführt werden…

Die „docker-entrypoint.sh“-Datei müssen wir noch „ausführbar“ machen, also „+x“ für „executable“.

mkdir -p ~/docker/matomo-php73-apache

wget -q -P ~/docker/matomo-php73-apache https://raw.githubusercontent.com/matomo-org/docker/2125140c0481fa39e5f1add28bcc45fd9f36e75e/apache/docker-entrypoint.sh https://raw.githubusercontent.com/matomo-org/docker/2125140c0481fa39e5f1add28bcc45fd9f36e75e/apache/php.ini

chmod +x ~/docker/matomo-php73-apache/docker-entrypoint.sh

Wir setzen gleich ein wenig höhere Limits in der „php.ini“-Datei (die Ausführungszeit von php wird auf 1800 Sekunden (30m) erhöht, das Speicherlimit auf 1024 MB), in dem wir die folgenden Instruktionen unten anhängen:

nano ~/docker/matomo-php73-apache/php.ini

max_execution_time = 1800
default_socket_timeout = 1800
memory_limit = 1024M

Dies waren die Vorbereitungen. Jetzt erstellen wir das „Dockerfile“, die Steuerdatei für den Zusammenbau des Images.

Nicht erschrecken: Das Ding ist zwar kürzer als das von Nextcloud, aber immer noch ziemlich umfangreich und „erschlägt“ einen gerne, wenn man es zum ersten Mal sieht. Zerlegt in seine Einzelbestandteile ist das Konstrukt aber verdammt logisch und nimmt dem Ganzen seinen Schrecken…

Und bis auf einige wenige Änderungen ist diese Datei auch 1:1 vom originalen Dockerfile übernommen worden.

nano ~/docker/matomo-php73-apache/Dockerfile
### MATOMO DOCKERFILE
###
##START
FROM php:7.3-apache-buster
LABEL maintainer="pierre@piwik.org"

RUN set -ex; \
	\
	savedAptMark="$(apt-mark showmanual)"; \
	\
	apt-get update; \
	apt-get install -y --no-install-recommends \
		libfreetype6-dev \
		libjpeg-dev \
		libldap2-dev \
		libpng-dev \
		libzip-dev \
	; \
	\
	debMultiarch="$(dpkg-architecture --query DEB_BUILD_MULTIARCH)"; \
	docker-php-ext-configure gd --with-freetype-dir=/usr --with-png-dir=/usr --with-jpeg-dir=/usr; \
	docker-php-ext-configure ldap --with-libdir="lib/$debMultiarch"; \
	docker-php-ext-install \
		gd \
		ldap \
		mysqli \
		opcache \
		pdo_mysql \
		zip \
	; \
	\
# pecl will claim success even if one install fails, so we need to perform each install separately
	pecl install APCu; \
	pecl install redis; \
	\
	docker-php-ext-enable \
		apcu \
		redis \
	; \
	\
# reset apt-mark's "manual" list so that "purge --auto-remove" will remove all build dependencies
	apt-mark auto '.*' > /dev/null; \
	apt-mark manual $savedAptMark; \
	ldd "$(php -r 'echo ini_get("extension_dir");')"/*.so \
		| awk '/=>/ { print $3 }' \
		| sort -u \
		| xargs -r dpkg-query -S \
		| cut -d: -f1 \
		| sort -u \
		| xargs -rt apt-mark manual; \
	\
	apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false; \
	rm -rf /var/lib/apt/lists/*

ENV MATOMO_VERSION 3.11.0

RUN set -ex; \
	fetchDeps=" \
		dirmngr \
		gnupg \
	"; \
	apt-get update; \
	apt-get install -y --no-install-recommends \
		$fetchDeps \
	; \
	\
	curl -fsSL -o piwik.tar.gz \
		"https://builds.matomo.org/piwik-${MATOMO_VERSION}.tar.gz"; \
	curl -fsSL -o piwik.tar.gz.asc \
		"https://builds.matomo.org/piwik-${MATOMO_VERSION}.tar.gz.asc"; \
	export GNUPGHOME="$(mktemp -d)"; \
	gpg --batch --keyserver ha.pool.sks-keyservers.net --recv-keys 814E346FA01A20DBB04B6807B5DBD5925590A237; \
	gpg --batch --verify piwik.tar.gz.asc piwik.tar.gz; \
	gpgconf --kill all; \
	rm -rf "$GNUPGHOME" piwik.tar.gz.asc; \
	tar -xzf piwik.tar.gz -C /usr/src/; \
	rm piwik.tar.gz; \
	apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false $fetchDeps; \

### Nach der Säuberungsaktion: msmtp SETUP Block, damit das nicht mehr gekillt wird...
    apt-get install -y --no-install-recommends \
        msmtp \
        msmtp-mta \
        bsd-mailx \
        mailutils \
        sudo \
	; \
    rm -rf /var/lib/apt/lists/*
### msmtp CONFIG Block
## "sendmail"-Pfad auf "ssmtp" umbiegen
RUN    { \
        echo 'sendmail_path = /usr/bin/msmtp -t -C /etc/msmtprc'; \
    } > /usr/local/etc/php/conf.d/sendmail.ini
## msmtp und SMTP-Postfach konfigurieren
RUN { \
        echo '# Set defaults.'; \
        echo 'defaults'; \
        echo 'logfile /var/log/msmtp.log'; \
        echo '# Enable or disable TLS/SSL encryption.'; \
        echo 'tls on'; \
        echo 'tls_starttls on'; \
        echo 'tls_certcheck off'; \
        echo '# Setup mail to send emails via SMTP'; \
        echo 'account mail'; \
        echo 'host mein.mailserver.de'; \
        echo 'port 587'; \
        echo 'auth login'; \
        echo 'user mail@mein.mailserver.de'; \
        echo 'from mail@mein.mailserver.de'; \
        echo 'password supergeheimesmailpasswort'; \
        echo '# Set a default account'; \
        echo 'account default : mail'; \
} > /etc/msmtprc \
&& chmod 600 /etc/msmtprc && chown www-data:www-data /etc/msmtprc

COPY php.ini /usr/local/etc/php/conf.d/php-piwik.ini

RUN set -ex; \
	curl -fsSL -o GeoIPCity.tar.gz \
		"https://geolite.maxmind.com/download/geoip/database/GeoLite2-City.tar.gz"; \
	curl -fsSL -o GeoIPCity.tar.gz.md5 \
		"https://geolite.maxmind.com/download/geoip/database/GeoLite2-City.tar.gz.md5"; \
	echo "$(cat GeoIPCity.tar.gz.md5)  GeoIPCity.tar.gz" | md5sum -c -; \
	mkdir /usr/src/GeoIPCity; \
	tar -xf GeoIPCity.tar.gz -C /usr/src/GeoIPCity --strip-components=1; \
	mv /usr/src/GeoIPCity/GeoLite2-City.mmdb /usr/src/piwik/misc/GeoLite2-City.mmdb; \
	rm -rf GeoIPCity*

COPY docker-entrypoint.sh /entrypoint.sh

# WORKDIR is /var/www/html (inherited via "FROM php")
# "/entrypoint.sh" will populate it at container startup from /usr/src/piwik
VOLUME /var/www/html

ENTRYPOINT ["/entrypoint.sh"]
CMD ["apache2-foreground"]
##EOF

Schauen wir uns die Blöcke mal genauer an:

Zeile 4: Das Grundlegende Image, auf dem unser Matomo-Image aufbaut, ist das „php:7.3-apache-buster“. Also ein Debian-10 Image mit Apache und PHP in Version 7.3. Dieses Image wird zuerst geladen. Alle folgenden Instruktionen im Dockerfile erweitern dieses Image dann um die jeweiligen Funktionen und Programme, bis am Schluss unser fertig modifiziertes Matomo Image dabei heraus kommt.

Zeilen 7-18: Hier werden Bibliotheken für diverse Hilfsprogramme nachgeladen. Anhand des Namens kannst Du schön erkennen, wofür die jeweils gut sind.

Zeilen 20-30: Jetzt werden eine Reihe von PHP-Erweiterungen geladen und installiert.

Zeilen 32-40: Über pecl (php extension community library) werden noch zwei Ergänzungen zur PHP-Umgebung installiert. Die sind für Caching zuständig.
Änderung gegenüber Original: Hier habe ich die Versionsnummern entfernt. Es wird also immer die aktuellste Version gezogen.

Zeilen 41-53: Die nicht mehr benötigten Hilfsprogramme werden, um Platz zu sparen, wieder entfernt. Diese waren nur zur Installation der PHP-Module nötig.

Zeile 55: Die Version von Matomo, die anschließend geladen soll, wird hier eingestellt. Sollte es eine neuere Version von Matomo geben, müssen wir die Versionsnummer an dieser Stelle anpassen und dann das Image erneut bauen.

Zeilen 57-78: Matomo wird jetzt aus den offiziellen Quellen heruntergeladen und in unser Image entpackt. Anschließend werden die Installationsdateien und nicht mehr benötigte Hilfsprogramme entfernt.

Zeilen 80-114: Das ist das von uns eingefügte Setup von „msmtp“ für den Mailversand aus dem Image heraus. Erst lassen wir die nötigen Programme in das Image installieren, danach erzeugen wir eine Config-Datei dafür. Diese Zeilen musst Du an Deine Installation anpassen:
Zeile 105: Der Hostname von Deinem Mailserver, auf dem Du das Mailkonto für den Versand angelegt hast.
Zeilen 108+109: Hier gehört zwei Mal die volle E-Mail Adresse von Deinem Mailkonto eingetragen.
Zeile 110: Das Passwort des Mailaccounts, damit die Mails auch verschickt werden können. Die Anweisung ‚password‘ bleibt stehen, Du ersetzt nur „supergeheimesmailpasswort“ durch Dein Mail Passwort…

Zeile 116: php.ini wird ins Image kopiert.

Zeilen 118-127: Die GeoDatenbank „GeoLite2-City“ wird vom Anbieter MaxMind heruntergeladen und ins Image entpackt. Die Installationsdatei wird anschließend wieder entfernt.

Zeile 129: Das Entrypoint-Script wird ins Image kopiert.

Zeile 133: Das Volume „/var/www/html“ wird der Docker-Engine zur Verarbeitung übergeben.

Zeilen 135+136: Der Entrypoint wird gesetzt und zum Abschluss kommt der Befehl, der Apache hochlaufen lässt, wenn wir den Container starten.

Image bauen

Damit ist das „Dockerfile“ fertig und wir starten den „Bauprozess“:

„docker build“ weist Docker an, aus einem Dockerfile heraus ein Image zu bauen. „-t“ ist der „Tag“, also die Bezeichnung von dem Image. Hier nenne ich das Image wie auch das Verzeichnis nach der Anwendung, der php-Version und dem verwendeten Webserver. Ein Doppelpunkt grenzt den Namen von der Versionsnummer ab. Wie wir im Dockerfile gesehen haben, ist dies hier die Version 3.11.0 von Matomo. Als Parameter wird im Anschluss der Ordner übergeben, in dem sich das Dockerfile befindet.

docker build -t matomo-php73-apache:3.11.0 ~/docker/matomo-php73-apache

Was jetzt kommt mutet an wie die Bildschirmausgabe im Kommandobunker von einem Kriegsfilm: Wilde verkettete Befehle, Zeilensprünge, „wirre“ Kommandos, die abgearbeitet werden…

Das alles ist beim ersten Mal sehr erschreckend, aber völlig normal. Hier laufen nun die „build“-Prozesse der Reihe nach durch. Hin und wieder erkennen wir sogar einen der Befehle aus dem Dockerfile.

Das Ganze dauert runde vier Minuten, wobei das stark vom verwendeten Server abhängt. Am Schluss schreibt uns Docker die erlösenden Zeilen:

Successfully built 892790e81b5f
Successfully tagged matomo-php73-apache:3.11.0

Glückwunsch! Das Image ist jetzt fertig!

Wir taggen das Image jetzt noch einmal und geben Docker quasi eine „Weiterleitung“ mit dem „:latest“ Tag, das wir mit der gerade gebauten Version 3.11.0 verknüpfen:

docker tag matomo-php73-apache:3.11.0 matomo-php73-apache:latest

Damit sind wir in der Lage, anschließend das Image im Container mit „:latest“ zu deklarieren. Sollte Version 3.12.0 kommen und wir ein neues Image gebaut haben, brauchen wir das nur noch mit „:latest“ zu taggen. Der Container wird beim nächsten Start dann das neue Image benutzen. Wir sparen uns quasi das ständige Ändern der Versionsnummern in unseren „docker-compose“-Dateien…

Im nächsten Kapitel werden wir die „docker-compose“-Datei für Matomo definieren und dort gleich unser frisch gebackenes Image verwenden!

Anzeige *

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Verwendung
von Cookies

Um unsere Webseite für Sie optimal zu gestalten und fortlaufend verbessern zu können, verwenden wir Cookies. Durch die weitere Nutzung der Webseite stimmen Sie der Verwendung von Cookies zu. Weitere Informationen zu Cookies erhalten Sie in unserer Datenschutzerklärung.

Scroll to Top