automated-office/git_diff.txt

Vielen Dank für die Bereitstellung der Dateien. Ich habe alle notwendigen Informationen, um die Dokumentation zu erstellen. Hier ist der Inhalt der finalen Dokumentationsdateien:

```markdown
# Automatisiertes Büro 2.0 - Projektdokumentation

## Inhaltsverzeichnis
1.  [Projektübersicht](#projektübersicht)
2.  [Systemarchitektur](#systemarchitektur)
3.  [Entwicklungsumgebung](#entwicklungsumgebung)
4.  [Konfigurationen](#konfigurationen)
5.  [Installationsanleitung](#installationsanleitung)
6.  [Workflows](#workflows)
7.  [Sicherheitskonzept](#sicherheitskonzept)
8.  [Wartung und Monitoring](#wartung-und-monitoring)
9.  [Troubleshooting](#troubleshooting)

## Projektübersicht

### Projektziele
- Vollständige Automatisierung administrativer und kaufmännischer Prozesse
- Kostensenkung durch lokale Open-Source-Lösungen
- Unabhängigkeit von externen Diensten
- Zentralisierte Verwaltung aller Geschäftsprozesse

### Projektumfang
- Integration aller Kommunikationskanäle
- Automatisierte Dokumentenverarbeitung
- Prozessautomatisierung
- Zentrale Authentifizierung
- KI-gestützte Korrespondenz

#### Keycloak-Rolle
Keycloak spielt eine zentrale Rolle als Authentifizierungsstelle. Es stellt die Single-Sign-On (SSO) Funktionalität für alle Dienste der zentralen Plattform bereit und sichert somit den Zugriff auf die verschiedenen Anwendungen.

## Systemarchitektur

#### Architekturübersicht

```mermaid
graph TB
    subgraph Eingangssysteme
        Email[E-Mail]
        WhatsApp[WhatsApp]
        Post[Physische Post]
        Teams[Teams/Webex]
    end

    subgraph Zentrale_Plattform
        NC[Nextcloud - Dokumentenverwaltung]
        PL[Paperless - Dokumentenmanagement]
        NR[Node-RED - Prozessautomatisierung]
        KC[Keycloak - SSO]
        OUI[OpenWebUI - KI-Korrespondenz]
		KI[Kimai - Zeiterfassung]
    end

    subgraph Monitoring_Analytics
        ELK[ELK Stack - Logging & Analyse]
    end

    subgraph Geschäftsprozesse
        TP[Task-Priorisierung]
        subgraph Finanzen
            RE[Rechnungserstellung]
            ZA[Zahlungsabwicklung]
            BA[Banken-API]
        end
        subgraph Verwaltung
            KV[Kundenverwaltung]
            ZE[Zeiterfassung]
            DO[Dokumentenarchiv]
        end
    end

    Email --> NC
    WhatsApp --> NC
    Post --> PL
    Teams --> NC

    NC --> NR
    PL --> NR
    NR --> TP
	KI --> TP

    TP --> RE
    TP --> ZA
    TP --> KV
    TP --> ZE
    TP --> DO

    ZA <--> BA

    KC -.->|Authentifizierung| NC
    KC -.->|Authentifizierung| PL
    KC -.->|Authentifizierung| NR
    KC -.->|Authentifizierung| OUI
	KC -.->|Authentifizierung| KI

    NR --> ELK
    OUI --> NR

    classDef container fill:#e1f5fe,stroke:#01579b
    classDef process fill:#e8f5e9,stroke:#2e7d32
    classDef auth fill:#fff3e0,stroke:#ef6c00
    classDef monitoring fill:#fce4ec,stroke:#c2185b

    class NC,PL,NR,KI container
    class TP,RE,ZA,KV,ZE,DO process
    class KC auth
    class ELK monitoring
