Zammad unter Ubuntu-Server

Oct 19, 2025 von
Schlagwörter: zammad ubuntu

Zammad ist ein Web-basiertes Open Source-Ticketsystem. Dieser Blog-Artikel zeigt Euch, wie man Zammad 6.5 unter Ubuntu Server 24.04 LTS installiert und mit Hilfe von nginx als Reverse-Proxy im Web verfügbar macht.

Prolog

Wir als STÜBER SYSTEMS haben seit vielen Jahren ein Ticketsystem betrieben, das auf einer Open Source-Variante von OTRS basiert. Die Implementation ist mittlerweile ziemlich in die Jahre gekommen.

Also haben wir uns umgeschaut, welche Optionen wir haben:

  • Option 1: Eine neuere Version von OTRS. Nun, das mit OTRS ist so eine Sache. Die Software ist schon lange kein richtiges Open Source-Projekt mehr. Vor einigen Jahren wurde die Entscheidung getroffen, sich auf ein Closed Source-Bezahlmodell zu konzentrieren. Es existiert weiterhin eine Open Source-Variante, diese ist jedoch lediglich eine ältere Variante der aktuellen Bezahlversion. Seit dem 1. Januar 2021 ist der offizielle Support für diese Community Edition vollständig eingestellt.

  • Option 2: Eine kommerzielle SaaS-Lösung. Keine wirkliche Option für uns, weil wir dort nicht die vollständige Kontrolle über alle Daten haben und weil wir auch keine Möglichkeit der Anpassung auf Quellcode-Ebene haben.

  • Option 3: Eine alternatives Open Source-System suchen und finden. Genau das haben wir getan.

Open Source-Ticketsysteme gibt es zahlreiche auf dem Markt, aber mir scheint, die allermeisten Systeme sind mehr auf Entwickler als auf Anwender zugeschnitten. Es sind also vor allem klassische Bug-Tracking-Systeme, die optisch ihre besten Tage meist schon hinter sich haben. Zammad ist da eine bemerkenswerte Ausnahme. Ein frisches, wohldurchdachtes Design, kontinuierliche Weiterentwicklung und Zammad kommt auch noch aus Berlin. Das passt.

Natürlich ist nicht alles perfekt und nicht alle unsere Workflows, die wir in unserem altem OTRS-System etabliert haben, konnten wir 1:1 übernehmen. Wir waren also gezwungen, alles noch einmal neu zu überdenken und ich finde, das hat sich gelohnt. Seit Oktober 2025 ist Zammad unser neues Ticketsystem.

Wer Lust bekommen hat auf eine eigene Instanz von Zammad, der ist herzlich eingeladen, weiterzulesen.

Einführung

Zammad ist ein Web-basiertes Open Source-Ticketsystem, lizenziert unter der AGPL. Der Name Zammad leitet sich aus dem Bayerischen ab und bedeutet soviel wie “zusammen”. Die erste Version 1.0 erschien 2016, mittlerweile ist das Projekt bei Version 6 angekommen. Zammad wird aktiv weiterentwickelt, es gibt auch eine kommerzielle SaaS-Variante.

zammad.org

zammad.org

Zammad läuft nur unter Linux. Die Betriebssysteme Windows und macOS werden nicht unterstützt. Einen Überblick über alle Funktionen von Zammad findest Du auf den Zammad-Webseiten.

Hardware-Voraussetzungen

Folgende Hardware-Spezifikation wird für Zammad 6.5 empfohlen:

Zum Einstieg:

  • 2 CPU Cores
  • 4 GB RAM (+4 GB beim Einsatz von Elasticsearch auf dem gleichen Server)

Für optimale Performanz bei bis zu 40 Agenten:

  • 6 CPU Cores
  • 6 GB RAM (+6 GB beim Einsatz von Elasticsearch auf dem gleichen Server)

Agenten sind jene Benutzer, die auf Anfragen in einem Ticketsystem reagieren. Elasticsearch ist eine Suchmaschine, mit der eine große Menge an Daten sehr effizient durchsucht werden kann.

Software-Voraussetzungen

