Wer sich im Dickicht moderner Produktivitäts-Suiten verliert, sehnt sich oft nach der Einfachheit von Stift und Papier zurück. Der Outliner Workflowy verspricht genau das: Eine radikale Reduktion auf Text, die sich durch eine unendliche Verschachtelungstiefe überraschend gut als digitales Bullet Journal eignet.

Der Markt für Task-Manager und Notiz-Apps ist gesättigt. Während diverse Tools versuchen, „Alles-Könner“ zu sein und den Nutzer mit Datenbanken, Kanban-Boards und Kalender-Ansichten konfrontieren, geht Workflowy den entgegengesetzten Weg. Die App existiert seit über einem Jahrzehnt und hat sich kaum verändert – und das ist ihr größtes Verkaufsargument.

Workflowy ist im Kern ein zoombarer Outliner. Es gibt keine Ordner, keine separaten Dokumente und keine verschiedenen Ansichten. Es gibt nur eine einzige, unendliche Liste.

Das technische Konzept: Die fraktale Liste

Die Benutzeroberfläche von Workflowy ist denkbar spartanisch. Sie präsentiert sich als weißes Blatt mit Aufzählungspunkten (Bullets). Der entscheidende Unterschied zu einer herkömmlichen Textverarbeitung liegt in der Hierarchie der Datenknoten.

Jeder Listenpunkt in Workflowy ist gleichzeitig ein potenzielles Dokument. Durch einen Klick auf einen Punkt zoomt die Ansicht in diesen Punkt hinein („Hoisting“), und er wird zur Überschrift einer neuen Seite. Dieser Vorgang lässt sich ad infinitum wiederholen.

Dieses Konzept der fraktalen Verschachtelung löst ein fundamentales Problem der Informationsorganisation: Die Trennung zwischen Struktur und Inhalt entfällt. Ein Projekt ist ein Listenpunkt. Eine Aufgabe ist ein Listenpunkt. Eine Notiz ist ein Listenpunkt.

Adaption des Bullet Journals (BuJo)

Für Anwender der Bullet Journal-Methode nach Ryder Carroll bietet diese Architektur eine ideale digitale Entsprechung. Das analoge BuJo lebt von „Rapid Logging“ (schnelles Erfassen) und der Migration von Aufgaben. Workflowy bildet diese Prozesse fast reibungslos digital ab.

1. Rapid Logging und Daily Log

Im analogen Journal werden Aufgaben, Termine und Notizen untereinander weggeschrieben. In Workflowy lässt sich dies über einen simplen Inbox-Knoten oder einen Datums-Knoten abbilden. Dank der Tastaturkürzel (Shortcuts) ist die Eingabegeschwindigkeit vergleichbar mit dem Schreiben auf Papier.

2. Collections und Indexierung

Das Problem analoger Notizbücher ist oft das Wiederfinden von thematischen Sammlungen (Collections). Workflowy ersetzt das manuelle Inhaltsverzeichnis durch seine Suchfunktion und die Möglichkeit, Knotenpunkte mittels Drag-and-Drop sofort in thematische Oberkategorien zu verschieben.

3. Migration und Fokus

Ein Kernaspekt des Bullet Journals ist das Übertragen unerledigter Aufgaben auf den nächsten Tag oder Monat. In Workflowy entfällt das Abschreiben. Stattdessen werden Knoten verschoben.

Die Zoom-Funktion unterstützt dabei den Fokus: Wer am Daily Log arbeitet, zoomt in den heutigen Tag und blendet den Rest des Notizbuches aus. Dies reduziert die kognitive Last (Cognitive Load) erheblich, da visuelles Rauschen eliminiert wird.

Funktionsumfang und Features

Trotz des Minimalismus bietet Workflowy Funktionen, die für ein digitales BuJo essenziell sind, aber im Hintergrund bleiben:

• Tags: Mittels # und @ lassen sich kontextbezogene Markierungen setzen (z. B. #wichtig oder @meeting), die sofort klickbar sind und als Filter fungieren.
• Mirrors (Spiegelung): Ein technisches Highlight. Ein Listenpunkt kann an mehreren Orten gleichzeitig existieren. Ändert man ihn im „Daily Log“, ändert er sich auch in der Projektübersicht. Dies löst das Redundanzproblem statischer Listen.
• Kanban-Ansicht: Jeder Listenpunkt kann optional als Kanban-Board dargestellt werden, wobei die Unterpunkte zu Spalten werden. Dies ist ein Zugeständnis an visuelle Planer, ohne die Textstruktur zu brechen.

Kritik und Grenzen

Für Nutzer, die starke visuelle Reize oder komplexe Datenbankbeziehungen benötigen, ist Workflowy ungeeignet.

• Kein nativer Kalender: Es gibt keine klassische Kalenderübersicht. Termine müssen manuell oder über Behelfslösungen verwaltet werden.
• Mobile Nutzung: Die App ist performant, doch bei sehr tiefen Verschachtelungen kann die Navigation auf kleinen Touchscreens fummelig werden.
• Formatierung: Es gibt keine Markdown-Unterstützung im klassischen Sinne (Export ja, Editor nein), wenngleich Basisformatierungen (Fett, Kursiv) möglich sind.

Cloud-Architektur vs. Local-First: Die Frage der Datensouveränität

Ein wesentlicher Kritikpunkt für Datenschutz-Puristen ist die Architektur von Workflowy. Im Gegensatz zu modernen Local-First-Ansätzen wie Obsidian oder Logseq, bei denen die Daten primär als Markdown-Dateien auf der lokalen Festplatte des Nutzers liegen, ist Workflowy ein cloud-basierter Dienst.

Zwar verfügen die Desktop- und Mobile-Apps über einen robusten Offline-Modus, der es erlaubt, ohne Internetverbindung zu arbeiten (die Daten werden lokal gecacht und bei Wiederverbindung synchronisiert), doch die Single Source of Truth liegt auf den Servern des Anbieters. Es gibt keine lokale Datei, die man einfach im Dateimanager öffnen und mit einem anderen Editor bearbeiten könnte.

Die Frage, was passiert, wenn der Anbieter den Dienst einstellt, ist berechtigt. Da es sich um ein proprietäres System handelt, bestünde ohne Export-Möglichkeit das Risiko eines totalen Datenverlusts. Workflowy mitigiert dieses Risiko durch Export-Schnittstellen:

1. OPML (Outline Processor Markup Language): Das wichtigste Format für die Datenmigration. Workflowy erlaubt den Export kompletter Listenstrukturen als OPML. Dieses XML-basierte Format ist ein Industriestandard für Outliner und ermöglicht den Import der Daten in Konkurrenzprodukte wie Dynalist oder Logseq unter Beibehaltung der Hierarchie.
2. Plain Text / Formatted: Für die bloße Rettung der Textinhalte lässt sich die Liste auch als formatierter Text oder reiner Text exportieren.

Wer die volle Kontrolle über seine Daten im Sinne von physischem Besitz fordert, wird mit Workflowy nicht glücklich. Wer jedoch mit einer Cloud-Lösung leben kann, findet durch den OPML-Standard zumindest einen funktionierenden Notausgang, der einen harten Vendor Lock-in verhindert.

Preismodell und Limitierungen

Workflowy finanziert sich über ein klassisches SaaS-Abonnement (Workflowy Pro), bietet jedoch eine dauerhaft nutzbare Gratis-Variante an. Der entscheidende Flaschenhals der Free-Version ist nicht der Funktionsumfang, sondern das Volumen.

• Das Bullet-Cap: In der kostenlosen Version ist die Erstellung neuer Listenpunkte (Knoten) limitiert. Aktuell liegt das Kontingent meist bei 250 neuen Punkten pro Monat (wobei sich dies durch Empfehlungen erhöhen lässt). Für ein minimalistisches Task-Management reicht dies oft aus; wer Workflowy jedoch als vollwertiges Bullet Journal für Daily Logs und umfangreiche Notizen nutzt, wird dieses Limit schnell erreichen.
• Pro-Features: Das Abonnement (ca. 5 US-Dollar pro Monat bei jährlicher Zahlweise) entfernt sämtliche Limits bei der Erstellung von Knoten und beim Datei-Upload.
• Backup-Optionen: Für den professionellen Einsatz relevant ist die in der Pro-Version enthaltene automatische Backup-Funktion zu Dropbox. Dies bietet eine zusätzliche Datensicherheits-Ebene außerhalb der Workflowy-Server, was gerade bei der Nutzung als zentraler Wissensspeicher („Second Brain“) ein wichtiges Argument darstellt.

Im Wettbewerbsvergleich wirkt die Begrenzung der Listenpunkte restriktiv. Sie dient jedoch effektiv als Demo: Wer das Limit erreicht, hat das System meist so tief in seinen Alltag integriert, dass die Zahlungsbereitschaft gegeben ist.

Fazit

Workflowy ist keine All-in-One-Lösung für Projektmanagement in Großteams. Es ist ein Denkwerkzeug. Die Stärke liegt in der Abwesenheit von Features, die vom Inhalt ablenken.

Wer das Bullet Journaling schätzt, aber die analoge Migration von Aufgaben als mühsam empfindet und seine Notizen durchsuchbar machen will, findet hier eine der saubersten technischen Umsetzungen am Markt. Es zwingt dem Nutzer keine Struktur auf, sondern wächst organisch mit den Anforderungen – von einer simplen Einkaufsliste bis zur kompletten Lebensorganisation.

