nextcloud Private Cloud

Nextcloud ist eine Open‑Source‑Software für selbstgehostetes Cloud‑Storage (auch Private Cloud genannt).

Das bedeutet: Du installierst sie auf einem Server deiner Wahl (z. B. ein NAS, ein VPS, ein eigener PC) und hast damit einen privaten Cloud‑Speicher, den nur du bzw. die von dir autorisierten Personen nutzen können.

Kernfunktionen

• Hochladen/Herunterladen, Synchronisation (Desktop‑Client, Mobile‑Apps), Web‑Ansicht
• Echtzeit‑Bearbeitung mit Collabora / LibreOffice Online, Kommentare, Versionsverlauf
• iCal/Kontakte synchronisieren, gemeinsam nutzen
• Chat/Private Nachrichten (WebRTC‑Video), Gruppenchats
• Verschlüsselung (client‑side, server‑side), Zwei‑Faktor‑Authentifizierung, IP‑Whitelist, Rollen‑basierte Zugriffssteuerung
• Nutzer‑Management, Speicher‑Reporting, Backup/Restore

Quelle des Projekts: https://nextcloud.com

Voraussetzung

Docker muss installiert sein. Z.B. so:

curl -fsSL https://get.docker.com | sh

Vorgehen

Du kannst Dir auf einem Server Deiner Wahl ein Verzeichnis erstellen. Darin erstellst Du die benötigten Dateien "docker-compse.yml" und ".env":

docker-compose.yml

services:
  nextcloud:
    image: linuxserver/nextcloud:latest
    container_name: nextcloud-app
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Berlin
    volumes:
      - /path/to/nextcloud/config:/config
      - /path/to/nextcloud/data:/data
    restart: unless-stopped
    depends_on:
      - db
    networks:
      - nextcloud-net
      - proxy-net

  db:
    image: mariadb:11
    container_name: nextcloud-db
    volumes:
      - /path/to/nextcloud/db:/var/lib/mysql
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Berlin
      - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}
      - MYSQL_DATABASE=${MYSQL_DATABASE}
      - MYSQL_USER=${MYSQL_USER}
      - MYSQL_PASSWORD=${MYSQL_PASSWORD}
    networks:
      - nextcloud-net

  redis:
    image: redis:latest
    container_name: nextcloud-redis
    command: redis-server --requirepass ${REDIS_PASSWORD}
    environment:
      - REDIS_PASSWORD=${REDIS_PASSWORD}
    volumes:
      - /storage/nextcloud/redis:/data
    restart: unless-stopped
    networks:
      - nextcloud-net

networks:
  nextcloud-net:
    driver: bridge
  proxy-net:
    external: true

In der Datei ".env" werden dann die Inhalte der Umgebungsvariablen gespeichert. Außerdem muss das externe Netzwerk "proxy-net" existieren, in dem der reverse proxy hängt (-> siehe meine Seite zu nginx proxy manager).

.env

MYSQL_ROOT_PASSWORD=
MYSQL_DATABASE=nextcloud
MYSQL_USER=nextcloud
MYSQL_PASSWORD=
REDIS_PASSWORD=

Du vergibst jetzt noch die Passwörter für die die mariadb-Datenbank und den Redis-Cache.

Starten der Container

Jetzt kannst Du auf der Kommandozeile oder über einen docker-Manager wie Portainer die Container starten:

docker compose up -d

Reverse proxy

Im nginx proxy manager erstellt Du nun den Hostnamen der Seite, z.B. cloud.geekgully.de, und generierst das SSL-Zertifikat. Danach ist Kitchenowl z.B. unter https://cloud.geekgully.de erreichbar.

wallabag Leseliste

Wallabag ist eine Open‑Source‑Leseliste (Read‑It‑Later‑App) ähnlich Pocket, mit der du Artikel, Blog‑Posts und Webseiten später bequem lesen kannst – ohne die Originalseite zu verlassen.

Die Anwendung speichert die Inhalte in einer Datenbank, zeigt sie dann in einem klaren, leserfreundlichen Format an und bietet zahlreiche Funktionen wie Tagging, Kategorien, Volltextsuche, Synchronisation mit externen Geräten und mehr.

Quelle des Projekts: https://wallabag.org/

Warum Wallabag nutzen?

• Lade Inhalte einmal herunter und lese sie später ohne Internetverbindung.
• Keine Werbung, keine unnötigen UI‑Elemente – nur der Text (und optional Bilder).
• Ordne Artikel mit Tags oder in Kategorien ein; finde alles schnell wieder.
• Durchsuche den gesamten Inhalt deiner Wallabag‑Sammlung.
• Nutze die API/Apps, um Inhalte auf mehreren Geräten zu synchronisieren.
• SSL/TLS-Unterstützung, optional Authentifizierung via OAuth2 oder Basic Auth.