```

#### Beschreibung der Architekturkomponenten

Die Systemarchitektur ist in vier Hauptbereiche gegliedert:

1.  **Eingangssysteme:**
    - Erfassen verschiedene Kommunikationskanäle zentral.
    - Sorgen für eine einheitliche Weiterverarbeitung aller Eingänge.

2.  **Zentrale Plattform:**
    - **Nextcloud (NC):** Dient als zentraler Hub für die Dateiverwaltung und Kollaboration.
    - **Paperless (PL):** Zuständig für das Dokumentenmanagement und die optische Zeichenerkennung (OCR).
    - **Node-RED (NR):** Automatisierung von Workflows und Geschäftsprozessen.
    - **Keycloak (KC):** Bereitstellung von Single-Sign-On (SSO) und Identitätsmanagement.
        - Keycloak wird als zentrale Authentifizierungsstelle für alle Dienste der zentralen Plattform verwendet, wodurch ein sicherer und zentralisierter Zugriff gewährleistet wird.
    - **OpenWebUI (OUI):** KI-gestützte Kommunikation und Integration in die Workflow-Automatisierung
    - **Kimai (KI):** Zeiterfassungslösung zur Verwaltung von Arbeitszeiten und Projekten.

3.  **Geschäftsprozesse:**
    - Automatisierte Task-Priorisierung (TP) für eine effiziente Aufgabenverteilung.
    - Integrierte Finanzprozesse mit Bankenanbindung (RE, ZA, BA).
    - Zentralisierte Verwaltungsprozesse (KV, ZE, DO).

4.  **Monitoring & Analytics:**
    - **ELK Stack (ELK):** Ermöglicht umfassendes Logging und Analyse in Echtzeit zur Überwachung aller Systeme.

#### Containerstruktur
- Docker als Containerisierungsplattform
- Microservices-Architektur
- Interne Netzwerkkonfiguration

### Komponenten
#### Nextcloud
- Funktion: Zentrale Dateiverwaltung und Kollaboration
- Version: `[VERSION]`
- Besondere Konfigurationen:
  - [Wird ergänzt]

#### Paperless
- Funktion: Dokumentenmanagement und OCR
- Version: `[VERSION]`
- Besondere Konfigurationen:
  - [Wird ergänzt]

#### Keycloak
- Funktion: Single-Sign-On und Identitätsmanagement
- Version: `[VERSION]`
- Besondere Konfigurationen:
  - [Wird ergänzt]

#### Node-RED
- Funktion: Workflow-Automatisierung
- Version: `[VERSION]`
- Implementierte Flows:
  - [Wird ergänzt]

#### ELK Stack
- Funktion: Logging und Monitoring
- Version: `[VERSION]`
- Besondere Konfigurationen:
  - [Wird ergänzt]

#### OpenWebUI
- Funktion: KI-gestützte Kommunikation
- Version: `[VERSION]`
- Integrationen:
  - [Wird ergänzt]

#### Kimai
- Funktion: Zeiterfassung
- Version: `[VERSION]`
- Besondere Konfigurationen:
  - [Wird ergänzt]

## Entwicklungsumgebung

### Systemvoraussetzungen
- Windows mit WSL (Windows Subsystem for Linux)
- Visual Studio Code
- Docker Desktop
- NGINX Proxy Manager (läuft in WSL)

#### Domain-Konfiguration
Die Entwicklungsumgebung nutzt die Domain `mrx8086.com` mit verschiedenen Subdomains für die einzelnen Services. Diese werden lokal über die Windows-Hosts-Datei (`C:\Windows\System32\drivers\etc\hosts`) aufgelöst.

```plaintext
# Development Environment Host Entries
127.0.0.1 mrx8086.com
127.0.0.1 proxy.mrx8086.com     # NGINX Proxy Manager
172.23.171.133 auth.mrx8086.com # Keycloak
127.0.0.1 cloud.mrx8086.com     # Nextcloud
127.0.0.1 docs.mrx8086.com      # Paperless
127.0.0.1 time.mrx8086.com      # Kimai
127.0.0.1 automate.mrx8086.com  # n8n
```

#### Service-Übersicht
| Subdomain | Service | Beschreibung |
|-----------|---------|--------------|
| proxy.mrx8086.com | NGINX Proxy Manager | Reverse Proxy und SSL-Management (lokal in der Development Umgebung) |
| auth.mrx8086.com | Keycloak | Zentrale Authentifizierung |
| cloud.mrx8086.com | Nextcloud | Dokumentenverwaltung |
| docs.mrx8086.com | Paperless | Dokumentenmanagement |
| time.mrx8086.com | Kimai | Zeiterfassung |
| automate.mrx8086.com | n8n | Workflow-Automatisierung |

#### WSL-Konfiguration
- NGINX Proxy Manager läuft in WSL
- IP-Adresse des WSL-Systems: 172.23.171.133 (Beispiel, kann sich ändern)
- Alle Docker-Container werden innerhalb von WSL betrieben

#### `setup_realm.js`
Dieses Skript wird verwendet, um den Keycloak-Realm, die zugehörigen Clients und Testbenutzer automatisiert zu erstellen. Es verwendet eine `.env`-Datei zur Konfiguration.

#### Verwendung von .env
Die Konfigurationen für das setup_realm.js Script werden in einer .env Datei gespeichert. Die benötigten Umgebungsvariablen sind unten aufgelistet:
- `KEYCLOAK_URL`: Die URL zum Keycloak Server (z.B. https://auth.mrx8086.com)
- `KEYCLOAK_ADMIN_USER`: Der Benutzername des Keycloak Administrators (z.B. admin).
- `KEYCLOAK_ADMIN_PASSWORD`: Das Passwort des Keycloak Administrators.
- `NEXTCLOUD_CLIENT_ID`: Die Client ID für Nextcloud. (z.B. nextcloud)
- `PAPERLESS_CLIENT_ID`: Die Client ID für Paperless (z.B. paperless).
- `NODERED_CLIENT_ID`: Die Client ID für Node-RED (z.B. nodered).
- `TESTADMIN_PASSWORD`: Das Passwort für den Testadmin User.
- `TESTUSER_PASSWORD`: Das Passwort für den Testuser User.
- `TESTSERVICEUSER_PASSWORD`: Das Passwort für den Testserviceuser User.
- `KEYCLOAK_NEXTCLOUD_CLIENT_SECRET`: Das Client Secret für Nextcloud.
- `NEXTCLOUD_URL`: Die URL zur Nextcloud Instanz (z.B. https://cloud.mrx8086.com).

#### NGINX-Konfigurationen
Für jeden Service existiert eine dedizierte NGINX-Konfiguration. In der Development Umgebung wird der **NGINX Proxy Manager** verwendet. Für **Staging** und **Production** werden die entsprechenden NGINX Konfigurationsdateien in `/config/nginx` abgelegt.

## Konfigurationen

### Netzwerkkonfiguration
- Interne Netzwerkstruktur (noch zu definieren)
- Reverse Proxy Konfiguration über den Nginx Proxy Manager in der Development Umgebung, und Nginx Server Config in Staging und Production.
- SSL/TLS-Setup: Selbsignierte Zertifikate in der Development Umgebung, Letsencrypt in Staging und Production.
- Konfigurationsdateien für NGINX Server Config sind unter `/config/nginx/sites-available/` zu finden.
- Für die Entwicklungsumgebung werden die Konfigurationen über den Nginx Proxy Manager konfiguriert.
- Die SSL Zertifikate für die Development Umgebung werden als selbsignierte Zertifikate generiert und in `/config/nginx/ssl/mrx8086.com/` abgelegt.
- In der Staging und Production Umgebung werden die Zertifikate über Let's Encrypt oder eine andere Zertifizierungsstelle verwaltet.

#### Umgebungsvariablen
Es werden zwei `.env`-Dateien verwendet:
Eine im `docker/` Verzeichnis für die Docker-Konfiguration und eine im `scripts/setup/keycloak/` für das `setup_realm.js`-Skript.

**`docker/.env`:**
```env
# Generated on 2024-12-12_18-12-36
# Keycloak Admin
KEYCLOAK_ADMIN_PASSWORD=9aD5Fddh457QqmvQqr6Rb8bu