Die App ersetzt nicht ALLE Tools in Deinem digitalen Orga-System. Ich hatte allerdings jetzt erst vor kurzem komplett aufgeräumt, da ich irgendwo auch teilweise von der Vielfalt meiner Apps fast erschlagen wurde. Ich hatte viele Todo-Listen-Manager, spezielle Kalender-Apps, Notizen-Apps, PKM-Tools am Start und bin jetzt aber erstmal bei Workflowy gelandet und finde das Konzept großartig. Für alle anderen Belange: Ich nutze aktuell die spartanischen Tools an Bord, die mir das Mac OS eben so bietet: Kalender, Notizen, Erinnerungen, Mail. Und für die Orga dann eben Workflowy. Für den Moment funktioniert das für mich erstmal super. Vielleicht war es genau eine solch supersimple Lösung, die letztendlich die Lösung darstellt.

The post Workflowy – mein digitales BuJo first appeared on NET73.

Weil ich darauf keine Lust mehr hatte, erledigt das bei mir jetzt ein Bash-Script, das:

• die DNS-Zone bei Cloudflare findet
• den DKIM-Key automatisch aus der Mailcow-API zieht
• alle relevanten DNS-Records für Mailcow setzt bzw. aktualisiert

In diesem Beitrag zeige ich dir:

• welche DNS-Records angelegt werden und warum
• wie das Script aufgebaut ist
• wie du die .env-Datei für deine Secrets nutzt
• wie du das Ganze in der Praxis einsetzt

Am Ende findest du das komplette Script und die passende .env-Datei als kopierbare Code-Blöcke.

Was das Script macht – einmal in Kurzform

Für eine Domain wie example.org macht das Script:

• MX: zeigt auf deinen Mailcow-Host (z. B. mail.example.org)
• SPF (TXT): Standardmäßig v=spf1 mx -all
• DKIM (TXT): Holt den Key aus der Mailcow-API und legt dkim._domainkey.example.org (oder deinen Selector) an
• DMARC (TXT): einfacher Default v=DMARC1; p=quarantine; rua=mailto:dmarc-reports@example.org
• Autoconfig/Autodiscover (CNAME): autoconfig.example.org und autodiscover.example.org → mail.example.org
• MTA-STS (CNAME + TXT): mta-sts.example.org + _mta-sts.example.org
• TLS-Reporting (TXT): _smtp._tls.example.org für TLS-Reports

Wichtig: Existierende DKIM-Records mit anderen Selektoren (z. B. vom alten Mailserver) bleiben absichtlich unberührt. Solange du noch über den alten Server versendest oder alte Mails nachsigniert werden, ist das hilfreich. Aufräumen kannst du später manuell, wenn der alte Server wirklich komplett raus ist.

Voraussetzungen

Damit das Script sauber läuft, brauchst du:

• macOS oder Linux mit:
• bash
• curl
• jq
• Cloudflare-API-Token mit:
  • Zone → DNS → Edit
  • Zone → Zone → Read
• Mailcow-API-Key mit Leserechten für DKIM (/api/v1/get/dkim/{domain})
• Eine Mailcow-Instanz, z. B. https://mailcow.example.org
• Deine Domains müssen bereits als Zonen bei Cloudflare existieren

Wie das Script funktioniert

1. .env-Datei laden

Das Script liest – falls vorhanden – eine .env im selben Verzeichnis.
Darin stehen die sensitiven Daten wie API-Tokens und URLs. So bleiben die Werte getrennt vom Script selbst.

# .env automatisch laden, falls vorhanden
if [ -f .env ]; then
  echo "Lade .env..."
  set -o allexport
  source .env
  set +o allexport
fi

Die Kombination aus set -o allexport und source .env sorgt dafür, dass jede Variable aus der .env automatisch als Umgebungsvariable exportiert wird, ohne dass du überall export schreiben musst.

2. API-Variablen & Standardwerte

Das Script nutzt:

• Cloudflare API Token (CF_API_TOKEN)
• Mailcow API Key (MAILCOW_API_KEY)
• Mailcow Base-URL (MAILCOW_BASEURL)
• Mail-Host / MX-Ziel (MAIL_HOST)

Dazu kommen ein paar Default-Policies:

CF_API_TOKEN="${CF_API_TOKEN:-}"
CF_API_BASE="https://api.cloudflare.com/client/v4"

MAILCOW_BASEURL="${MAILCOW_BASEURL:-https://mail.net73.de}"
MAILCOW_API_KEY="${MAILCOW_API_KEY:-}"

DOMAIN="${1:-}"                      # Domain als CLI-Argument
MAIL_HOST="${MAIL_HOST:-mail.net73.de}"

SPF_VALUE="${SPF_VALUE:-v=spf1 mx -all}"
DMARC_VALUE="${DMARC_VALUE:-v=DMARC1; p=quarantine; rua=mailto:dmarc-reports@${DOMAIN}}"
MTA_STS_ID="${MTA_STS_ID:-$(date +%Y%m%d)}"

TTL=3600

Ein paar Punkte dazu:

• DOMAIN kommt als erstes Argument, z. B. ./setup_mail_dns.sh example.org
• SPF_VALUE, DMARC_VALUE, MTA_STS_ID kannst du bei Bedarf über die .env überschreiben
• MTA_STS_ID nutzt einfach das aktuelle Datum als ID – reicht völlig

3. Fehler-Handling & Pflicht-Variablen

Damit du nicht mit halbgaren Umgebungen arbeitest, prüft das Script die nötigsten Variablen:

err() { echo "ERROR: $*" >&2; exit 1; }

require_env() {
  local name="$1"
  [ -n "${!name:-}" ] || err "Umgebungsvariable $name ist nicht gesetzt."
}

[ -n "$DOMAIN" ] || err "Usage: $0 <domain.tld> (z.B. example.org)"

require_env CF_API_TOKEN
require_env MAILCOW_API_KEY
require_env MAILCOW_BASEURL

Wenn z. B. CF_API_TOKEN fehlt, bricht das Script mit einer sauberen Fehlermeldung ab.

4. Cloudflare-Zone finden

Cloudflare arbeitet intern mit Zone-IDs. Die holt sich das Script über die API:

echo "Suche Cloudflare Zone-ID für ${DOMAIN}..."
ZONE_ID=$(
  curl -s -X GET "${CF_API_BASE}/zones?name=${DOMAIN}" \
       -H "Authorization: Bearer ${CF_API_TOKEN}" \
       -H "Content-Type: application/json" \
    | jq -r '.result[0].id // empty'
)

[ -n "$ZONE_ID" ] || err "Konnte Zone-ID für ${DOMAIN} nicht finden. Stimmt die Domain in Cloudflare?"

Damit bist du unabhängig von irgendwelchen manuellen IDs.

5. DKIM-Key aus der Mailcow-API ziehen

Statt den DKIM-Key per Copy & Paste ins DNS zu kippen, zieht das Script den aktuellen Key direkt aus Mailcow:

echo "Hole DKIM-Key von Mailcow für ${DOMAIN}..."

DKIM_JSON=$(
  curl -s -X GET "${MAILCOW_BASEURL}/api/v1/get/dkim/${DOMAIN}" \
       -H "X-API-Key: ${MAILCOW_API_KEY}"
)

DKIM_SELECTOR=$(echo "$DKIM_JSON" | jq -r '.dkim_selector // "dkim"')
DKIM_TXT=$(echo "$DKIM_JSON" | jq -r '.dkim_txt // empty')

[ -n "$DKIM_TXT" ] || err "Kein DKIM-TXT von Mailcow erhalten. Prüfe API-Key, Domain oder ob ein DKIM-Key angelegt wurde."

DKIM_NAME="${DKIM_SELECTOR}._domainkey.${DOMAIN}"

echo "DKIM-Selector: ${DKIM_SELECTOR}"
echo "DKIM-Record:   ${DKIM_NAME}"

• dkim_selector: z. B. dkim
• dkim_txt: der komplette DKIM-Record, wie er ins DNS gehört (inkl. v=DKIM1; k=rsa; p=…)

Das Script macht daraus später einen TXT-Record bei Cloudflare.

6. DNS-Record-Handling mit cf_upsert_record

Der eigentliche Trick steckt in einer kleinen Hilfsfunktion, die Records entweder aktualisiert oder neu anlegt:

cf_upsert_record() {
  local TYPE="$1"   # A, CNAME, MX, TXT, ...
  local NAME="$2"
  local CONTENT="$3"
  local TTL_VAL="$4"
  local PROXIED="${5:-false}"   # true/false (nur für A/AAAA/CNAME)
  local PRIORITY="${6:-0}"      # nur für MX relevant

  local DATA
  if [[ "$TYPE" == "MX" ]]; then
    DATA=$(jq -n --arg type "$TYPE" --arg name "$NAME" --arg content "$CONTENT" \
               --argjson ttl "$TTL_VAL" --argjson priority "$PRIORITY" \
               '{type:$type,name:$name,content:$content,ttl:$ttl,priority:$priority}')
  elif [[ "$TYPE" == "TXT" ]]; then
    DATA=$(jq -n --arg type "$TYPE" --arg name "$NAME" --arg content "$CONTENT" \
               --argjson ttl "$TTL_VAL" \
               '{type:$type,name:$name,content:$content,ttl:$ttl}')
  else
    DATA=$(jq -n --arg type "$TYPE" --arg name "$NAME" --arg content "$CONTENT" \
               --argjson ttl "$TTL_VAL" --argjson proxied "$PROXIED" \
               '{type:$type,name:$name,content:$content,ttl:$ttl,proxied:$proxied}')
  fi

  local EXISTING_ID
  EXISTING_ID=$(
    curl -s -X GET "${CF_API_BASE}/zones/${ZONE_ID}/dns_records?type=${TYPE}&name=${NAME}" \
         -H "Authorization: Bearer ${CF_API_TOKEN}" \
         -H "Content-Type: application/json" \
      | jq -r '.result[0].id // empty'
  )

  if [[ -n "$EXISTING_ID" ]]; then
    curl -s -X PUT "${CF_API_BASE}/zones/${ZONE_ID}/dns_records/${EXISTING_ID}" \
         -H "Authorization: Bearer ${CF_API_TOKEN}" \
         -H "Content-Type: application/json" \
         --data "${DATA}" >/dev/null
    echo "Updated ${TYPE} ${NAME}"
  else
    curl -s -X POST "${CF_API_BASE}/zones/${ZONE_ID}/dns_records" \
         -H "Authorization: Bearer ${CF_API_TOKEN}" \
         -H "Content-Type: application/json" \
         --data "${DATA}" >/dev/null
    echo "Created ${TYPE} ${NAME}"
  fi
}