Zammad 6.5 besitzt folgende Software-Abhängigkeiten:

  • Ruby 3.2.8 sowie das Package libimlib2 (Bibliothek zur Bildbearbeitung). Wird bei einer Package-Installation automatisch mitinstalliert.

  • Redis Community Edition (ein In-Memory Data Store)

  • Unterstütze Linux-Distributionen:

    • Ubuntu 22.04, 22.04 & 20.04
    • CentOS 8 & 9
    • Debian 11 & 12
    • OpenSUSE Leap 15.x

  • Unterstütze Datenbank-Management-Systeme:

    • PostgreSQL 10+

  • Unterstütze Reverse-Proxys:

    • Nginx 1.2+
    • Apache 2.2+

  • Optional (aber dringend empfohlen) Elasticsearch 7 oder 8

Installation

Voraussetzung:

Legen wir los. Wir werden jetzt folgendes machen:

  • Firewall installieren und konfigurieren
  • Nginx 1.2 und Certbot installieren
  • PostgreSQL 18 installieren
  • Elasticsearch 8 installieren
  • Redis 7.4 installieren
  • Zammad 6.5.2 installieren
  • Nginx als Reverse-Proxy für Zammad konfigurieren
  • Zammad starten und einrichten
  • Zammad mit Elasticsearch verbinden

Firewall

Wir nutzen Ufw als Firewall in Ubuntu. In der Regel ist Ufw bereits vorinstalliert. Falls nicht, erfolgt die Installation wie folgt:

$ sudo apt install ufw

Standardmäßig ist die Firewall deaktiviert. Wir konfigurieren sie (beispielhaft) für unsere Zwecke und aktivieren sie anschließend:

$ sudo ufw default deny incoming
$ sudo ufw allow ssh
$ sudo ufw allow http
$ sudo ufw allow https
$ sudo ufw enable

Den Status der Firewall kannst Du wie folgt abfragen:

$ sudo ufw status

Und so wird die Firewall (bei Bedarf) wieder deaktiviert:

$ sudo ufw disable

Nginx und Certbot

Nginx und Certbot benötigen wir, um Zammad später hinter einem Reverse-Proxy laufen zu lassen. Eine ausführliche Installationsanleitung für nginx findest Du in diesem Blog-Artikel. Hier die absolute Kurzfassung:

$ sudo apt remove nginx
$ sudo apt install curl gnupg2 ca-certificates lsb-release ubuntu-keyring
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" | sudo tee /etc/apt/sources.list.d/nginx.list
$ echo -e "Package: *\nPin: origin nginx.org\nPin: release o=nginx\nPin-Priority: 900\n" | sudo tee /etc/apt/preferences.d/99nginx
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
$ sudo apt update && sudo apt install nginx
$ sudo systemctl start nginx
$ sudo systemctl enable nginx
$ sudo apt install certbot python3-certbot-nginx

PostgreSQL

PostgreSQL ist das Datenbank-Management-System für Zammad. Eine ausführliche Installationsanleitung für PostgreSQL 18 findest Du in diesem Blog-Artikel. Hier die absolute Kurzfassung:

$ sudo sh -c 'echo "deb [signed-by=/usr/share/postgresql-common/pgdg/apt.postgresql.org.asc] https://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
$ sudo apt install curl ca-certificates
$ sudo install -d /usr/share/postgresql-common/pgdg
$ sudo curl -o /usr/share/postgresql-common/pgdg/apt.postgresql.org.asc --fail https://www.postgresql.org/media/keys/ACCC4CF8.asc
$ sudo apt update && sudo apt install postgresql-18 postgresql-client-18

Elasticsearch

Jetzt wollen wir Elasticsearch installieren. Elasticsearch ermöglicht die effiziente Suche über alle in Zammad gespeicherten Daten.

Als erstes müssen wir das apt-Repository von Elasticsearch in unserem Ubuntu-Server registrieren:

$ echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list

Anschließend wird der Elasticsearch-Signaturschlüssel importiert. Dieser wird für die Überprüfung des Installationspakets aus dem soeben registrierten apt-Repository benötigt.

$ wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg

Nun können wir die eigentliche Installation von Elasticsearch starten:

$ sudo apt-get update && sudo apt-get install elasticsearch

Ist die Installation fertig, musst Du unbedingt sorgfältig die Konsolenausgabe inspizieren. Dort findest Du folgende Ausgabe:

Authentication and authorization are enabled.
TLS for the transport and HTTP layers is enabled and configured.

The generated password for the elastic built-in superuser is : mein-elastic-kennwort

Notiere Dir bitte das Kennwort (das in der Realität natürlich anders aussieht, Beispiel: CbMBTNP1mzqG6w4B2yl*), wir benötigen es später für die Integration von Elasticsearch in Zammad.

$ sudo /bin/systemctl daemon-reload
$ sudo /bin/systemctl enable elasticsearch.service
$ sudo systemctl start elasticsearch.service

Das dauert jetzt ein Weilchen. Aber am Ende sollte der Elasticsearch-Dienst erfolgreich gestartet sein.

Wir können dies wie folgt überprüfen:

$ sudo systemctl status elasticsearch.service

Die Antwort sollte in etwa so aussehen:

elasticsearch.service - Elasticsearch
     Loaded: loaded (/usr/lib/systemd/system/elasticsearch.service; enabled; preset: enabled)
     Active: active (running) since Thu 2025-10-09 15:45:55 UTC; 32s ago
       Docs: https://www.elastic.co
   Main PID: 5868 (java)
      Tasks: 116 (limit: 28737)
     Memory: 12.4G (peak: 12.4G)
        CPU: 49.428s
     CGroup: /system.slice/elasticsearch.service
             ├─5868 /usr/share/elasticsearch/jdk/bin/java -Xms4m -Xmx64m -XX:+UseSerialGC -Dcli.name=server -Dcli.scr>
             ├─5932 /usr/share/elasticsearch/jdk/bin/java -Des.networkaddress.cache.ttl=60 -Des.networkaddress.cache.>
             └─5958 /usr/share/elasticsearch/modules/x-pack-ml/platform/linux-x86_64/bin/controller

Oct 09 15:45:40 ubuntu systemd[1]: Starting elasticsearch.service - Elasticsearch...
Oct 09 15:45:55 ubuntu systemd[1]: Started elasticsearch.service - Elasticsearch.

Möchtest Du die exakte Version Deiner Elasticsearch-Installation ermitteln, dann tippe folgendes ein:

$ sudo /usr/share/elasticsearch/bin/elasticsearch --version

Die Antwort sollte in etwa so aussehen:

Version: 8.19.5, Build: deb/d6dd0417f05cd69706f4f103c69bbb8b7688db9c/2025-10-03T16:35:50.165700789Z, JVM: 25

Und noch eine Sache: Elasticsearch empfiehlt den virtuellen Speicher zu erhöhen. Um dies dauerhaft zu tun, musst Du folgende Datei öffnen (oder neu erstellen):

$ sudo nano /etc/sysctl.d/10-map-count.conf

Sollte der Wert für vm.max_map_count kleiner als 262144 sein, ändere ihn wie folgt ab und speichere die Datei:

vm.max_map_count=262144

Mit folgendem Befehl wird die Änderung ohne Reboot aktiviert:

$ sudo sysctl -p

Kleiner Test, ob’s stimmt:

$ cat /proc/sys/vm/max_map_count

Redis

Jetzt installieren wir Redis. Redis ist ein In-Memory-Datenbank für das performante Speichern von nicht-persistenten Daten (z.B. einem Cache).

$ sudo apt install redis-server

Redis wird automatisch gestartet. Wir können dies wie folgt überprüfen:

$ sudo systemctl status redis

Die Antwort sollte in etwa so aussehen:

● redis-server.service - Advanced key-value store
     Loaded: loaded (/usr/lib/systemd/system/redis-server.service; enabled; preset: enabled)
     Active: active (running) since Thu 2025-10-09 15:50:16 UTC; 5s ago
       Docs: http://redis.io/documentation,
             man:redis-server(1)
   Main PID: 6381 (redis-server)
     Status: "Ready to accept connections"
      Tasks: 5 (limit: 28737)
     Memory: 3.7M (peak: 4.2M)
        CPU: 53ms
     CGroup: /system.slice/redis-server.service
             └─6381 "/usr/bin/redis-server 127.0.0.1:6379"

Oct 09 15:50:16 ubuntu systemd[1]: Starting redis-server.service - Advanced key-value store...
Oct 09 15:50:16 ubuntu systemd[1]: Started redis-server.service - Advanced key-value store.