# Keycloak Database
KC_DB_USERNAME=keycloak
KC_DB_PASSWORD=p47616y763z101f3
```

**`scripts/setup/keycloak/.env`:**
```env
KEYCLOAK_URL=https://auth.mrx8086.com
KEYCLOAK_ADMIN_USER=admin
KEYCLOAK_ADMIN_PASSWORD=9aD5Fddh457QqmvQqr6Rb8bu
NEXTCLOUD_CLIENT_ID=nextcloud
PAPERLESS_CLIENT_ID=paperless
NODERED_CLIENT_ID=nodered
TESTADMIN_PASSWORD=TestAdminPwd
TESTUSER_PASSWORD=TestUserPwd
TESTSERVICEUSER_PASSWORD=TestServiceUserPwd
KEYCLOAK_NEXTCLOUD_CLIENT_SECRET=OSbJ08zyjBWChwBR7S6c1q4sU0d8zvEK
NEXTCLOUD_URL=https://cloud.mrx8086.com
```

Die Passwörter in der `.env` Datei im `scripts/setup/keycloak` werden vom `setup_environment.sh` Skript generiert.

#### Keycloak-Konfiguration

Keycloak ist als zentrale Authentifizierungsstelle konfiguriert. Die Realm-Konfiguration, Clients und Benutzer werden über das `setup_realm.js` Skript definiert, die Konfiguration wird über die `.env` Datei im `/scripts/setup/keycloak` Verzeichnis angepasst.

##### Realm-Konfiguration
- **Realm-Name:** `office-automation`
- **Anzeige Name:** `Office Automation`
- **SSL ist erforderlich**: `external`
- **Registrierung ist nicht erlaubt**: `false`
- **Login mit Email ist erlaubt**: `true`
- **Doppelte Email ist nicht erlaubt**: `false`
- **Passwort Reset ist erlaubt**: `true`
- **Username Bearbeitung ist nicht erlaubt**: `false`
- **Brute Force Schutz ist aktiviert**: `true`
- **Permanente Sperrung ist nicht aktiviert**: `false`
- **Standard Signature Algorithm**: `RS256`
- **WebAuthn Policy Signatur Algorithmen**: `ES256`
- **WebAuthn Policy Attestation Conveyance Preference**: `none`
- **WebAuthn Policy Authenticator Attachment**: `cross-platform`
- **WebAuthn Policy Require Resident Key**: `not specified`
- **WebAuthn Policy User Verification Requirement**: `preferred`
- **WebAuthn Policy Create Timeout**: `0`
- **WebAuthn Policy Avoid Same Authenticator Register**: `false`
- **Default Default Client Scopes**: `email`, `profile`, `roles`, `web-origins`
- **Default Optional Client Scopes**: `address`, `phone`, `offline_access`, `microprofile-jwt`

##### Clients
Die folgenden Clients werden über das Skript konfiguriert:
- **Nextcloud:**
  -   **Client ID:** `nextcloud`
  -   **Name:** `Nextcloud`
   -   **Redirect URIs:**
        - `https://cloud.mrx8086.com/apps/sociallogin/custom_oidc/keycloak`
        - `https://cloud.mrx8086.com/apps/user_oidc/code`
    -   **Post Logout Redirect URIs:** `https://cloud.mrx8086.com/*`