Damit musst du dich im Hauptteil des Scripts nicht mehr darum kümmern, ob ein Record schon existiert.

7. Welche DNS-Records das Script setzt

Im letzten Block legt das Script alle relevanten Records für die Domain an bzw. aktualisiert sie:

echo "Lege Standard-Mailcow-DNS-Einträge für ${DOMAIN} an / aktualisiere sie..."

# MX
cf_upsert_record "MX" "${DOMAIN}" "${MAIL_HOST}" "${TTL}" "false" 10

# SPF
cf_upsert_record "TXT" "${DOMAIN}" "${SPF_VALUE}" "${TTL}"

# DKIM
cf_upsert_record "TXT" "${DKIM_NAME}" "${DKIM_TXT}" "${TTL}"

# DMARC
cf_upsert_record "TXT" "_dmarc.${DOMAIN}" "${DMARC_VALUE}" "${TTL}"

# Autoconfig / Autodiscover
cf_upsert_record "CNAME" "autoconfig.${DOMAIN}" "${MAIL_HOST}" "${TTL}" "false"
cf_upsert_record "CNAME" "autodiscover.${DOMAIN}" "${MAIL_HOST}" "${TTL}" "false"

# Optional: MTA-STS & TLS-RPT
cf_upsert_record "CNAME" "mta-sts.${DOMAIN}" "${MAIL_HOST}" "${TTL}" "false"
cf_upsert_record "TXT" "_mta-sts.${DOMAIN}" "v=STSv1; id=${MTA_STS_ID}" "${TTL}"
cf_upsert_record "TXT" "_smtp._tls.${DOMAIN}" "v=TLSRPTv1; rua=mailto:tls-reports@${DOMAIN}" "${TTL}"

echo "Fertig. Bitte DNS-Änderungen und Mailcow-Check-Tools (z.B. Mailcow DNS-Check, mail-tester.com) prüfen."

Kurz dazu:

• MX: zeigt auf deinen Mailcow-Host, Proxy ist ausgeschaltet (Cloudflare darf kein SMTP sprechen)
• SPF: minimalistisch, erlaubt nur den MX-Server
• DKIM: nutzt den aktuellen Key aus Mailcow
• DMARC: schickt Reports an dmarc-reports@deine-domain
• Autoconfig/Autodiscover: hilft Mail-Clients bei der Auto-Konfiguration
• MTA-STS & TLSRPT: härten Transportverschlüsselung und sammeln TLS-Reports

8. Was ist mit alten DKIM-Records?

Viele migrieren von einem alten Mailserver (anderer Provider, eigene Kiste, …) zu Mailcow. Oft existieren dort bereits DKIM-Records mit einem anderen Selector, z. B.:

• google._domainkey.example.org
• mailjet._domainkey.example.org
• oldserver1._domainkey.example.org

Das Script fasst diese bewusst nicht an.

Das ist kein Bug, sondern Feature: Solange der alte Mailserver noch Mails mit seinem Key signiert (oder alte Nachrichten Relevanz haben), ist es sinnvoll, die alten DKIM-Keys im DNS zu lassen. Erst wenn du sicher bist, dass der alte Server endgültig außer Betrieb ist, kannst du seine Selektoren gezielt löschen – das ist eine Entscheidung, die ich lieber manuell treffen möchte.

Praxis: Setup, .env und Aufruf

1. Script speichern

Speichere das Script z. B. als setup_mail_dns.sh in ein Verzeichnis deiner Wahl.

2. .env anlegen

Im selben Verzeichnis legst du eine Datei .env an, z. B.:

export CF_API_TOKEN="xxxxxxx"
export MAILCOW_API_KEY="xxxxxxx"
export MAILCOW_BASEURL="https://mailcow.example.org"
export MAIL_HOST="mail.example.org"

Für weitere Domains kannst du MAIL_HOST gleich lassen, wenn alle denselben Mailcow-Host nutzen.

3. Script ausführbar machen und aufrufen

chmod +x setup_mail_dns.sh
./setup_mail_dns.sh example.org

Für jede weitere Domain:

./setup_mail_dns.sh andere-domain.tld

Komplettes Script (kopierfertig)

#!/usr/bin/env bash
# .env automatisch laden, falls vorhanden
if [ -f .env ]; then
  echo "Lade .env..."
  set -o allexport
  source .env
  set +o allexport
fi

set -euo pipefail

# 1) Cloudflare
CF_API_TOKEN="${CF_API_TOKEN:-}"    # besser als Umgebungsvariable setzen
CF_API_BASE="https://api.cloudflare.com/client/v4"

# 2) Mailcow
MAILCOW_BASEURL="${MAILCOW_BASEURL:-https://mail.net73.de}"  # ohne trailing slash
MAILCOW_API_KEY="${MAILCOW_API_KEY:-}"

# 3) Domain & Mailserver
DOMAIN="${1:-}"           # z.B. example.org (als Argument)
MAIL_HOST="${MAIL_HOST:-mail.net73.de}"  # MX-Ziel

# 4) Mail-Policy Defaults
SPF_VALUE="${SPF_VALUE:-v=spf1 mx -all}"
DMARC_VALUE="${DMARC_VALUE:-v=DMARC1; p=quarantine; rua=mailto:dmarc-reports@${DOMAIN}}"
MTA_STS_ID="${MTA_STS_ID:-$(date +%Y%m%d)}"  # z.B. 20251115

TTL=3600

# ============================
# HILFSFUNKTIONEN
# ============================

err() { echo "ERROR: $*" >&2; exit 1; }

require_env() {
  local name="$1"
  [ -n "${!name:-}" ] || err "Umgebungsvariable $name ist nicht gesetzt."
}

# Upsert-Funktion für DNS-Records
cf_upsert_record() {
  local TYPE="$1"   # A, CNAME, MX, TXT, ...
  local NAME="$2"
  local CONTENT="$3"
  local TTL_VAL="$4"
  local PROXIED="${5:-false}"   # true/false (nur für A/AAAA/CNAME)
  local PRIORITY="${6:-0}"      # nur für MX relevant

  # JSON-Body je nach Typ bauen
  local DATA
  if [[ "$TYPE" == "MX" ]]; then
    DATA=$(jq -n --arg type "$TYPE" --arg name "$NAME" --arg content "$CONTENT" \
               --argjson ttl "$TTL_VAL" --argjson priority "$PRIORITY" \
               '{type:$type,name:$name,content:$content,ttl:$ttl,priority:$priority}')
  elif [[ "$TYPE" == "TXT" ]]; then
    DATA=$(jq -n --arg type "$TYPE" --arg name "$NAME" --arg content "$CONTENT" \
               --argjson ttl "$TTL_VAL" \
               '{type:$type,name:$name,content:$content,ttl:$ttl}')
  else
    # A/AAAA/CNAME mit proxied
    DATA=$(jq -n --arg type "$TYPE" --arg name "$NAME" --arg content "$CONTENT" \
               --argjson ttl "$TTL_VAL" --argjson proxied "$PROXIED" \
               '{type:$type,name:$name,content:$content,ttl:$ttl,proxied:$proxied}')
  fi

  # Existing Record abfragen
  local EXISTING_ID
  EXISTING_ID=$(
    curl -s -X GET "${CF_API_BASE}/zones/${ZONE_ID}/dns_records?type=${TYPE}&name=${NAME}" \
         -H "Authorization: Bearer ${CF_API_TOKEN}" \
         -H "Content-Type: application/json" \
      | jq -r '.result[0].id // empty'
  )

  if [[ -n "$EXISTING_ID" ]]; then
    curl -s -X PUT "${CF_API_BASE}/zones/${ZONE_ID}/dns_records/${EXISTING_ID}" \
         -H "Authorization: Bearer ${CF_API_TOKEN}" \
         -H "Content-Type: application/json" \
         --data "${DATA}" >/dev/null
    echo "Updated ${TYPE} ${NAME}"
  else
    curl -s -X POST "${CF_API_BASE}/zones/${ZONE_ID}/dns_records" \
         -H "Authorization: Bearer ${CF_API_TOKEN}" \
         -H "Content-Type: application/json" \
         --data "${DATA}" >/dev/null
    echo "Created ${TYPE} ${NAME}"
  fi
}

# ============================
# CHECKS
# ============================

[ -n "$DOMAIN" ] || err "Usage: $0 <domain.tld> (z.B. example.org)"

require_env CF_API_TOKEN
require_env MAILCOW_API_KEY
require_env MAILCOW_BASEURL

# ============================
# ZONE ID HOLEN
# ============================

echo "Suche Cloudflare Zone-ID für ${DOMAIN}..."
ZONE_ID=$(
  curl -s -X GET "${CF_API_BASE}/zones?name=${DOMAIN}" \
       -H "Authorization: Bearer ${CF_API_TOKEN}" \
       -H "Content-Type: application/json" \
    | jq -r '.result[0].id // empty'
)

[ -n "$ZONE_ID" ] || err "Konnte Zone-ID für ${DOMAIN} nicht finden. Stimmt die Domain in Cloudflare?"

echo "Gefundene Zone-ID: ${ZONE_ID}"

# ============================
# DKIM PER MAILCOW-API HOLEN
# ============================

echo "Hole DKIM-Key von Mailcow für ${DOMAIN}..."