Ist Redis auch für den Autostart beim Booten Deines Servers konfiguriert?

$ sudo systemctl is-enabled redis-server

Möchtest Du die exakte Version Deiner Redis-Installation ermitteln, dann tippe folgendes ein:

$ redis-server --version

Die Antwort sollte in etwa so aussehen:

Redis server v=7.0.15 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=3ec7bf4ec5bfafb8

Zammad

Jetzt endlich sind wir soweit. Es ist alles vorbereitet, wir können Zammad installieren. Wir beginnen mit der Registrierung des apt-Repository:

$ curl -fsSL https://dl.packager.io/srv/zammad/zammad/key | gpg --dearmor | sudo tee /etc/apt/keyrings/pkgr-zammad.gpg > /dev/null

Dann kommt der Import des Zammad-Signaturschlüssels:

$ echo "deb [signed-by=/etc/apt/keyrings/pkgr-zammad.gpg] https://dl.packager.io/srv/deb/zammad/zammad/stable/ubuntu 24.04 main"| sudo tee /etc/apt/sources.list.d/zammad.list > /dev/null

Und nun die eigentliche Installation (hier muss man ein wenig Geduld mitbringen):

$ sudo apt update && sudo apt install zammad

Zammad wird nicht automatisch gestartet, das holen wir nach:

$ sudo systemctl start zammad

Wir können dies wie folgt überprüfen:

$ sudo systemctl status zammad

Die Antwort sollte in etwa so aussehen:

● zammad.service
     Loaded: loaded (/etc/systemd/system/zammad.service; enabled; preset: enabled)
     Active: active (running) since Thu 2025-10-09 15:54:22 UTC; 18s ago
   Main PID: 10905 (sleep)
      Tasks: 1 (limit: 28737)
     Memory: 196.0K (peak: 340.0K)
        CPU: 1ms
     CGroup: /system.slice/zammad.service
             └─10905 /bin/sleep infinity

Oct 09 15:54:22 ubuntu systemd[1]: Started zammad.service.

Ist Zammad auch für den Autostart beim Booten Deines Servers konfiguriert?

$ sudo systemctl is-enabled zammad

Zammad im Web verfügbar machen

Zammad ist installiert, aber von außen via Webbrowser noch nicht zugreifbar. Dazu müssen wir nginx als Reverse-Proxy für Zammad konfigurieren:

Führe dazu folgenden Befehl aus:

$ sudo nano /etc/nginx/conf.d/zammad.conf

Kopiere folgenden Inhalt hinein (die Domäne zammad.beispiel.de ist natürlich nur ein Beispiel, Du musst Deine eigene Domäne hinterlegen) und speichere die Datei:

upstream zammad-railsserver {
  server 127.0.0.1:3000;
}

upstream zammad-websocket {
  server 127.0.0.1:6042;
}

server {

  listen 80;
  listen [::]:80;

  server_name zammad.beispiel.de;

  server_tokens off;

  root /opt/zammad/public;

  access_log /var/log/nginx/zammad.access.log;
  error_log  /var/log/nginx/zammad.error.log;

  client_max_body_size 50M;

  location ~ ^/(assets/|robots.txt|humans.txt|favicon.ico|apple-touch-icon.png) {
    expires max;
  }

  # legacy web socket server
  location /ws {
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "Upgrade";
    proxy_set_header Host $http_host;
    proxy_set_header CLIENT_IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_read_timeout 86400;
    proxy_pass http://zammad-websocket;
  }

  # action cable
  location /cable {
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "Upgrade";
    proxy_set_header Host $http_host;
    proxy_set_header CLIENT_IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_read_timeout 86400;
    proxy_pass http://zammad-railsserver;
  }

  location / {
    proxy_set_header Host $http_host;
    proxy_set_header CLIENT_IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;

    # Change this line in an SSO setup
    proxy_set_header X-Forwarded-User "";

    proxy_read_timeout 300;
    proxy_pass http://zammad-railsserver;

    gzip on;
    gzip_types text/plain text/xml text/css image/svg+xml application/javascript application/x-javascript application/json application/xml;
    gzip_proxied any;
  }
}

Speichere die Datei und starte nginx neu:

$ sudo systemctl restart nginx