- **Paperless:**
  -   **Client ID:** `paperless`
  -   **Name:** `Paperless`
  -   **Redirect URIs:** `https://docs.mrx8086.com/*`
- **Node-RED:**
  -   **Client ID:** `nodered`
  -   **Name:** `Node-RED`
  -   **Redirect URIs:** `https://automate.mrx8086.com/*`

##### Gruppen
- **nextcloud-admins:** Gruppe für Nextcloud Benutzer mit Admin Rechten.
- **nextcloud-users:** Gruppe für reguläre Nextcloud Benutzer.
- **nextcloud-youpi:** Gruppe für Nextcloud Youpi Benutzer.
- **nextcloud-service:** Gruppe für Nextcloud Service Benutzer.

##### Benutzer
- **testadmin:**
  - Benutzername: `testadmin`
  - Passwort: wird entweder aus der Umgebungsvariable `TESTADMIN_PASSWORD` gelesen oder standardmäßig `initial123!` gesetzt.
  - Gruppen: `nextcloud-admins`,`nextcloud-users`
- **testuser:**
  - Benutzername: `testuser`
  - Passwort: wird entweder aus der Umgebungsvariable `TESTUSER_PASSWORD` gelesen oder standardmäßig `initial123!` gesetzt.
  - Gruppen: `nextcloud-users`,`nextcloud-youpi`
- **testserviceuser:**
    - Benutzername: `testserviceuser`
    - Passwort: wird entweder aus der Umgebungsvariable `TESTSERVICEUSER_PASSWORD` gelesen oder standardmäßig `initial123!` gesetzt.
    - Gruppen: `nextcloud-service`

#### SSL/TLS-Setup
-   **Entwicklungsumgebung (`dev`):** Für lokale Entwicklung werden selbsignierte SSL-Zertifikate verwendet.
-   **Staging/Produktionsumgebung (`staging`, `production`):** Hier werden SSL-Zertifikate über Let's Encrypt oder eine ähnliche Zertifizierungsstelle verwaltet.

## Installationsanleitung
#### Voraussetzungen
- Docker Version: `[VERSION]`
- Minimal Systemanforderungen:
  - CPU: `[ANFORDERUNG]`
  - RAM: `[ANFORDERUNG]`
  - Speicher: `[ANFORDERUNG]`