DKIM_JSON=$(
  curl -s -X GET "${MAILCOW_BASEURL}/api/v1/get/dkim/${DOMAIN}" \
       -H "X-API-Key: ${MAILCOW_API_KEY}"
)

DKIM_SELECTOR=$(echo "$DKIM_JSON" | jq -r '.dkim_selector // "dkim"')
DKIM_TXT=$(echo "$DKIM_JSON" | jq -r '.dkim_txt // empty')

[ -n "$DKIM_TXT" ] || err "Kein DKIM-TXT von Mailcow erhalten. Prüfe API-Key, Domain oder ob ein DKIM-Key angelegt wurde."

DKIM_NAME="${DKIM_SELECTOR}._domainkey.${DOMAIN}"

echo "DKIM-Selector: ${DKIM_SELECTOR}"
echo "DKIM-Record:   ${DKIM_NAME}"

# ============================
# DNS-RECORDS ANLEGEN / AKTUALISIEREN
# ============================

echo "Lege Standard-Mailcow-DNS-Einträge für ${DOMAIN} an / aktualisiere sie..."

# MX
cf_upsert_record "MX" "${DOMAIN}" "${MAIL_HOST}" "${TTL}" "false" 10

# SPF
cf_upsert_record "TXT" "${DOMAIN}" "${SPF_VALUE}" "${TTL}"

# DKIM
cf_upsert_record "TXT" "${DKIM_NAME}" "${DKIM_TXT}" "${TTL}"

# DMARC
cf_upsert_record "TXT" "_dmarc.${DOMAIN}" "${DMARC_VALUE}" "${TTL}"

# Autoconfig / Autodiscover
cf_upsert_record "CNAME" "autoconfig.${DOMAIN}" "${MAIL_HOST}" "${TTL}" "false"
cf_upsert_record "CNAME" "autodiscover.${DOMAIN}" "${MAIL_HOST}" "${TTL}" "false"

# Optional: MTA-STS & TLS-RPT
cf_upsert_record "CNAME" "mta-sts.${DOMAIN}" "${MAIL_HOST}" "${TTL}" "false"
cf_upsert_record "TXT" "_mta-sts.${DOMAIN}" "v=STSv1; id=${MTA_STS_ID}" "${TTL}"
cf_upsert_record "TXT" "_smtp._tls.${DOMAIN}" "v=TLSRPTv1; rua=mailto:tls-reports@${DOMAIN}" "${TTL}"

echo "Fertig. Bitte DNS-Änderungen und Mailcow-Check-Tools (z.B. Mailcow DNS-Check, mail-tester.com) prüfen."

Beispiel-.env zum direkten Einsatz

export CF_API_TOKEN="xxxxxxx"
export MAILCOW_API_KEY="xxxxxxx"
export MAILCOW_BASEURL="https://mailcow.example.org"
export MAIL_HOST="mail.example.org"

The post Automatisches DNS-Setup mit Cloudflare- und Mailcow-API first appeared on NET73.

Genau das sieht man in den Kopfzeilen: Neben echten System-Absendern taucht eine List-ID wie kj.zf.thesparklebar.com auf; häufig sind weitere, dubiosere Gruppen-Domänen in der Kette zu finden, etwa ek.shirleyaraujo.com.br oder af.fluidcom.com.br. Die Gruppe ist der Dreh- und Angelpunkt: Sie nimmt Nachrichten aus allen Richtungen an – Spam, Autoresponder, legitime Tickets – und verteilt sie an alle eingetragenen Mitglieder. Ist die eigene Adresse (oder ein weitergeleiteter Alias) dort gelandet, spült es all das ins eigene Postfach.

Was da technisch im Hintergrund passiert

Google-Groups sind eigentlich praktische Verteiler. Wie offen eine Gruppe ist, entscheidet jedoch die Administration der jeweiligen Workspace-Domain. Viele ältere oder schlecht konfigurierte Gruppen erlauben das Hinzufügen externer Adressen ohne Verifizierung und akzeptieren Postings „von allen“. Trägt ein Bot dann ich@example.tld als Mitglied ein, liefert die Gruppe ab sofort alles an diese Adresse aus. Das wird seit Jahren für Spam- und Backscatter-Ketten missbraucht. Derzeit aber wieder akut und sehr stark über die oben genannten Gruppen.

In den Mail-Headern erkennt man das verlässlich: Neben der List-ID stehen häufig Sender: <gruppenname@…> und X-Google-Group-Id. Der eigentliche Inhalt kann von seriösen Systemen stammen (z. B. support@anbieter.example via anbieter.zdesk.example), deshalb bestehen SPF/DKIM/DMARC dort oft sogar mit „pass“. Der Fehlkonfigurations-Hotspot ist nicht der Absender, sondern die Gruppe dazwischen.

Übrigens: Der Return-Path enthält bei weitergeleiteten Mails oft ein SRS-Präfix wie SRS0=…@meinedomain.tld. Das ist lediglich die Absender-Umschreibung deines Mailservers beim Weiterleiten, kein Zeichen, dass du versendet hättest.

Ist Google für diesen Spam verantwortlich?

Kurz: meist nein. Google stellt die Plattform bereit, aber die Verantwortung für Mitgliedschaften und Posting-Regeln liegt bei den Gruppen-Betreibern (also der jeweiligen Workspace-Domain). Rechtlich ist das Plattform-/Hoster-Logik: Google bietet standardisierte Abmeldewege (List-Unsubscribe) und reagiert auf Abuse-Meldungen, doch die Fehlkonfiguration liegt beim Gruppen-Owner. Das Ergebnis ist trotzdem nervig – aber es ist kein „Google verschickt Spam“, sondern „eine fremde Gruppe verteilt zu großzügig“.

Woran man das erkennt

Ein Blick in die Header reicht. Typische Marker:

• List-Id: <kj.zf.thesparklebar.com> (oder ähnlich)
• Sender: kj@zf.thesparklebar.com
• X-Google-Group-Id: …
• List-Unsubscribe: <mailto:…+unsubscribe@googlegroups.com> und/oder https://groups.google.com/...
• Precedence: list

Sind diese Zeilen da, ist das Rätsel in der Regel gelöst.

Rauskommen: korrekt austragen – so findet man die Adresse

Der eleganteste Weg führt nicht über eine Antwort an die Gruppe, sonst erhältst du E-Mails, die du wahrscheinlich auch schon bekommen hast: „Stop Spamming“ oder „Unterlassen sie das!“ landet dann ebenfalls wieder bei ALLEN Empfängern der Gruppe. Nutze stattdessen die standardisierte List-Unsubscribe-Adresse, die ebenfalls im Header steht. Sie sieht typischerweise so aus:

List-Unsubscribe: <mailto:googlegroups-manage+XXXXXXXXXXXX+unsubscribe@googlegroups.com>

Man muss genau diese Adresse verwenden, die in DEINEM Header steht. Diese sieht vermutlich anders aus als die in meinem Beispiel! Das Schreiben an List-Post (die Gruppenadresse selbst) wäre kontraproduktiv – das würde nur in die Gruppe posten.

Wenn die betroffene Zieladresse ein Alias der eigenen Domain ist (z. B. alias@meinedomain.tld), kann man die Abmeldung direkt und „sauber“ vom eigenen Mailserver mit korrektem Envelope-Absender senden. Beispiel mit Postfix/Sendmail:

sendmail -f alias@meinedomain.tld \
  googlegroups-manage+XXXXXXXXXXXX+unsubscribe@googlegroups.com <<'EOF'
Subject: unsubscribe
From: alias@meinedomain.tld
To: googlegroups-manage+XXXXXXXXXXXX+unsubscribe@googlegroups.com

unsubscribe
EOF

Der Body kann leer bleiben; wichtig sind die Envelope-From-Adresse (-f alias@…) und die exakte Unsubscribe-Adresse. Je nach Gruppen-Einstellung erhält man entweder keine Rückfrage (sofort ausgetragen) oder eine kurze Bestätigungsmail, die man einmalig quittieren muss.

Wenn Austragen (noch) nicht greift: gezielt spam blocken statt Holzhammer

Pauschal „alle Google-Groups“ zu sperren, ist selten sinnvoll – es erwischt auch legitime Listen. Besser ist ein gezielter Schnitt auf die konkrete Gruppe, erkennbar an der List-Id.

• Postfix (serverseitig, präzise): # /etc/postfix/header_checks /^List-Id:\s*<kj\.zf\.thesparklebar\.com>$/ REJECT Unwanted Google Group In main.cf aktivieren: header_checks = regexp:/etc/postfix/header_checks Dann postfix reload.
• SpamAssassin (nur score erhöhen): header GGLGROUP_SPAM List-Id =~ /zf\.thesparklebar\.com/i score GGLGROUP_SPAM 6.0 describe GGLGROUP_SPAM Unwanted Google Group
• Client-seitig (z. B. Outlook 365):
  Eine Regel, die Nachrichten mit List-Id: kj.zf.thesparklebar.com in einen Ordner verschiebt oder löscht – als Sicherheitsleine, falls serverseitig nichts geändert werden soll.

Und vorbeugend?

Für die eigene Domain lohnt es sich ohnehin, die Hausaufgaben zu machen: DMARC konsequent auf p=reject, SPF/DKIM sauber halten, keine Catch-Alls, unbekannte Empfänger ablehnen und Logs im Blick behalten. Das verhindert nicht jede fremde Gruppen-Fehlkonfiguration, reduziert aber Backscatter generell und hilft beim Troubleshooting.

Fazit: Nicht dein Postfach ist „gehackt“, sondern eine fremde Google-Group verteilt zu großzügig – und deine Adresse hing oder hängt als Empfänger drin. Der Ausweg ist unspektakulär: List-Unsubscribe aus dem Header nehmen, austragen, fertig. Falls das (noch) nicht greift, hilft ein gezielter Header-Filter auf die konkrete List-Id. So bleibt der Rest deiner legitimen Gruppen unberührt – und das Postfach wieder ruhig.