Jetzt musst Du via Certbot dafür sorgen, dass zammad.beispiel.de auch unter https zu erreichen ist:

$ sudo certbot --nginx

Alle Details hierzu findest Du im bereits erwähnten Blog-Artikel HTTPS unter nginx/Ubuntu.

Zammad starten und einrichten

Jetzt kommt der große Augenblick: Wir starten Zammad zum ersten Mal, in dem wir https://zammad.beispiel.de in unseren Webbrowser eintippen. Folgendes Bild sollte erscheinen:

Zammad-Startbildschirm

Zammad-Startbildschirm

Klicke auf Ein neues System einrichten und arbeite Dich durch die Fragen. Du musst:

  • einen ersten Benutzer als Zammad-Administrator anlegen (wahrscheinlich Du selber)
  • den Namen Deiner Organisation vergeben (im Zweifelsfalle einfach einen Fantasienamen vergeben)
  • die Verbindung zu einem SMTP-Server für ausgehende E-Mails konfigurieren (kannst Du erstmal überspringen)
  • einen ersten E-Mail-Kanal für eingehende E-Mails konfigurieren (kannst Du auch erstmal überspringen)

Danach macht Zammad sich hübsch und Du bist als Administrator automatisch angemeldet.

Einige Operationen in Zammad (z.B. benutzerdefinierte Felder erstellen) benötigen einen Neustart des Systems. Für diesen Fall folgenden Befehl eingeben:

$ sudo systemctl restart zammad

Zammad mit Elasticsearch verbinden

Als letzte Heldentat verbinden wir Zammad mit Elasticsearch. Zunächst überprüfen wir, ob der Zugriff auf Elasticsearch funktioniert:

$ sudo curl --cacert /etc/elasticsearch/certs/http_ca.crt -u elastic:mein-elastic-kennwort https://localhost:9200

Das sollte in etwa folgende Ausgabe ergeben:

{
  "name" : "ubuntu",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "8hx5NPxHTBmYFQxZ6qez8w",
  "version" : {
    "number" : "8.19.5",
    "build_flavor" : "default",
    "build_type" : "deb",
    "build_hash" : "d6dd0417f05cd69706f4f103c69bbb8b7688db9c",
    "build_date" : "2025-10-03T16:35:50.165700789Z",
    "build_snapshot" : false,
    "lucene_version" : "9.12.2",
    "minimum_wire_compatibility_version" : "7.17.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "You Know, for Search"
}

Prima, klappt, jetzt zu Zammad. Rufe nacheinander folgende Befehle auf:

$ sudo zammad run rails r "Setting.set('es_url', 'https://localhost:9200')"
$ sudo zammad run rails r "Setting.set('es_user', 'elastic')"
$ sudo zammad run rails r "Setting.set('es_password', 'mein-elastic-kennwort')"

Und wenn wir schon einmal dabei sind, können wir nebenbei gleich noch ein paar weitere Optimierungen vornehmen:

$ sudo zammad run rails r "Setting.set('es_attachment_ignore', [ '.png', '.jpg', '.jpeg', '.mpeg', '.mpg', '.mov', '.bin', '.exe', '.box', '.mbox' ] )"
$ sudo zammad run rails r "Setting.set('es_attachment_max_size_in_mb', 50)"

In beiden Fällen geht es darum, die Suche nach Dateiinhalten zu optimieren, indem die Indizierung für sehr große Dateien bzw. Nicht-Text-Dateien eingeschränkt wird.

Jetzt müssen wir noch das generierte Elasticsearch-Zertifikat in Zammad registrieren. Rufe dazu folgenden Befehl auf:

$ sudo cat /etc/elasticsearch/certs/http_ca.crt

Kopiere den Inhalt in Deine Zwischenablage. Wechsle zu Zammad in Deinem Web-Browser und navigiere dort zu Admin Panel > Einstellungen > Sicherheit. Wähle SSL-Zertifikate und füge das soeben kopierte Elasticsearch-Zertifikat hinzu.

Elasticsearch-Zertifikat hinzufügen

Elasticsearch-Zertifikat hinzufügen

So, jetzt muss nur noch der Suchindex von Elasticsearch generiert werden:

$ sudo systemctl restart zammad
$ sudo zammad run rake zammad:searchindex:rebuild

Zammad aktualisieren

Eine Aktualisierung von Zammad muss stets wohlbedacht werden, vor allem wenn es sich um ein größeres Zammad-Update handelt (z.B. zwischen Major-Versionen). Daher solltest Du nicht blind ein sudo apt update && sudo apt upgrade durchführen.

Möchtest Du Ubuntu generell aktualisieren, empfiehlt es sich, vorsichtshalber Zammad davon auszunehmen und später separat durchzuführen:

$ sudo apt update
$ sudo apt-mark hold zammad
$ sudo apt upgrade
$ sudo apt-mark unhold zammad

In diesem Zusammenhang sei auch auf folgenden Forumsbeitrag hingewiesen.

Hat sich durch das Update von Zammad die Datenstruktur geändert (Hinweis dazu steht meist in den Release-Notes), muss ein Rebuild des Elasticsearch-Indexes durchgeführt werden:

$ sudo zammad run rake zammad:searchindex:rebuild

Geschafft!

Zammad läuft jetzt. Schau Dich um und versuche die Software nach Deinen Bedürfnissen anzupassen. Als Einstiegspunkt empfiehlt sich die Zammad-Dokumentation:

Wer Zammad nutzt, muss sich auch über das Thema Backup und Restore Gedanken machen. Zammad bietet von Hause aus zwei Shell-Skripte für Backup (zammad_backup.sh) und Restore (zammad_restore.sh) an, die Du für diese Zwecke nutzen und automatisieren kannst. Alle Infos dazu findest Du ebenfalls in der Dokumentation.

Troubleshooting

Hilfe, die Aktualisierung bricht ab!

Eine Aktualisierung via sudo apt update && sudo apt upgrade führt manchmal zu einem Ergebnis wie diesem hier:

Preparing to unpack .../38-cloud-init_25.2-0ubuntu1~24.04.1_all.deb ...
Unpacking cloud-init (25.2-0ubuntu1~24.04.1) over (25.1.4-0ubuntu0~24.04.1) ...
Errors were encountered while processing:
 /tmp/apt-dpkg-install-7NyUom/37-zammad_6.5.2-1760009902.29555156.noble_amd64.deb
needrestart is being skipped since dpkg has failed
E: Sub-process /usr/bin/dpkg returned an error code (1)

Das bedeutet, die Installation des Pakets wurde nicht bis zum Ende durchgeführt und ist vielleicht sogar in einem inkonsistenten Zustand.

Das Mittel dagegen lautet:

$ sudo apt -f install

Dabei passiert folgendes:

  • Apt sucht nach Paketen, deren Installation unterbrochen wurde oder bei denen Abhängigkeiten fehlen.
  • Wenn Pakete unvollständig sind, lädt apt die fehlenden Abhängigkeiten herunter und installiert sie, um das System zu reparieren.
  • Apt korrigiert fehlerhafte Paketinformationen und stellt sicher, dass der Paketmanager wieder in einem konsistenten Zustand ist.

Danach musst Du erneut

$ sudo apt upgrade

aufrufen und die Welt ist (hoffentlich) wieder in Ordnung.

Hilfe, ich kann mein 20 GB-Video nicht hochladen!

Das ist auch gut so, denn 20 GB sind zu viel für ein Ticketsystem. Es gibt aber zwei Stellschrauben bei Zammad, um die Maximalgröße der Anhänge zu beeinflussen:

  • Die Maximalgröße von E-Mail-Anhängen kann unter Verwaltung > E-Mail > Einstellungen > Maximale E-Mail-Größe korrigiert werden. Der größte zulässige Wert ist 150 MB.

  • Die Maximalgröße von Datei-Uploads kann indiekt über die Konfiguration von nginx beinflusst werden. In unserer Beispielkonfiguration weiter oben sind es 50 MB. Um diesen Wert zu erhöhen oder zu erniedrigen, gehe wie folgt vor:

    Öffne die Konfiguration:

    $ sudo nano /etc/nginx/conf.d/zammad.conf

    Ändere die folgende Zeile ab und speichere die Datei:

    client_max_body_size 50M;

    Starte nginx neu:

    $ sudo systemctl restart nginx
Das könnte dich auch interessieren:
  1. Duplicity unter Ubuntu-Server
Teile diesen Artikel