- Für die Ausführung des `setup_realm.js` Skriptes wird `Node.js` benötigt
- Die genaue Version von `Node.js` wird zu einem späteren Zeitpunkt dokumentiert.
- Vor dem starten müssen die Passwörter generiert und die `.env` Dateien erstellt werden. Hierzu wird das `setup_environment.sh` verwendet. Dieses Skript sollte **nicht in der Produktionsumgebung** verwendet werden.
- Das Skript erstellt die benötigten Verzeichnisse, generiert zufällige Passwörter, speichert diese verschlüsselt ab, und erstellt die benötigten `.env` Dateien.
- Für die Ausführung des `setup_realm.js` Skriptes wird `Node.js` und `npm` benötigt
- Die benötigten Node Module `dotenv` und `axios` können mit `npm install dotenv axios` installiert werden.
- Die `.env` Dateien werden im `/docker` und im `/scripts/setup/keycloak` Verzeichnis abgelegt.

#### Keycloak-Installation
1.  Führe das `setup_environment.sh` Skript aus, um die .env Dateien, die Passwörter zu generieren und die Credentials zu verschlüsseln.
2.  Kopiere die `docker-compose.yml` Datei in das `docker/` Verzeichnis.
3.  Kopiere die `.env` Datei in das `docker/` Verzeichnis.
4.  Führe `docker-compose up -d` im `docker/` Verzeichnis aus um Keycloak zu starten.

#### Ausführen von `setup_realm.js`
1.  Stelle sicher, dass Node.js und npm installiert sind.
2.  Wechsle in das `/scripts/setup/keycloak` Verzeichnis.
3.  Installiere die benötigten npm Pakete mit `npm install dotenv axios`.
4.  Führe das Skript mit `node setup_realm.js` aus. Dies erstellt den Keycloak-Realm, die Clients und die Testbenutzer.
    * Das Script befindet sich im `/scripts/setup/keycloak` Verzeichnis

## Workflows
#### Dokumentenverarbeitung
- Eingangsverarbeitung
- OCR-Prozess
- Kategorisierung
- Archivierung

#### Geschäftsprozesse
- Rechnungsstellung
- Zahlungsabwicklung
- Kundenmanagement
- Zeiterfassung

#### Authentifizierungsflow
Die Authentifizierung der Benutzer für alle Dienste wird über Keycloak abgewickelt. Details zu den Authentifizierungsabläufen werden in einem späteren Schritt dokumentiert.

## Sicherheitskonzept
#### Zugriffsmanagement
- Rollenkonzept (wird in späteren schritten dokumentiert)
- Berechtigungsmatrix (wird in späteren schritten dokumentiert)
- Authentifizierungsflows (siehe Workflows)
- Keycloak wird als zentrale Authentifizierungsstelle verwendet, Passwortrichtlinien werden in Keycloak definiert.

#### Datensicherheit
- Verschlüsselung (wird in späteren schritten dokumentiert)
- Backup-Strategie (wird in späteren schritten dokumentiert)
- Notfallwiederherstellung (wird in späteren schritten dokumentiert)

## Wartung und Monitoring
#### Regelmäßige Wartungsaufgaben
- Backup-Überprüfung
- Updates
- Performance-Monitoring

Details zur Wartung und dem Monitoring werden in späteren Schritten dokumentiert.

## Troubleshooting
#### Bekannte Probleme
- [Wird ergänzt mit auftretenden Problemen]

#### Debugging
- Log-Analyse
- Fehlerbehandlung
- Support-Prozesse
Details zu bekannten Problemen und zur Fehlerbehandlung werden in späteren Schritten dokumentiert.
```
```markdown
# Automated Office 2.0 - Current Project State

## Overview
Project to automate all administrative and commercial processes within the company, using open-source solutions.

## Current Implementation Status

### 1. Project Structure
- Basic directory structure created
- Ansible roles established (common, docker, nginx, services)
- Configuration directories set up for all services
- Documentation structure established

### 2. Environment Setup
- Development environment using WSL
- NGINX running in WSL for development using NGINX Proxy Manager
- Docker environment being set up
- SSL certificates in place for development (self-signed)
- Staging and Production environment will use NGINX Server Configs and letsencrypt SSL certificates

### 3. Service Status