Voraussetzung

Docker muss installiert sein. Z.B. so:

curl -fsSL https://get.docker.com | sh

Vorgehen

Du kannst Dir auf einem Server Deiner Wahl ein Verzeichnis erstellen. Darin erstellst Du die benötigten Dateien "docker-compse.yml" und ".env":

docker-compose.yml

services:
  wallabag:
    image: wallabag/wallabag:latest
    container_name: wallabag-app
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}
      - SYMFONY__ENV__DATABASE_DRIVER=pdo_mysql
      - SYMFONY__ENV__DATABASE_HOST=db
      - SYMFONY__ENV__DATABASE_PORT=3306
      - SYMFONY__ENV__DATABASE_NAME=${SYMFONY__ENV__DATABASE_NAME}
      - SYMFONY__ENV__DATABASE_USER=${SYMFONY__ENV__DATABASE_USER}
      - SYMFONY__ENV__DATABASE_PASSWORD=${SYMFONY__ENV__DATABASE_PASSWORD}
      - SYMFONY__ENV__DATABASE_CHARSET=utf8mb4
      - SYMFONY__ENV__DATABASE_TABLE_PREFIX="wallabag_"
      - SYMFONY__ENV__MAILER_DSN=smtp://127.0.0.1
      - SYMFONY__ENV__FROM_EMAIL=${SYMFONY__ENV__FROM_EMAIL}
      - SYMFONY__ENV__DOMAIN_NAME=${SYMFONY__ENV__DOMAIN_NAME}
      - SYMFONY__ENV__SERVER_NAME=${SYMFONY__ENV__SERVER_NAME}
      - SYMFONY__ENV__SECRET=${SYMFONY__ENV__SECRET}
      - SYMFONY__ENV__LOCALE=de
      - SYMFONY__ENV__FOSUSER_REGISTRATION=false
      - SYMFONY__ENV__FOSUSER_CONFIRMATION=false
    # ports:
    #   - "80"
    volumes:
      - /path/to/wallabag/images:/var/www/wallabag/web/assets/images
    depends_on:
      - db
      - redis
    networks:
      - wallabag-net
      - proxy-net
  db:
    image: mariadb:11
    container_name: wallabag-db
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}
    volumes:
      - /path/to/wallabag/db:/var/lib/mysql
    healthcheck:
      test: ["CMD", "/usr/local/bin/healthcheck.sh", "--innodb_initialized"]
      interval: 20s
      timeout: 3s
    networks:
      - wallabag-net
  redis:
    image: redis:alpine
    container_name: wallabag-redis
    restart: unless-stopped    
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 20s
      timeout: 3s
    networks:
      - wallabag-net
networks:
  wallabag-net:
  proxy-net:
    external: true

In der Datei ".env" werden dann die Inhalte der Umgebungsvariablen gespeichert. Außerdem muss das externe Netzwerk "proxy-net" existieren, in dem der reverse proxy hängt (-> siehe meine Seite zu nginx proxy manager).

.env

MYSQL_ROOT_PASSWORD=
SYMFONY__ENV__DATABASE_NAME=wallabag
SYMFONY__ENV__DATABASE_USER=wallabag
SYMFONY__ENV__DATABASE_PASSWORD=
SYMFONY__ENV__FROM_EMAIL=Diese E-Mail-Adresse ist vor Spambots geschützt! Zur Anzeige muss JavaScript eingeschaltet sein.
SYMFONY__ENV__DOMAIN_NAME=https://wallabag.example.com
SYMFONY__ENV__SERVER_NAME="Mein Wallabag"
SYMFONY__ENV__SECRET=

Du vergibst jetzt noch die Passwörter für die die mariadb-Datenbank, füllst den E-Mail Absender, die URL Deines wallabag und den Namen Deines wallabag ein. Außerdem erstellst Du noch einen langen Secret Key.

Starten der Container

Jetzt kannst Du auf der Kommandozeile oder über einen docker-Manager wie Portainer die Container starten:

docker compose up -d

Reverse proxy

Im nginx proxy manager erstellt Du nun den Hostnamen der Seite, z.B. wallabag.geekgully.de, und generierst das SSL-Zertifikat. Danach ist Kitchenowl z.B. unter https://wallabag.geekgully.de erreichbar.

Kitchenowl Rezeptverwaltung

KitchenOwl ist eine Open‑Source‑Applikation, die als Selbst‑Hosting‑Lösung für Einkaufsliste, Rezepte, Essensplanung und Ausgabenverwaltung dient. Sie besteht aus einem Backend (Python/Flask) und einer Frontend‑App (Flutter bzw. Web‑UI).

Quelle des Projekts: https://github.com/TomBursch/kitchenowl