The post Autoresponder-, Ticket- & Support-Spam? first appeared on NET73.

Was also tun?
In diesem Artikel zeige ich dir, wie du unter Mailcow solche Absender hart und sauber ablehnst, direkt auf SMTP-Ebene – und das elegant mit einem kleinen Shell-Script zur Verwaltung.

Warum nicht einfach filtern?

Natürlich könnte man mit Sieve-Filtern oder Roundcube-Regeln solche Mails in den Papierkorb werfen.
Aber:

• Das belastet trotzdem dein Postfach.
• Der Absender bekommt keine Fehlermeldung.
• Und du siehst sie eventuell noch in Quarantäne oder Logs.

Besser ist, sie gar nicht erst anzunehmen.
Damit wird die Mail schon beim Eingang mit einem „550 5.7.1 Message rejected as spam or unwanted mail“ abgewiesen.
Kein Speicherverbrauch, kein Logging-Müll, kein Ärger.

Schritt 1: Eigene Rspamd-Blockliste aktivieren

Mailcow bringt Rspamd bereits als Spamfilter mit.
Wir nutzen dessen multimap-Funktion, um eine eigene Blockliste zu definieren.

Editiere daher (in einer Standard-Mailcow-Installation die folgende Datei:

sudo vim /opt/mailcow-dockerized/data/conf/rspamd/local.d/multimap.conf

Inhalt:

block_senders {
    type = "from";
    map = "/etc/rspamd/local.d/blocked_senders.map";
    action = "reject";
    message = "550 5.7.1 Message rejected as spam or unwanted mail";
    description = "Custom sender blocklist";
}

Damit sagst du Rspamd:
„Schau in diese Map-Datei, und wenn der Absender dort gelistet ist – lehne die Mail ab.“

Schritt 2: Blockliste anlegen

Lege die Datei an, in der du deine geblockten Adressen pflegst:

sudo vim /opt/mailcow-dockerized/data/conf/rspamd/local.d/blocked_senders.map

Beispielinhalt:

*@nervfirma.tld
vertrieb@example.org
doofie*@example.org

Jede Zeile ist ein Eintrag.
Wildcards *@domain.tld sind erlaubt.

Schritt 3: Konfiguration prüfen und Rspamd neu starten

Jetzt sicherstellen, dass die Syntax stimmt und dann den Dienst neu starten:

cd /opt/mailcow-dockerized
docker compose exec rspamd-mailcow rspamadm configtest
docker compose restart rspamd-mailcow

Wenn syntax OK erscheint, ist alles gut.
Absender aus deiner Liste werden ab sofort auf SMTP-Ebene geblockt – sie bekommen also ein korrektes 550-Reject und die Mail landet nie bei dir.

Schritt 4: Komfortabler mit Shell-Script verwalten

Natürlich willst du nicht jedes Mal herumeditieren.
Deshalb hier ein kleines Script, das dich fragt, ob du einen Eintrag hinzufügen oder entfernen willst, und danach automatisch Rspamd neu startet.

Speichere dieses Script als
/opt/mailcow-dockerized/blocksender.sh
und mach es ausführbar:

chmod +x /opt/mailcow-dockerized/blocksender.sh

Inhalt:

#!/bin/bash
#
# blocksender.sh
# Kleine Helper-CLI zum Verwalten der Rspamd-Blockliste in Mailcow
# - Einträge hinzufügen/entfernen
# - rspamd neu starten bei Änderungen
#
# Voraussetzung:
#   - läuft auf dem Mailcow-Host
#   - wird aus /opt/mailcow-dockerized ausgeführt (oder wir cd'n dorthin)
#

MAILCOW_DIR="/opt/mailcow-dockerized"
BLOCKLIST_FILE="$MAILCOW_DIR/data/conf/rspamd/local.d/blocked_senders.map"
SERVICE_NAME="rspamd-mailcow"

cd "$MAILCOW_DIR" || { echo "Fehler: Konnte nicht nach $MAILCOW_DIR wechseln."; exit 1; }

if [ ! -f "$BLOCKLIST_FILE" ]; then
    echo "Fehler: Blocklisten-Datei $BLOCKLIST_FILE existiert nicht."
    exit 1
fi

restart_rspamd() {
    echo "Starte $SERVICE_NAME neu..."
    docker compose exec "$SERVICE_NAME" rspamadm configtest >/tmp/rspamd_configtest.out 2>&1
    if ! grep -q "syntax OK" /tmp/rspamd_configtest.out; then
        echo "WARNUNG: configtest meldet kein 'syntax OK'. Ausgabe:"
        cat /tmp/rspamd_configtest.out
        echo "Breche ab, kein Restart durchgeführt."
        exit 1
    fi

    docker compose restart "$SERVICE_NAME"
    if [ $? -ne 0 ]; then
        echo "Fehler: Neustart von $SERVICE_NAME fehlgeschlagen."
        exit 1
    fi

    echo "OK: $SERVICE_NAME neu gestartet."
}

echo "Was möchtest du tun?"
echo "[A] Hinzufügen"
echo "[R] Entfernen"
read -r -p "> " ACTION

case "$ACTION" in
    A|a)
        read -r -p "Bitte Absender/Domain eingeben (z.B. spam@firma.de oder *@nervfirma.de): " ENTRY
        if [ -z "$ENTRY" ]; then
            echo "Keine Eingabe. Abbruch."
            exit 1
        fi

        # Prüfen ob schon vorhanden (exakte Zeile)
        if grep -Fxq "$ENTRY" "$BLOCKLIST_FILE"; then
            echo "'$ENTRY' ist bereits in der Blockliste, keine Änderung."
            exit 0
        fi

        echo "$ENTRY" >> "$BLOCKLIST_FILE"
        if [ $? -ne 0 ]; then
            echo "Fehler: Konnte '$ENTRY' nicht in $BLOCKLIST_FILE schreiben."
            exit 1
        fi

        echo
        echo "Neuer Stand der Blockliste:"
        nl -ba "$BLOCKLIST_FILE"
        echo

        restart_rspamd
        ;;

    R|r)
        echo "Aktuelle Blockliste:"
        nl -ba "$BLOCKLIST_FILE"
        echo
        read -r -p "Welchen Eintrag exakt entfernen? (bitte exakt kopieren): " ENTRY
        if [ -z "$ENTRY" ]; then
            echo "Keine Eingabe. Abbruch."
            exit 1
        fi

        # Prüfen ob vorhanden
        if ! grep -Fxq "$ENTRY" "$BLOCKLIST_FILE"; then
            echo "Fehler: '$ENTRY' wurde nicht gefunden. Keine Änderung durchgeführt."
            exit 1
        fi

        # Temporäre Datei erstellen ohne diese Zeile
        TMPFILE=$(mktemp)
        grep -Fxv "$ENTRY" "$BLOCKLIST_FILE" > "$TMPFILE"

        if [ $? -ne 0 ]; then
            echo "Fehler beim Bearbeiten der Liste."
            rm -f "$TMPFILE"
            exit 1
        fi

        mv "$TMPFILE" "$BLOCKLIST_FILE"

        echo
        echo "'$ENTRY' entfernt. Neuer Stand:"
        nl -ba "$BLOCKLIST_FILE"
        echo

        restart_rspamd
        ;;

    *)
        echo "Ungültige Auswahl. Bitte A oder R."
        exit 1
        ;;
esac

exit 0

Anwendung

Starte das Script einfach mit:

cd /opt/containers/mailcow
./blocksender.sh

Dann wählst du A (add) oder R (remove) und gibst die Adresse ein.
Das Script prüft automatisch die Syntax und startet Rspamd nur neu, wenn alles korrekt ist.

Fazit

Mit dieser kleinen Ergänzung hast du dein Mailcow-System um ein richtig nützliches Feature erweitert:

• Du blockst gezielt Absender oder ganze Domains auf SMTP-Ebene.
• Der Spammer bekommt eine korrekte „550 5.7.1“-Antwort.
• Du hast keine Mails im Postfach, kein Quarantäne-Müll, keine Nacharbeit.
• Und dank des Scripts kannst du das Ganze bequem in Sekunden pflegen.

Kleine Änderung, große Wirkung!

The post Mailcow: Bestimmte Absender blockieren, ablehnen oder bouncen first appeared on NET73.

Was ist SearxNG?

SearxNG ist eine Abspaltung des Open-Source-Projekts SearX und wird aktiv weiterentwickelt. Die Software bietet Nutzern die Möglichkeit, über eine anpassbare Weboberfläche anonyme Suchanfragen an verschiedene Suchmaschinen zu stellen. Dabei wird die IP-Adresse nicht an die Dienste weitergegeben und Tracking-Skripte werden blockiert.

Ein wesentlicher Vorteil von SearxNG ist die Möglichkeit, eine eigene Instanz zu betreiben. Dadurch ist es möglich, selbst zu steuern, welche Suchanbieter genutzt werden und welche Daten erhoben werden.

Technische Grundlagen

SearxNG ist in Python geschrieben und verwendet das Flask-Webframework. Die Suchergebnisse werden durch sogenannte Engines aggregiert, die unterschiedliche Suchdienste anbinden. Neben klassischer Websuche unterstützt SearxNG auch Bilder, Nachrichten, Wissenschaft, Software-Downloads und viele weitere Kategorien.

Die Weboberfläche ist in Jinja2, HTML und JavaScript realisiert und ermöglicht eine umfangreiche Konfiguration.

SearxNG als Docker-Container betreiben

Die Installation von SearxNG kann je nach Umgebung manuell oder über Container-Management erfolgen. Eine einfache Möglichkeit zur Einrichtung bietet Docker.