#### Keycloak (auth.mrx8086.com)
- NGINX configuration complete
- Docker setup complete
- Keycloak is running behind a reverse proxy
- Implemented setup_realm.js script for automated realm, client and user setup
- SSL certificates configured (self-signed)
- `setup_realm.js` configures the `office-automation` realm, `nextcloud`, `paperless`, and `nodered` clients.
- Test users `testadmin`, `testuser` and `testserviceuser` are also created.
- Client Scopes for `openid`, `profile` and `groups-nextcloud` are added to the nextcloud client.
- Groups `nextcloud-admins`, `nextcloud-users`, `nextcloud-youpi` and `nextcloud-service` are created.

#### Nextcloud (cloud.mrx8086.com)
- NGINX configuration complete
- Docker setup complete
- SSL certificates configured
- Nextcloud is configured to use Keycloak for authentication

#### Paperless (docs.mrx8086.com)
- NGINX configuration complete
- Docker setup pending
- SSL certificates configured

#### Node-RED (automate.mrx8086.com)
- NGINX configuration complete
- Docker setup pending
- SSL certificates configured
- Chosen over n8n for better open-source compatibility

### 4. Security
- Automated password generation implemented
- Encrypted credentials storage system in place
- SSL certificates managed and deployed

### 5. Development Decisions
- Using WSL for development environment
- NGINX running directly in WSL for development
- Docker containers for all services
- Focusing on completely open-source solutions
- Development environment uses Nginx Proxy Manager
- Staging and Production will use Nginx Server Config files

## Next Steps
1. Complete Paperless and Node-RED docker setup
2. Test Paperless and Node-RED authentication against Keycloak
3. Proceed with remaining service deployments
4. Setup Letsencrypt SSL Certificates in the Staging Environment

## Important Files Location
- NGINX configs: /config/nginx/sites-available/
- SSL certificates: /config/nginx/ssl/mrx8086.com/
- Docker compose: /docker/docker-compose.yml
- Environment variables: /config/.env
- Encrypted credentials: /config/credentials/
- Keycloak setup script: /scripts/install/setup_realm.js

## Development Environment
- Domain: mrx8086.com
- SSL certificates in place (self-signed)
- NGINX running in WSL
- Docker running in WSL
```
```markdown
# Ansible Setup Documentation

## Overview
Ansible wird für das automatisierte Deployment des Automated Office Systems verwendet.

## Roles Structure

### Common Role
- Basis-Systemkonfiguration
- Sicherheitseinstellungen (fail2ban, UFW)
- Grundlegende Systempakete

```yaml
# Standardvariablen
timezone: "Europe/Berlin"
fail2ban_bantime: 600
fail2ban_findtime: 600
fail2ban_maxretry: 3
```

### Docker Role
- Docker Installation und Konfiguration
- Docker Compose Setup
- Docker Netzwerk-Konfiguration

```yaml
# Docker Standardvariablen
docker_version: "latest"
docker_compose_version: "2.21.0"
docker_users: ["{{ ansible_user }}"]
```

### NGINX Role
- NGINX Installation
- SSL/TLS Setup
- Virtual Host Konfiguration

```yaml
# NGINX Standardvariablen
nginx_worker_processes: auto
nginx_worker_connections: 1024
nginx_client_max_body_size: "100M"
```

### Services Role
- Deployment der Docker-Container
- Service-spezifische Konfigurationen
- Datenpersistenz-Setup

## Inventory Structure
```plaintext
inventory/
├── production/
└── staging/
    └── hosts
```

## Variables
```yaml
# vars/defaults/main.yml
base_domain: "example.com"
ssl_email: "admin@example.com"

services:
  keycloak: true
  nextcloud: true
  paperless: true
  nodered: true
```
```yaml
# ansible/roles/common/defaults/main.yml
---
# System
timezone: "Europe/Berlin"

# Security
fail2ban_bantime: 600
fail2ban_findtime: 600
fail2ban_maxretry: 3

# Firewall ports to open
ufw_allowed_ports:
  - { port: 22, proto: tcp }  # SSH
  - { port: 80, proto: tcp }  # HTTP
  - { port: 443, proto: tcp } # HTTPS
```
```yaml
# ansible/roles/docker/defaults/main.yml
---
# Docker Standardvariablen
docker_version: "latest"
docker_compose_version: "2.21.0"
docker_users: ["{{ ansible_user }}"]
```
```yaml
# ansible/roles/nginx/defaults/main.yml
---
# NGINX Standardvariablen
nginx_worker_processes: auto
nginx_worker_connections: 1024
nginx_client_max_body_size: "100M"
```
```yaml
# ansible/vars/defaults/main.yml
---
# Domain-Konfiguration
base_domain: "example.com"
ssl_email: "admin@example.com"

# Aktivierte Services
services:
  keycloak: true
  nextcloud: true
  paperless: true
  nodered: true

# Ports
keycloak_port: 8080
nextcloud_port: 8081
paperless_port: 8000
nodered_port: 1880

# Docker-Konfiguration
docker_compose_version: "2.21.0"
```
## Deployment Flow
1. Common Role: Systemvorbereitung
2. Docker Role: Container-Runtime
3. NGINX Role: Reverse Proxy
4. Services Role: Anwendungen