KitchenOwl ist ein voll funktionsfähiges, selbstgehostetes Küchensystem, das in einem einzigen Docker‑Container laufen kann. Du kannst es auf jedem Server, NAS oder Raspberry Pi betreiben und hast Zugriff auf Einkaufsliste, Rezepte, Essensplanung und Ausgabenübersicht – alles bequem über die Web‑UI oder mobile Flutter‑App.

Voraussetzung

Docker muss installiert sein. Z.B. so:

curl -fsSL https://get.docker.com | sh

Vorgehen

Du kannst Dir auf einem Server Deiner Wahl ein Verzeichnis erstellen. Darin erstellst Du die benötigten Dateien "docker-compse.yml" und ".env":

docker-compose.yml

services:
  db:
    image: postgres:17
    container_name: kitchenowl-db
    security_opt:
      - "no-new-privileges:true"
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - /path/to/kitchenowl/db:/var/lib/postgresql/data
    networks:
      - default
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}"]
      interval: 30s
      timeout: 60s
      retries: 5
      start_period: 80s
  back:
    image: tombursch/kitchenowl:latest
    container_name: kitchenowl-app
    restart: unless-stopped
    #ports:
    #  - "80:8080"
    networks:
      - default
      - proxy-net
    environment:
      JWT_SECRET_KEY: ${JWT_SECRET_KEY}
      DB_DRIVER: postgresql
      DB_HOST: db
      DB_NAME: ${POSTGRES_DB}
      DB_USER: ${POSTGRES_USER}
      DB_PASSWORD: ${POSTGRES_PASSWORD}
    depends_on:
      - db
    volumes:
      - /path/to/kitchenowl/files:/data
networks:
  default:
  proxy-net:
    external: true

In der Datei ".env" werden dann die Inhalte der Umgebungsvariablen gespeichert. Außerdem muss das externe Netzwerk "proxy-net" existieren, in dem der reverse proxy hängt (-> siehe meine Seite zu nginx proxy manager)

.env

POSTGRES_DB=kitchenowl
POSTGRES_USER=kitchenowl
POSTGRES_PASSWORD=
JWT_SECRET_KEY=

Du musst jetzt nur noch ein Passwort für die postgres-Datenbank und einen langen JWT Key einfügen. Diese kannst Du Dir beliebig ausdenken oder einen Passwort Genarator verwenden.

Starten der Container

Jetzt kannst Du auf der Kommandozeile oder über einen docker-Manager wie Portainer die Container starten:

docker compose up -d

Reverse proxy

Im nginx proxy manager erstellt Du nun den Hostnamen der Seite, z.B. kitchenowl.geekgully.de, und generierst das SSL-Zertifikat. Danach ist Kitchenowl z.B. unter https://kitchenowl.geekgully.de erreichbar.

nginx proxy manager

Nginx Proxy Manager ist ein Docker‑freundlicher Reverse‑Proxy‑Manager, der Nginx zu einer plug‑and‑play-Komponente macht. Er kümmert sich automatisch um Konfiguration, SSL‑Zertifikate und Updates – alles über eine benutzerfreundliche Web‑UI.

Vorteile

• Keine manuellen Nginx‑Konfigurationen – ideal für Anfänger oder schnelle Prototypen.
• Automatisches HTTPS – reduziert die Hürden bei der TLS‑Einrichtung.
• Docker‑native Lösung – alle Zustände werden in Docker‑Volumes gespeichert, was Backups und Migrationen vereinfacht.
• Große Community & Dokumentation – das Projekt hat eine wachsende Nutzerbasis und klare Setup‑Anleitungen (
  https://nginxproxymanager.com/).

Voraussetzung

Docker muss installiert sein. Z.B. so:

curl -fsSL https://get.docker.com | sh

Anleitung zur Installation

Externes Netzwerk erstellen

Zuerst erstellen wir ein externes Netzwerk, über das der enginx proxy manager dann mit den einzelnen Containern reden kann:

# docker network create proxy-net

docker-compose.yml

Nun die docker-compose-Datei, ganz einfach ohne Datenbank:

services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    restart: unless-stopped
    container_name: npm-app
    ports:
      # These ports are in format <host-port>:<container-port>
      - '80:80' # Public HTTP Port
      - '443:443' # Public HTTPS Port
      - '81:81' # Admin Web Port
      # Add any other Stream port you want to expose
      # - '21:21' # FTP
    # Uncomment the next line if you uncomment anything in the section
    environment:
      # Uncomment this if you want to change the location of
      # the SQLite DB file within the container
      # DB_SQLITE_FILE: "/data/database.sqlite"

      # Uncomment this if IPv6 is not enabled on your host
      DISABLE_IPV6: 'true'
    volumes:
      - /path/to/nginxproxymanager/data:/data
      - /path/to/nginxproxymanager/letsencrypt:/etc/letsencrypt
    networks:
      - proxy-net

networks:
  proxy-net:
    external: true