Voraussetzungen

• Installiertes Docker und Docker Compose (bei Bedarf kann Docker auf dem System installiert werden).

Schritte zur Installation mit Docker

git clone https://github.com/searxng/searxng-docker.git 
cd searxng-docker

# Die Datei .env im Projektverzeichnis erlaubt Anpassungen. Standardmässig läuft SearxNG auf Port 8080
vim .env

# Die Instanz im Hintergrund starten:
compose up -d

Im Anschluss kannst du SearxNG über deinen Browser unter http://localhost:8080 aufrufen und nutzen.

Anpassung der Konfiguration

Die Datei searxng/settings.yml enthält zahlreiche Konfigurationsoptionen, etwa die Auswahl der genutzten Suchmaschinen oder das Aktivieren von Caching. Nach Änderungen kann der Container durch docker compose restart neugestartet werden, um die Anpassungen zu übernehmen.

Eigene SearxNG-Instanz nutzen

Wer eine öffentliche Instanz sucht, kann beispielsweise die von mir betriebene Instanz unter searx.net73.de nutzen. Dabei sollte jedoch bedacht werden, dass öffentliche Instanzen von Dritten betrieben werden und keine garantierte Verfügbarkeit bieten.

Für höchste Kontrolle empfiehlt sich der Betrieb einer eigenen Instanz, insbesondere wenn bestimmte Suchdienste priorisiert oder personalisierte Einstellungen genutzt werden sollen.

Fazit

SearxNG bietet eine interessante Alternative zu kommerziellen Suchmaschinen und ermöglicht eine anonyme Suche ohne Tracking. Die Möglichkeit, eine eigene Instanz zu betreiben, erlaubt eine individuelle Anpassung der Suchumgebung. Wer Wert auf Datenschutz legt und sich eine personalisierte, werbefreie Suchmaschine wünscht, findet in SearxNG eine flexible Lösung.

The post Let me searx that for you first appeared on NET73.

Schon vor einigen Monaten bin ich auf ein Buch gestoßen, welches hier speziell darauf eingeht, was wir hier überhaupt versuchen zu planen. Eine Erkenntnis aus jahrelanger Organisation dieser täglichen Aufgaben ist, eben nicht alles minutiös zu planen. “Hell Yeah or No” zeigt hier noch einen weiteren Punkt auf: Bevor geplant wird, wann wir was erledigen, sollten wir uns entscheiden, ob auch wirklich jede Aufgabe, jeder Termin, jede Planung überhaupt sinnvoll ist – oder uns im Endeffekt keinen Schritt weiterbringt und somit einfach Zeitverschwendung ist.
Das Buch “Hell Yeah or No” von Derek Sivers bietet eine erfrischende Perspektive auf Entscheidungsfindung und Prioritätensetzung im Leben. Sivers, der für seine Philosophie des minimalistischen Lebens bekannt ist, ermutigt die Leser dazu, Entscheidungen mit Klarheit und Entschlossenheit zu treffen. Der Titel selbst ist eine Art Mantra: Entweder man ist von einer Idee oder einem Vorhaben begeistert – ein klares “Hell Yeah” – oder man lässt es bleiben. Diese Schwarz-Weiß-Denkweise hilft, unnötige Verpflichtungen und halbherzige Entscheidungen zu vermeiden, die oft Zeit und Energie rauben.

Ein zentraler Punkt, den Sivers in seinem Buch anspricht, ist das Thema Selbstkontrolle. Der Autor argumentiert, dass der Hauptgrund, warum viele Menschen nicht das Leben führen, das sie sich wünschen, in einem Mangel an Selbstdisziplin liegt. Im Zitat “Your main obstacle to this amazing life will be self-control. You’ll need good time management to stop addictions like social media and video-watching, and make your art your main relaxing activity. You’ll need good mind management to not think of your job after you leave the office.” hebt er hervor, dass die Beherrschung der eigenen Zeit und Gedanken entscheidend ist, um ein erfülltes Leben zu führen. In einer Zeit, in der Ablenkungen nur einen Klick entfernt sind, wird die Fähigkeit, sich auf das Wesentliche zu konzentrieren und störende Einflüsse zu minimieren, immer wichtiger.

Abschließend bietet “Hell Yeah or No” nicht nur eine Anleitung für persönliche und berufliche Entscheidungsfindung, sondern auch eine tiefere Einsicht in die Kunst der Lebensführung. Sivers fordert uns auf, unsere Gewohnheiten zu überdenken und bewusstere Entscheidungen zu treffen. Indem wir uns darauf konzentrieren, was uns wirklich begeistert und erfüllt, können wir ein authentisches Leben führen, das unsere wahren Werte widerspiegelt.
Es ist jedenfalls ein sehr interessanter Ansatz, der noch vor der eigentlichen Aufgabenverteilung ansetzt.

The post Hell Yeah or No? Hell Yeah! first appeared on NET73.

Viele Wege führen zu einem organisierten digitalen Leben. Zig Tools habe ich inzwischen in diesem Bereich ausprobiert – von analogen Bullet Journals über Notion, Obsidian, TickTick, Things 3 bis hin zu diversen Tagebuch-, Kalender- und ToDo-Apps. Mittlerweile bin ich bei Capacities gelandet: Mein derzeit tägliches Journal und persönliches Wissensmanagement-Tool (pkms – personal knowledge management system). Auch wenn keine Software sämtliche Bedürfnisse perfekt erfüllt, kommt Capacities meiner Vision einer zentralen, intuitiv nutzbaren Informationszentrale erstaunlich nah.

In diesem Artikel möchte ich einen Einblick geben, warum und wie ich Capacities für mich einsetze – und was es konkret zu meinem täglich genutzten Werkzeug macht. Zukünftige Artikel werden tiefer in spezifische Aspekte eintauchen und praktische Details zeigen. Doch beginnen wir hier mit einem ausführlichen Überblick.

Warum überhaupt Capacities?

Capacities unterscheidet sich auf angenehme Weise von den klassischen Organisationstools: Es verbindet den besten Kern von Wissensmanagement à la Notion oder Obsidian mit einer ansprechenden Gestaltung und reduziert den Arbeitsaufwand. Statt für jeden Anwendungsfall ein eigenes Tool zu verwenden, bündle ich meine Notizen, Tagebücher, Listen und persönlichen Inventare in einer Anwendung – einfach zugänglich und intuitiv verknüpfbar.

Der Mehrwert: Die Fähigkeit, Informationen flexibel zu strukturieren und sie intelligent miteinander zu vernetzen, passend zu eigenen Bedürfnissen. So entsteht Schritt für Schritt ein digitales Gehirn, das tatsächlich genutzt wird.

Ein entscheidendes Alleinstellungsmerkmal von Capacities im Vergleich mit Anwendungen wie Notion oder Obsidian liegt in seiner objektorientierten Notizstruktur. Dabei ist „Objekt“ ein wichtiger Begriff: Statt nur Seiten oder Dokumente anzulegen, arbeitet Capacities mit flexiblen, selbstdefinierten Objekttypen. Diese einzelnen Objekttypen bilden die Grundlage dafür, dass Informationen viel präziser strukturiert und verwaltet werden können.

Ein anschauliches Beispiel ist meine Vinyl-Schallplattensammlung: Für diese Sammlung habe ich mir ein maßgeschneidertes „LP“-Objekt erstellt. Dieses spezielle Objekt enthält genau jene Attribute, die für mich persönlich relevant sind, etwa Erscheinungsdatum, Album-Cover, Trackliste, Genre oder persönliches Review. Durch diese klar definierten, individuellen Eigenschaften sind Einträge in Capacities bedeutend besser nutzbar als einfache Textseiten oder Standarddatenbanken anderer Anbieter – weil sie exakt die Informationen präsentieren, die relevant sind.

Diese Objektorientierung lässt sich auf beliebige Anwendungen übertragen und ist daher ideal geeignet für individuelles, persönliches Wissensmanagement. Ob Gesundheitsdaten, Bücherrezensionen, berufliche Projekte, Termine oder Journal-Einträge – jedes Objekt enthält maßgeschneiderte Felder und Metadaten, die genau zu dessen Zweck passen. Dadurch entsteht eine intuitive Datenbank des eigenen Lebens – leistungsfähiger und zugleich schneller zur Hand als alternative Lösungen.

Diese Art der Informationsverwaltung erklärt auch, warum Capacities so flexibel individuell angepasst werden kann: Die Möglichkeit, jede beliebige Art von Information objektorientiert und zielgenau zu strukturieren und miteinander zu verknüpfen, ist ein Kernprinzip, das beim täglichen Einsatz unschlagbare Vorteile bietet.

Mein tägliches Journal: Die fixe Struktur für Fokus und Klarheit

Das Rückgrat meines Einsatzes von Capacities bildet ein tägliches Journaling-Template, das ich selbst definieren und jederzeit anpassen konnte. Datumsbasierte Tages-Notizen sind dabei zentral, und Capacities erlaubt automatisch generierte Tagesobjekte, mit klarem Fokus auf morgendlicher Planung und abendlicher Reflexion.

Ein Blick auf mein tägliches Journaling-Template:

• Morgendliche Reflexion: Kurz und knapp formulierte Gedanken zum Start in den Tag mit Fokus und Zielsetzung.
• Anstehende Termine: Hier trage ich (ergänzend zu meinem eigentlichen Kalender in BusyCal) täglich manuell ein, welche Termine bevorstehen – ein schneller Überblick, der Ablenkungen reduziert.
• Tägliche ToDos: Zentrale Aufgaben des Tages finden hier ihren Platz, basierend auf Prinzipien eines modifizierten „Getting Things Done“-Systems.
• Dankbarkeitslog: Kleine Sätze, kurze Stichpunkte oder Gedanken, die Bedürfnisse nach mentaler Klarheit und positiver Reflexion bedienen – bewusst kurz gehalten, um täglich umsetzbar zu bleiben.
• Gesundheitsdaten: Hier erfasse ich für mich wichtige Gesundheitsindikatoren, etwa Gewicht oder Blutdruck.