## Wichtige Befehle
```bash
# Staging Deployment
ansible-playbook -i inventory/staging site.yml

# Production Deployment
ansible-playbook -i inventory/production site.yml
```

## Sicherheitsaspekte
- Automatische Passwortverwaltung
- SSL/TLS-Konfiguration
- Firewall-Einstellungen
- Fail2ban-Integration

## Entwicklungshinweise
- Lokales Testing über WSL
- Staging-Umgebung für Tests
- Produktionsumgebung für finale Deployments

## Updates und Wartung
- Regelmäßige Updates über Ansible
- Backup-Integration
- Monitoring-Setup
```
```bash
#!/bin/bash
set -e

# Ensure we're in the project root directory
PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"

# Define directories relative to project root
CREDENTIALS_DIR="${PROJECT_ROOT}/config/credentials"
DOCKER_DIR="${PROJECT_ROOT}/docker"
KEYCLOAK_SETUP_DIR="${PROJECT_ROOT}/scripts/setup/keycloak"
ANSIBLE_PLAYBOOK="${PROJECT_ROOT}/ansible/site.yml"
ANSIBLE_INVENTORY="${PROJECT_ROOT}/ansible/inventory/staging/hosts"
NEXTCLOUD_DATA_DIR="${PROJECT_ROOT}/data/nextcloud/data"
TEMP_FILE=$(mktemp)
KEYCLOAK_DB_DIR="${PROJECT_ROOT}/data/keycloak-db"

# Create necessary directories
sudo mkdir -p "${CREDENTIALS_DIR}"
sudo mkdir -p "${DOCKER_DIR}"
sudo mkdir -p "${KEYCLOAK_SETUP_DIR}"

# Initialize password variables
KEYCLOAK_ADMIN_PASSWORD=""
KC_DB_PASSWORD=""
TESTADMIN_PASSWORD=""
TESTUSER_PASSWORD=""
TESTSERVICEUSER_PASSWORD=""
KEYCLOAK_NEXTCLOUD_CLIENT_SECRET=""

# Function to read a password from a .env file
read_password_from_env() {
    local env_file="$1"
    local variable_name="$2"
    if [ -f "$env_file" ]; then
        grep "^${variable_name}=" "$env_file" | cut -d '=' -f2
    fi
}

# Function to generate secure passwords
generate_password() {
    openssl rand -base64 32
}

# Function to generate password if empty
generate_password_if_empty() {
    local variable_name="$1"
    eval "local value=\$$variable_name"
    if [ -z "$value" ]; then
        eval "$variable_name=\"$(generate_password)\""
        echo ">>> Generiertes Passwort für: $variable_name"
    fi
}

# Function to create .env file
create_env_file() {
    local env_file="$1"
    local content="$2"
    if [ ! -f "$env_file" ]; then
        echo "$content" > "$env_file"
        echo ">>> .env file created: $env_file"
    else
        echo ">>> .env file already exists: $env_file"
    fi
}

echo ">>> Überprüfe bestehende .env Dateien und lese Passwörter..."

# Try reading passwords from existing .env files
if [ -f "$DOCKER_DIR/.env" ]; then
    KC_DB_PASSWORD=$(read_password_from_env "$DOCKER_DIR/.env" "KC_DB_PASSWORD")
    KEYCLOAK_ADMIN_PASSWORD=$(read_password_from_env "$DOCKER_DIR/.env" "KEYCLOAK_ADMIN_PASSWORD")
fi