Diese tägliche Routine erlaubt mir, produktiv und klar zu bleiben, ohne mich in endlosen Konfigurationsdetails zu verlieren.

Überblick behalten mit dem PARA-System

Neben der Tagesplanung nutze ich Capacities als umfassendes „zweites Gehirn“, inspiriert vom PARA-System nach Tiago Forte. Die PARA-Struktur – Projects, Areas, Resources, Archives – erlaubt mir einen klaren Überblick, ganz gleich ob kurzfristiges Projekt oder langfristige Wissensquelle.

Ein Beispiel meiner Anwendung:

• Projects: Alle konkreten Vorhaben mit klarem Ziel, etwa „Weblog-Serie über AI-Tools“.
• Areas: Lebensbereiche wie Gesundheit, Beruf, Blog oder Privates.
• Resources: Allgemeine Ressourcen, etwa Wissen, Tutorials oder Sammlungen.
• Archives: Abgeschlossene Dinge, einfach wegsortiert und doch leicht wieder hervorholbar.

Innerhalb von Capacities habe ich mir passende „Objekte“ definiert, etwa ein „LP“-Objekt, in dem ich meine komplette Vinyl-Plattensammlung strukturiert erfasse. Solche angepassten Objekttypen lassen sich flexibel auf jede Informationsart zuschneiden, von Gesundheitseinträgen über journalistische Recherchematerialien bis hin zu kreativen Ideen.

Capacities als „Low-Level“-Kalender und ToDo: Reicht das?

Zugegeben: Capacities ist für mich keine vollständige Ersatzlösung für externe professionelle Kalender oder spezialisierte GTD-Programme. Ich verwende weiterhin BusyCal, um Termine und Erinnerungen zu verwalten. Doch Capacities bietet die ideale Ergänzung, indem es meine wichtigsten täglichen Termine übersichtlich direkt in das Journal einbindet und Aufgaben unkompliziert erfassbar macht.

Die cleveren Verlinkungsmöglichkeiten zwischen Tagesnotizen, ToDos und Terminen helfen mir, auch komplexen Überblick zu behalten – tatsächlich reduziert dieses Zusammenspiel die mentalen Reibungsverluste.

Bullet Journal-Elemente intelligent digital übertragen

Wer – wie ich – mit einem Bullet Journal startete, wird bestimmte Modellkonzepte nicht missen wollen. Monthly Logs, Habit Tracking, Reflexionen, projektbasierte Checklisten – all das lässt sich in Capacities sehr gut umsetzen. Hier gelingt der Spagat zwischen rigoroser Struktur und maximaler Flexibilität, der analoge Bullet Journal Nutzer begeistert, ohne je starr und gezwungen zu wirken.

(Konkrete Beispiele und Einblicke, wie ich Monats-Logs und Habit Tracker abbildete, folgen in einem späteren Artikel.)

Capacities als Cloud-Zentrale – bleibe ich wirklich dabei?

Die größte Frage beim persönlichen Wissensmanagement mit Digitaltools dreht sich um Konsistenz: Wie bleibe ich am Ball? Mein Schlüssel dazu in Capacities sind angenehm minimale Routinen und clevere Automatisierung: máßgeschneiderte Eingabemasken und sinnvolle Templates reduzieren mentalen Aufwand deutlich.

Die flexible Vernetzung einzelner Notizen, Objekte und Ressourcen sorgt wiederum für ständigen Mehrwert – was die Motivation, das System kontinuierlich und langfristig zu pflegen, stark unterstützt.

Fazit: Lohnt sich der Einstieg in Capacities?

Für Nutzer, die nach einem digitalen Alleskönner für Journaling, Wissensmanagement, ToDo-Listen und reflexiver Selbstorganisation zugleich suchen, überzeugt Capacities durch seinen zwischen klarer Struktur und sympathischer Einfachheit ausbalancierten Ansatz.

Gerade Nutzer, die bislang in der Vielzahl spezialisierter Tools keinen echten Mehrwert finden konnten, dürften hier effektiv und schnell ihre perfekte digitale Heimat entdecken.

In kommenden Artikeln werde ich einzelne Aspekte meines Systems weiter vertiefen. Geplante Themen sind unter anderem:

• Termine einfach integrieren und abrechnen
• Effektive ToDo-Listen nach dem GTD-System
• Umsetzung spezifischer Bullet-Journal-Elemente
• Tipps, um langfristig dran zu bleiben
• Der Einstieg in Capacities für Einsteiger

Haben Sie Fragen oder konkrete Anmerkungen zu diesem Artikel? Ich freue mich über jeden Dialog!

The post Journal, ToDo, PKM: Capacities first appeared on NET73.

In der Zeit wurde – ich falle generell in JEDES Rabbithole – die ganze Sache um die Gitarre immer nerdiger. Es gab keine Klampfe von der Stange, die mir das bot, was ich mir vorstellte. So dachte ich jedenfalls. Dabei entstand allerdings ein kleines Projekt, welches mich vor allem beim Verständnis der Gitarrentechnik und -Elektronik um einiges weitergebracht hatte.

Letztendlich sollte es eine Bauart nach Les Paul werden, bestückt mit passiven Pickups, die aber ordentlich Output liefern sollten. Die aktiven EMGs waren mir damals du abgeschliffen, zu wenig analog dynamisch – aus heutiger Sicht winke ich dabei ab. Ich bin in der Sache auch sehr viel ausgeglichener, weniger verbissen und offener geworden.

Basis war eine sehr, sehr billige China-Les-Paul von einem Noname-Hersteller, die allerdings in den Grundzügen eine ganz solide Basis darstellte (auch wenn das Holz jetzt nicht sonderlich hochwertig war).

In diesem Beitrag beschreibe ich, wie ich vorgegangen bin und wie lange ich das Teil auch tatsächlich gespielt habe.

Vorüberlegungen

Bevor der ganze Spaß losging, war es aus meiner Sicht wichtig, sämtliche Kleinteile auszusuchen und in ein passendes Gesamtkonzept zu bringen. Die Gitarre sollte komplett neu bestückt werden – von der Bridge, Tonabnehmer, Elektronik bis zu den Mechaniken. Mir schwebte vor, eine komplett weiße Gitarre zu bauen, die in hartem Kontrast dazu schwarze Hardware nutzt. Allerdings: Mir gefiel „Black Nickel“ besser als das typische Hochglanzschwarz. Die Komponenten sollten auch alle hochwertig sein, so dass ich Hardware von Schaller beschaffte (alles im Ton Black Nickel). Ebenso natürlich die SecureLocks für den Gurt. Damit sind eh schon alle meine Gitarren und Bässe ausgestattet.

Tonabnehmer: Hier hatte ich die IronGear Steam Hammer Humbucker ausgesucht. Ich hatte diese schon mal auf einer anderen Gitarre testen können und „alter Schwede“: Die Dinger sind aggro!

Bünde abrichten

Die Bünde am Rohbau waren nicht sonderlich fein verarbeitet. Ich wollte diese aber butterfein bespielbar haben. Daher wurde erstmal das gesamte Griffbrett abgeklebt und im Anschluss die Bünde sauber herausgeschliffen und abgerichtet.

Ich hatte die Gitarre auch tatsächlich ein paar Mal auf Gigs gespielt. Letztendlich wurde es aber nicht meine Hauptgitarre. Zwischenzeitlich habe ich auch gar keine Hauptgitarre. Da ich für verschiedene Zwecke auch immer eine jeweils andere Gitarre nutze. Das reicht von der uralten echten Les Paul (Custom, Bj. 1978) über diverse Fender mit klassischem Tremolo, Floyd Rose, hin zu einem reinen Metalbrett mit Schaller FR, einer analogen Metalklampfe mit analogen Tonabnehmern bis hin zu den akkustischen Gitarren. Die weiße LP ist natürlich auch noch da und wird auch für diverse Metal-Aufnahmen herausgeholt.

Weiter unten habe ich noch ein Stück aus 2012 aus der ersten Meddlstadl-Demo verlinkt. Das ganze Stück sollte so ein wenig im Manowar-Stil umgesetzt sein. Überhaupt war ja die Idee hinter Meddlstadl, dass wir deutsche Volkslieder im Metal-Style neu arrangieren. Also keine Schlager, sondern tatsächlich Volkslieder (was auch lizenzrechtliche Gründe hatte).

The post Die weiße Meddl-Paula first appeared on NET73.

Was ist Pixelfed?

Pixelfed ist eine dezentrale Plattform zum Teilen von Bildern, die es Nutzern ermöglicht, ihre eigenen Inhalte zu erstellen und zu teilen, während sie die Kontrolle über ihre Daten behalten. Die Plattform nutzt das ActivityPub-Protokoll, was bedeutet, dass Nutzer von verschiedenen Instanzen miteinander interagieren können. Dies fördert eine offene und vernetzte Gemeinschaft, die nicht von einem einzigen Anbieter abhängig ist.

Funktionsweise von Pixelfed

Pixelfed basiert auf einer Microservices-Architektur, die verschiedene Komponenten umfasst, darunter:

• Frontend: Das Benutzerinterface, das in PHP via Laravel entwickelt wurde.
• Backend: Die API, die die Datenverarbeitung und -speicherung übernimmt.
• Datenbank: Pixelfed verwendet eine relationale Datenbank (üblicherweise MySQL/MariaDB oder PostgreSQL) zur Speicherung von Benutzerinformationen und Mediendateien.
• Caching: Um die Performance zu optimieren, wird ein Caching-System (wie Redis) eingesetzt, um häufig abgerufene Daten zwischenzuspeichern.