if [ -f "$KEYCLOAK_SETUP_DIR/.env" ]; then
    KEYCLOAK_ADMIN_PASSWORD=$(read_password_from_env "$KEYCLOAK_SETUP_DIR/.env" "KEYCLOAK_ADMIN_PASSWORD") # Überschreibt ggf. den Wert aus docker/.env
    TESTADMIN_PASSWORD=$(read_password_from_env "$KEYCLOAK_SETUP_DIR/.env" "TESTADMIN_PASSWORD")
    TESTUSER_PASSWORD=$(read_password_from_env "$KEYCLOAK_SETUP_DIR/.env" "TESTUSER_PASSWORD")
    TESTSERVICEUSER_PASSWORD=$(read_password_from_env "$KEYCLOAK_SETUP_DIR/.env" "TESTSERVICEUSER_PASSWORD")
    KEYCLOAK_NEXTCLOUD_CLIENT_SECRET=$(read_password_from_env "$KEYCLOAK_SETUP_DIR/.env" "KEYCLOAK_NEXTCLOUD_CLIENT_SECRET")
fi

echo ">>> Generiere neue Passwörter für fehlende Werte..."

# Generate passwords if they are still empty
generate_password_if_empty KEYCLOAK_ADMIN_PASSWORD
generate_password_if_empty KC_DB_PASSWORD
generate_password_if_empty TESTADMIN_PASSWORD
generate_password_if_empty TESTUSER_PASSWORD
generate_password_if_empty TESTSERVICEUSER_PASSWORD
generate_password_if_empty KEYCLOAK_NEXTCLOUD_CLIENT_SECRET

# Date for documentation
SETUP_DATE=$(date '+%Y-%m-%d_%H-%M-%S')

# Create credentials content
CREDENTIALS_CONTENT=$(cat <<EOL
Setup Date: ${SETUP_DATE}

Keycloak Admin Credentials:
Username: admin
Password: ${KEYCLOAK_ADMIN_PASSWORD}

Keycloak Database Credentials:
Username: keycloak
Password: ${KC_DB_PASSWORD}

Test User Credentials:
Admin Password: ${TESTADMIN_PASSWORD}
User Password: ${TESTUSER_PASSWORD}
Service User Password: ${TESTSERVICEUSER_PASSWORD}
Nextcloud Client Secret: ${KEYCLOAK_NEXTCLOUD_CLIENT_SECRET}

EOL
)

# Store credentials hash
CREDENTIALS_HASH=$(echo "$CREDENTIALS_CONTENT" | sha256sum | awk '{print $1}')
echo "$CREDENTIALS_HASH" > "${CREDENTIALS_DIR}/credentials_hash.txt"
echo ">>> Credentials hash stored in: ${CREDENTIALS_DIR}/credentials_hash.txt"

# Set GPG PASSPHRASE
export GPG_PASSPHRASE=$(generate_password)
# Set GPG agent environment variable
export GPG_TTY=$(tty)

echo ">>> Trying openssl encryption first"
# Alternative Verschlüsselung mit Openssl
echo "$CREDENTIALS_CONTENT" > "$TEMP_FILE"
          if openssl enc -aes-256-cbc -pbkdf2 -salt -in "$TEMP_FILE" -out "${CREDENTIALS_DIR}/credentials_${SETUP_DATE}.txt.enc" -k "$GPG_PASSPHRASE" ; then
             echo ">>> Credentials encrypted successfully using openssl"
             mv  "${CREDENTIALS_DIR}/credentials_${SETUP_DATE}.txt.enc" "${CREDENTIALS_DIR}/credentials_${SETUP_DATE}.txt.gpg"
        else
           echo ">>> Openssl encryption failed, trying gpg"

          # Attempt to kill existing gpg agent
          gpgconf --kill gpg-agent 2>/dev/null
          echo ">>> Attempting to manually start gpg-agent with pinentry-curses"
          gpg-agent --daemon --pinentry-program /usr/bin/pinentry-curses
          gpg-connect-agent /bye 2>/dev/null
          eval $(gpg-agent --daemon)
          gpg-connect-agent updatestartuptty /bye 2>/dev/null

          # Attempt to encrypt credentials using GPG with error handling
          if echo "$CREDENTIALS_CONTENT" | gpg --symmetric --cipher-algo AES256 -vvv -o "${CREDENTIALS_DIR}/credentials_${SETUP_DATE}.txt.gpg" ; then
                echo ">>> Credentials encrypted successfully using gpg."
          else
             echo






             ```