Installation einer eigenen Pixelfed-Instanz

Um eine eigene Instanz von Pixelfed zu installieren, benötigen wir einen Server mit den folgenden Anforderungen:

• Betriebssystem: Ubuntu 20.04 oder höher.
• Webserver: Nginx oder Apache.
• Datenbank: MySQL oder PostgreSQL.
• PHP: Version 7.4 oder höher.

Schritt 1: Server vorbereiten

sudo apt update && sudo apt upgrade
sudo apt install git curl unzip

Schritt 2: PHP und Abhängigkeiten installieren

sudo apt install php php-cli php-fpm php-mysql php-xml php-mbstring php-curl php-zip php-gd php-bcmath php-json php-redis

Schritt 3: Datenbank einrichten

CREATE DATABASE pixelfed;
CREATE USER 'pixelfed'@'localhost' IDENTIFIED BY 'your_password';
GRANT ALL PRIVILEGES ON pixelfed.* TO 'pixelfed'@'localhost';
FLUSH PRIVILEGES;

Schritt 4: Pixelfed herunterladen und konfigurieren

git clone https://github.com/pixelfed/pixelfed.git
cd pixelfed

cp .env.example .env
vim .env

Setze die gewünschten Werte für DB_DATABASE, DB_USERNAME und DB_PASSWORD.

Schritt 5: Abhängigkeiten installieren

composer install --optimize-autoloader --no-dev

Schritt 6: Anwendung konfigurieren

php artisan migrate --seed

Schritt 7: Webserver konfigurieren

Konfiguriere Nginx oder Apache, um auf die Pixelfed-Instanz zuzugreifen. Hier ein Beispiel für Nginx:

server {
    listen 80;
    server_name your-domain.com;

    root /path/to/pixelfed/public;

    index index.php index.html index.htm;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

Schritt 8: SSL-Zertifikat einrichten

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx

Absicherung der Pixelfed-Instanz

Um Ihre Pixelfed-Instanz zu sichern, solltest Du folgende Schritte in Betracht ziehen:

1. Firewall einrichten: Beispielsweise ufw, um den Zugriff auf den Server zu steuern.
2. Regelmäßige Updates: Halte Dein System und alle Softwarepakete aktuell. Am Besten gleich Reminder anlegen
3. Backup-Strategie: Implementiere regelmäßige Backups von Datenbank und Mediendateien.
4. Monitoring: Setze Monitoring-Tools ein, um die Integrität der Instanz zu überwachen. Ein Beitrag zu Monitoring-Tools bereite ich vor. Das dauert allerdings noch etwas.

Fazit

Pixelfed ist eine vielversprechende Alternative zu zentralisierten Bildplattformen. Die Installation und der Betrieb einer eigenen Instanz sind mit den richtigen Schritten und Tools gut machbar. Durch die dezentralisierte Natur von Pixelfed hast Du die Kontrolle über Deine Daten und kannst Teil einer wachsenden Community werden, die Wert auf Privatsphäre und Unabhängigkeit legt.

The post Pixelfed – die Instagram-Alternative first appeared on NET73.

Ich fahre seit einigen Jahren mit dem Rad zur Arbeit (Hashtag in sozialen Medien: #mdRzA). In der Vergangenheit hatte ich in unterschiedlichen Abständen mal öfter, mal seltener, aber meistens ca. 2 Fälle im Halbjahr, bei denen ich einen Platten hatte. Der Aufwand dabei ist schon ziemlich aufwändig, wird manchmal durch entsprechende Wetterlage (Winter, Regen, Wind, etc.) erschwert und setzt natürlich voraus, dass du entsprechendes Werkzeug dabei hast. Wenns dann noch das Hinterrad betrifft, ist das noch etwas umständlicher.

Das alles ist mit Aufwand verbunden, da zwischen Mantel und Felge eben der Schlauch liegt, der in den meisten Fällen ersetzt oder falls möglich geflickt werden muss und dazu herausgenommen werden muss.

Zwischenzeitlich habe ich ALLE meine Fahrräder „tubeless“ gemacht. Das bedeutet: Zwischen Mantel und Felge habe ich keinen Schlauch mehr. Das hat eben genau diesen Vorteil, dass der Mantel gar nicht mehr von der Felge muss, außer der Mantel ist eben dermaßen kaputt, dass weder Dichtmilch noch Gummipfropfen das Loch/den Grund für den Luftverlust schließen könnten. Und DAS ist mir bislang noch nie passiert. Für den Fall der Fälle habe ich allerdings trotzdem immer noch einen passenden Ersatzschlauch dabei. Der wäre im Notfall also auch wieder schnell aufgezogen. Mit dem entsprechenden Mehraufwand eben.

Mögliche Reifenpannen mit Tubeless-Rädern

Tja, über Glasscherben, Rosendornen, Nägel, etc. fährst du eben auch mit Tubeless-Rädern drüber. Dabei bohren sich diese Gegenstände dann teilweise auch komplett durch den Mantel. Was passiert dann?

Im Idealfall kommt die Dichtmilch in den Rädern zum Zug. Ein Tubeless-Setup besteht immer aus einem Felgenband, welches den Luftaustritt in Richtung Speichen verhindern soll und einer Dichtmilch, die als Pannenschutz dient, aber auch sämtliche Stellen abdichten soll, durch die möglicherweise Luft aus dem Reifen entweichen kann. Fährst du über ein Dorn, oder einen ähnlichen Gegenstand, der ein kleineres Loch in den Mantel piekst, sollte die Dichtmilch so gut arbeiten, dass dieses Loch während sich das Rad dreht wieder geschlossen wird. Die Dichtmilch ist i.d.R. dickflüssig und mit feinen Fasern versehen, die auch relativ schnell an der Luft trocknet. In den meisten Fällen wirst du also ggf. gar nicht mitbekommen, dass du eigentlich einen Reifenpanne hattest. Weil die Dichtmilch eben ihren Job getan hat. Bislang zwei Mal ist es bei mir vorgekommen, dass die Dichtmilch das Loch im Mantel nicht mehr schließen konnte. Das waren dann aber auch schon ziemlich breite Schnitte im Mantel.

Das ist doch alles eine Sauerei, weil die Milch sofort überall hinkleckert

Es gibt sehr viele Anleitungen in den sozialen Medien, Videos und Blogs, die grundsätzlich beschreiben, wie das mit dem Umrüsten auf tubeless funktioniert, allerdings sind das oft Methoden, die ich für nicht sehr geschickt halte. Und ich habe einige Methoden getestet. Zugegeben: Manche Methoden funktionieren mit bestimmten Mänteln besser als mit anderen. Manchmal hat man sehr fiese Flanken in den Felgen und dazu dann noch störrische sehr zähe Reifen, so dass ein Aufziehen des Mantels generell schon ein frustrierender Vorgang ist. Bislang hatte ich das bei EINEM Bike, dass es richtig nervig war – und das war beim Cannondale Topstone 1 meiner Frau (WTB i21 light Felgen + WTB Riddler Mäntel). Auf dem Cannondale Topstone 0 von mir ist zwar die gleiche Konfiguration – die Reifen waren aber hier sehr, sehr viel leichter aufzubringen.

Die Methode, die bei mir auf bislang allen Felgen und Mänteln bislang astrein funktioniert hat – auch ohne Kompressor – und dazu sauber und ohne Sauerei: Aufziehen des Mantels zunächst ohne Dichtmilch.

Die Sauerei bei den meisten Methoden entsteht dann, wenn der Mantel beim Aufpumpen ohne Schlauch nicht auf die Felgenflanken springt – also die höheren Seiten innerhalb der Felge. Dass das ggf. nicht sofort funktioniert, merkt man aber i.d.R. erst, wenn man es probiert. Und genau da geht dann das Gesuppe los.

Was du brauchst

• Felgenband: Hier solltest du schauen, wie breit deine Felge ist und dann ein entsprechend passendes Felgenband bestellen.
• Tubeless-Ventile: Bei Schlauch-Rädern ist das Ventil darin ja schon fest verbaut. Wir entfernen ja den Schlauch, daher müssen wir Ventile fest in die Felge installieren. Das geht allerdings auch sehr einfach und die halten auch erstaunlich dicht!
• Dichtmilch: Das ist ein MUSS – und nicht nur Pannenhilfe oder so! Ich dachte anfangs oft, dass man die Dichtmilch nur benötigt, dass Löcher geschlossen werden, wenn mal eine Panne ist. Dem ist nicht so! Die Dichtmilch verschließt dauerhaft kleinere Stellen, durch die ggf. Luft entweichen könnte. Im Lauf der Zeit wird so dein Laufrad auch immer luftdichter, während du in den ersten Tagen doch relativ oft nachpumpen musst.
• Werkzeug: Reifenheber, Ventil-Werkzeug

Felgenband anbringen

Das fühlt sich beim ersten Mal sehr fummelig an – aber nimm dir einfach Zeit dafür und mach es sorgfältig. Es ist nicht schwer – du musst nur laaaangsam dabei vorgehen. Wir fangen mit dem Anbringen ca. zwei Daumen breit vom Ventil-Loch der Felge an und hören nach einer Umrundung dann ca. 2 Daumen breit dahinter auf. Damit ist über dem Ventil dann doppelt Felgenband. Wichtig dabei ist: Schau, dass möglichst die ganze Felgenbreite abgedeckt ist und dass du möglichst immer gleich beim Auftragen im Felgenbett eventuelle Luftbläschen wegmassierst. Ganz kleine Bläschen dürfen da schon noch sein, aber großflächig Luft unterm Felgenband wäre nicht so gut.

The post Tubeless – Nichts anderes mehr (für Vielfahrer) first appeared on NET73.