CI Test

.gitea/workflows/build-and-push.yaml

@@ -0,0 +1,67 @@
+name: Build and Push Docker Image
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - 'v*'
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Determine Image Tag
+        id: tag
+        run: |
+          # Prüfe ob es ein Git Tag ist
+          if [[ "${{ github.ref }}" == refs/tags/* ]]; then
+            # Verwende den Tag-Namen (z.B. v1.0.0)
+            TAG="${{ github.ref_name }}"
+          elif [[ "${{ github.ref_name }}" == "main" ]]; then
+            # Für main Branch: verwende 'latest'
+            TAG="latest"
+          else
+            # Für andere Branches: verwende Branch-Name + kurzen Commit-SHA
+            TAG="${{ github.ref_name }}-${{ github.sha }}"
+            TAG="${TAG:0:50}"  # Limit auf 50 Zeichen
+          fi
+          echo "IMAGE_TAG=${TAG}" >> $GITHUB_OUTPUT
+          echo "📦 Image Tag: ${TAG}"
+
+      - name: Create .env file from secrets and variables
+        run: |
+          cd docker
+          cat > .env << EOF
+          REGISTRY_URL=${{ vars.REGISTRY_URL }}
+          NAMESPACE=${{ vars.NAMESPACE }}
+          REPO_NAME=${{ vars.REPO_NAME }}
+          IMAGE_TAG=${{ steps.tag.outputs.IMAGE_TAG }}
+          CI_GITEA_USER=${{ secrets.CI_GITEA_USER }}
+          CI_GITEA_TOKEN=${{ secrets.CI_GITEA_TOKEN }}
+          EOF
+          echo "✅ .env file created with IMAGE_TAG=${{ steps.tag.outputs.IMAGE_TAG }}"
+
+      - name: Build Docker Image
+        run: |
+          cd docker
+          chmod +x build.sh
+          ./build.sh
+
+      - name: Push Docker Image to Registry
+        run: |
+          cd docker
+          chmod +x push.sh
+          ./push.sh
+
+      - name: Summary
+        run: |
+          echo "🎉 Build and Push completed successfully!"
+          echo "📦 Image: ${{ vars.REGISTRY_URL }}/${{ vars.NAMESPACE }}/${{ vars.REPO_NAME }}:${{ steps.tag.outputs.IMAGE_TAG }}"

.gitea/workflows/deploy.yml

@@ -1,103 +0,0 @@
-name: Build, Push & Deploy Angular App
-
-on:
-    push:
-        branches:
-            - main
-    tags:
-        - '*'
-
-env:
-    IMAGE_NAME: ${{ vars.IMAGE_NAME }}
-    GITEA_REGISTRY: ${{ vars.IMAGE_REGISTRY }}
-    DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }}
-    DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}
-    DEPLOY_USER: ${{ secrets.DEPLOY_USER }}
-    CI_REGISTRY_USER: ${{ secrets.CI_REGISTRY_USER }}
-    CI_REGISTRY_PASSWORD: ${{ secrets.CI_REGISTRY_PASSWORD }}
-    DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}
-    TAG: ${{ startsWith(github.ref, 'refs/tags/') && github.ref_name || 'latest' }}
-
-jobs:
-#    build:
-#        name: 🏗️ Build Docker Image
-#        runs-on: ubuntu-latest
-#        steps:
-#            - uses: actions/checkout@v3
-#
-#            - name: Install Docker client
-#              run: |
-#                  sudo apt-get update
-#                  sudo apt-get install -y docker.io bash
-#
-#            - name: Build Docker Image
-#              run: |
-#                  chmod +x ./docker/build.sh
-#                  cd docker
-#                  ./build.sh "${IMAGE_NAME}" "${TAG}"
-
-    push:
-        name: ⬆️ Build and Push Image to Gitea Registry
-        runs-on: ubuntu-latest
-#        needs: build
-        steps:
-            - uses: actions/checkout@v3
-
-            - name: Build and Push Image
-              env:
-                  GITEA_REGISTRY: ${{ vars.IMAGE_REGISTRY }}
-                  GITEA_USER: ${{ secrets.CI_REGISTRY_USER }}
-                  GITEA_TOKEN: ${{ secrets.CI_REGISTRY_PASSWORD }}
-                  IMAGE_NAME: ${{ vars.IMAGE_NAME }}
-                  TAG: ${{ startsWith(github.ref, 'refs/tags/') && github.ref_name || 'latest' }}
-              run: |
-                  sudo apt-get update
-                  sudo apt-get install -y docker.io bash
-                  cd docker
-                  chmod +x ./push-to-gitea.sh
-                  ./push-to-gitea.sh "${IMAGE_NAME}" "${TAG}"
-
-    deploy:
-        name: 🚀 Deploy to Remote Server
-        runs-on: ubuntu-latest
-        needs: push
-        if: github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/')
-        steps:
-            - name: Prepare environment
-              run: |
-                  sudo apt-get update
-                  sudo apt-get install -y openssh-client docker.io
-
-            - name: Deploy via SSH
-              run: |
-                  echo "${DEPLOY_KEY}" > /tmp/deploy_key.pem
-                  chmod 600 /tmp/deploy_key.pem
-
-                  ssh -i /tmp/deploy_key.pem -o StrictHostKeyChecking=no \
-                    ${DEPLOY_USER}@${DEPLOY_HOST} <<EOF
-                      docker login ${GITEA_REGISTRY} -u "${CI_REGISTRY_USER}" -p "${CI_REGISTRY_PASSWORD}"
-                      docker pull ${GITEA_REGISTRY}/${CI_REGISTRY_USER}/${IMAGE_NAME}:${TAG}
-                      docker stop ${IMAGE_NAME} || true
-                      docker rm ${IMAGE_NAME} || true
-                      docker run -d --name ${IMAGE_NAME} -p 80:80 ${GITEA_REGISTRY}/${CI_REGISTRY_USER}/${IMAGE_NAME}:${TAG}
-                  EOF
-
-#    notify:
-#        name: 🔔 Notify Deployment Result
-#        runs-on: ubuntu-latest
-#        needs: deploy
-#        if: always()
-#        steps:
-#            - name: Send Discord Notification
-#              run: |
-#                  STATUS=${{ job.status }}
-#                  MESSAGE="🚀 *Angular-Web-App Deployment* (${{ github.ref_name }}) finished with status: **${STATUS}**"
-#                  curl -H "Content-Type: application/json" \
-#                       -X POST \
-#                       -d "{\"content\": \"${MESSAGE}\"}" \
-#                       ${{ secrets.DISCORD_WEBHOOK_URL }}
-
-#    deploy-prod:
-#        if: startsWith(github.ref, 'refs/tags/')
-#    deploy-staging:
-#        if: github.ref == 'refs/heads/dev'

docker/BUILD.md

@@ -0,0 +1,124 @@
+# Docker Build Anleitung
+
+## Multi-Stage Build
+
+Das Dockerfile verwendet einen Multi-Stage Build mit zwei Stages:
+
+### Stage 1: Builder
+- **Base Image**: Node.js 24.7.0-alpine
+- **Aufgabe**: Baut die Angular-Applikation
+- Installiert Dependencies mit `npm ci`
+- Führt `npm run build` aus
+
+### Stage 2: Runner
+- **Base Image**: nginx-unprivileged:alpine3.22
+- **Aufgabe**: Serviert die statischen Dateien
+- Kopiert die gebauten Dateien aus der Builder-Stage
+- Läuft auf Port 8080
+
+## Build Ausführen
+
+### Empfohlen: Build-Script mit .env Integration
+
+Das empfohlene Vorgehen ist die Verwendung des Build-Scripts, welches automatisch den Image-Namen und Tag aus der `.env` Datei liest:
+
+```bash
+cd docker
+./build.sh
+```
+
+Das Script liest folgende Variablen aus der `.env` Datei:
+- `REGISTRY_URL`: Die Registry-URL (z.B. gitea.moz-tech.de)
+- `NAMESPACE`: Der Namespace/Benutzer (z.B. murat)
+- `REPO_NAME`: Der Repository-Name (z.B. enerport-web-app)
+- `IMAGE_TAG`: Das Image-Tag (z.B. latest, v1.0.0, dev)
+
+Der vollständige Image-Name wird dann als `${REGISTRY_URL}/${NAMESPACE}/${REPO_NAME}:${IMAGE_TAG}` zusammengesetzt.
+
+**Beispiel .env:**
+```env
+REGISTRY_URL=gitea.moz-tech.de
+NAMESPACE=murat
+REPO_NAME=enerport-web-app
+IMAGE_TAG=latest
+```
+
+### Manueller Build
+
+#### Vom docker/ Verzeichnis aus:
+
+```bash
+cd docker
+docker build -f Dockerfile -t enerport-web-app ..
+```
+
+**Wichtig**: Der Build-Kontext muss das Parent-Verzeichnis (`..`) sein, damit alle Source-Dateien verfügbar sind.
+
+#### Vom Root-Verzeichnis aus:
+
+```bash
+docker build -f docker/Dockerfile -t enerport-web-app .
+```
+
+## Container Starten
+
+```bash
+docker run -p 8080:8080 enerport-web-app
+```
+
+Die Applikation ist dann unter http://localhost:8080 erreichbar und leitet automatisch zur deutschen Lokalisierung um (http://localhost:8080/de/).
+
+### Verfügbare Sprachen
+
+Die Applikation unterstützt mehrere Sprachen durch i18n:
+- **Deutsch (de)**: http://localhost:8080/de/
+- **Deutsch-Deutschland (de-DE)**: http://localhost:8080/de-DE/
+- **Englisch (en)**: http://localhost:8080/en/
+
+## Image zur Registry pushen
+
+Nach dem erfolgreichen Build kann das Image mit dem Push-Script zur Gitea Registry hochgeladen werden:
+
+```bash
+cd docker
+./push.sh
+```
+
+Das Push-Script:
+- ✅ Liest automatisch alle Registry-Daten aus der `.env` Datei
+- ✅ Prüft ob das Image lokal existiert
+- ✅ Authentifiziert sich bei der Gitea Registry mit Token
+- ✅ Pusht das Image zur Registry
+- ✅ Logout nach erfolgreichem Push
+
+**Workflow:**
+```bash
+# 1. Image bauen
+./build.sh
+
+# 2. Image zur Registry pushen
+./push.sh
+```
+
+## CI/CD mit Gitea Actions
+
+Für automatische Builds bei jedem Commit auf den `main` Branch wurde ein Gitea Workflow eingerichtet:
+
+📄 **Workflow-Datei:** `.gitea/workflows/build-and-push.yaml`
+
+Der Workflow:
+- ✅ Wird automatisch bei Push auf `main` ausgeführt
+- ✅ Baut das Docker Image mit `build.sh`
+- ✅ Pusht das Image zur Registry mit `push.sh`
+- ✅ Verwendet Gitea Variables und Secrets (keine .env Datei in Git)
+
+**Setup-Anleitung:** Siehe [GITEA_SETUP.md](GITEA_SETUP.md) für die Einrichtung der benötigten Gitea Variables und Secrets.
+
+## Hinweise
+
+- Die `.dockerignore` Datei im docker/ Verzeichnis verhindert, dass unnötige Dateien ins Image kopiert werden
+- Das finale Image ist optimiert und enthält nur die gebauten statischen Dateien und Nginx
+- Der Nginx-Container läuft unprivileged auf Port 8080 für erhöhte Sicherheit
+- Die Scripts `build.sh` und `push.sh` nutzen die `.env` Datei für zentrale Konfiguration
+- Das Gitea Token in der `.env` Datei sollte niemals in Git committed werden
+- Für CI/CD werden Variables und Secrets aus Gitea verwendet (siehe GITEA_SETUP.md)

docker/GITEA_SETUP.md

@@ -0,0 +1,128 @@
+# Gitea CI/CD Setup
+
+Diese Anleitung erklärt, wie Sie die benötigten Variables und Secrets in Gitea für den automatischen Build und Push Workflow einrichten.
+
+## Gitea Workflow
+
+Der Workflow `.gitea/workflows/build-and-push.yaml` wird automatisch ausgeführt und:
+1. Bestimmt automatisch den Image-Tag basierend auf dem Commit/Tag
+2. Baut das Docker Image
+3. Pusht das Image zur Gitea Registry
+
+### Automatische Tag-Generierung
+
+Der IMAGE_TAG wird automatisch bestimmt:
+
+| Trigger | Tag-Format | Beispiel |
+|---------|-----------|----------|
+| Push auf `main` Branch | `latest` | `latest` |
+| Git Tag (v*) | Tag-Name | `v1.0.0`, `v2.1.3` |
+| Andere Branches | `{branch}-{sha}` | `develop-a1b2c3d` |
+
+**Sie müssen IMAGE_TAG NICHT mehr als Variable setzen** - es wird automatisch generiert!
+
+## Benötigte Gitea Variables und Secrets
+
+### Variables (öffentlich)
+
+Navigieren Sie zu: **Settings → Actions → Variables**
+
+Erstellen Sie folgende Variables:
+
+| Name | Wert | Beispiel |
+|------|------|----------|
+| `REGISTRY_URL` | URL der Gitea Registry | `gitea.moz-tech.de` |
+| `NAMESPACE` | Namespace/Benutzer | `murat` |
+| `REPO_NAME` | Repository Name | `enerport-web-app` |
+
+**Hinweis:** `IMAGE_TAG` wird automatisch aus dem Commit/Tag generiert und muss nicht als Variable gesetzt werden.
+
+### Secrets (vertraulich)
+
+Navigieren Sie zu: **Settings → Actions → Secrets**
+
+Erstellen Sie folgende Secrets:
+
+| Name | Wert | Beispiel |
+|------|------|----------|
+| `CI_GITEA_USER` | Gitea Benutzername | `murat` |
+| `CI_GITEA_TOKEN` | Gitea Access Token | `74a7738116bfb99497a7781291efc5766901f497` |
+
+**Hinweis:** 
+- User und Token werden zusammen als Secrets gespeichert für eine sichere Authentifizierung
+- Der Prefix `CI_GITEA_` ist erforderlich, da Gitea keine Variablen mit dem Prefix `GITEA_` erlaubt
+
+## Access Token erstellen
+
+1. Navigieren Sie zu **Settings → Applications → Manage Access Tokens**
+2. Klicken Sie auf **Generate New Token**
+3. Geben Sie einen Namen ein (z.B. "Docker Registry")
+4. Wählen Sie die Berechtigung: **write:package** (für Registry Push)
+5. Klicken Sie auf **Generate Token**
+6. Kopieren Sie den Token und fügen Sie ihn als Secret `CI_GITEA_TOKEN` hinzu
+
+## Workflow testen
+
+Nach der Einrichtung der Variables und Secrets:
+
+### Test 1: Push auf main Branch (erstellt 'latest' Tag)
+```bash
+git add .
+git commit -m "Test CI/CD workflow"
+git push origin main
+```
+→ Erstellt Image: `gitea.moz-tech.de/murat/enerport-web-app:latest`
+
+### Test 2: Git Tag erstellen (erstellt versioniertes Image)
+```bash
+git tag v1.0.0
+git push origin v1.0.0
+```
+→ Erstellt Image: `gitea.moz-tech.de/murat/enerport-web-app:v1.0.0`
+
+### Workflow-Status überprüfen:
+- Navigieren Sie zu **Actions** in Ihrem Gitea Repository
+- Sie sollten den Workflow "Build and Push Docker Image" sehen
+- Klicken Sie darauf, um die Logs und den verwendeten Tag zu sehen
+
+## Troubleshooting
+
+### Fehler: "REGISTRY_URL not set in .env"
+→ Stellen Sie sicher, dass alle Variables korrekt in Gitea eingerichtet sind
+
+### Fehler: "Failed to login to registry"
+→ Überprüfen Sie das `GITEA_TOKEN` Secret und stellen Sie sicher, dass es die **write:package** Berechtigung hat
+
+### Fehler: "Image not found locally"
+→ Der Build-Schritt ist fehlgeschlagen. Überprüfen Sie die Build-Logs im Workflow
+
+## Lokale Entwicklung vs. CI/CD
+
+### Lokal:
+- Verwendet die `docker/.env` Datei
+- Manuelle Ausführung von `./build.sh` und `./push.sh`
+
+### CI/CD (Gitea):
+- Erstellt `.env` Datei automatisch aus Gitea Variables/Secrets
+- Automatische Ausführung bei jedem Push auf `main`
+
+## Sicherheit
+
+⚠️ **Wichtig:**
+- Committen Sie die `docker/.env` Datei NIEMALS in Git (bereits in `.gitignore`)
+- Das `GITEA_TOKEN` sollte nur als Secret gespeichert werden
+- Alle anderen Werte können als Variables gespeichert werden
+
+## Image Pull
+
+Nach erfolgreichem Push können Sie das Image wie folgt pullen:
+
+```bash
+# Login zur Registry
+docker login gitea.moz-tech.de -u murat
+
+# Image pullen
+docker pull gitea.moz-tech.de/murat/enerport-web-app:latest
+
+# Container starten
+docker run -p 8080:8080 gitea.moz-tech.de/murat/enerport-web-app:latest

docker/build.sh

@@ -1,21 +1,94 @@
-#!/usr/bin/env bash
-set -e
+#!/bin/bash
 
-# Bild- und Tag-Parameter
-IMAGE="${1:-angular-web-app}"
-TAG="${2:-latest}"
+# ==============================================
+# Docker Build Script mit .env Integration
+# ==============================================
+# Dieses Script liest IMAGE_NAME und IMAGE_TAG
+# aus der .env Datei und führt den Docker Build aus
+# ==============================================
 
-# Pfad zum Skript selbst
+set -e  # Exit on error
+
+# Farben für Output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Script-Verzeichnis ermitteln
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/.env"
 
-# Root-Verzeichnis (eine Ebene über docker/)
-ROOT_DIR="$(realpath "$SCRIPT_DIR/..")"
+echo -e "${GREEN}=== Docker Build Script ===${NC}"
+echo ""
 
-# Dockerfile-Pfad
-DOCKERFILE="$SCRIPT_DIR/Dockerfile"
+# Prüfen ob .env Datei existiert
+if [ ! -f "$ENV_FILE" ]; then
+    echo -e "${RED}ERROR: .env file not found at ${ENV_FILE}${NC}"
+    exit 1
+fi
 
-echo "🏗️ Baue Docker-Image..."
-echo "🔹 Dockerfile: $DOCKERFILE"
-echo "🔹 Build-Kontext: $ROOT_DIR"
+# .env Datei laden
+echo -e "${YELLOW}Loading environment variables from .env...${NC}"
+set -a  # Automatisch alle Variablen exportieren
+source "$ENV_FILE"
+set +a
 
-docker build -f "$DOCKERFILE" -t "${IMAGE}:${TAG}" "$ROOT_DIR"
+# Validierung der erforderlichen Variablen
+if [ -z "$REGISTRY_URL" ]; then
+    echo -e "${RED}ERROR: REGISTRY_URL not set in .env${NC}"
+    exit 1
+fi
+
+if [ -z "$NAMESPACE" ]; then
+    echo -e "${RED}ERROR: NAMESPACE not set in .env${NC}"
+    exit 1
+fi
+
+if [ -z "$REPO_NAME" ]; then
+    echo -e "${RED}ERROR: REPO_NAME not set in .env${NC}"
+    exit 1
+fi
+
+# Image Name aus .env Variablen zusammensetzen
+IMAGE_NAME="${REGISTRY_URL}/${NAMESPACE}/${REPO_NAME}"
+
+# Image Tag (default: latest)
+IMAGE_TAG="${IMAGE_TAG:-latest}"
+
+# Vollständiger Image Name mit Tag
+FULL_IMAGE_NAME="${IMAGE_NAME}:${IMAGE_TAG}"
+
+echo -e "${GREEN}Image Name:${NC} ${FULL_IMAGE_NAME}"
+echo ""
+
+# Docker Build ausführen
+echo -e "${YELLOW}Starting Docker build...${NC}"
+echo ""
+
+# Zum Script-Verzeichnis wechseln
+cd "$SCRIPT_DIR"
+
+# Build-Befehl mit Parent-Verzeichnis als Kontext
+docker build \
+    -f Dockerfile \
+    -t "$FULL_IMAGE_NAME" \
+    --build-arg BUILDKIT_INLINE_CACHE=1 \
+    ..
+
+echo ""
+echo -e "${GREEN}✓ Build successful!${NC}"
+echo ""
+echo -e "Image: ${GREEN}${FULL_IMAGE_NAME}${NC}"
+echo ""
+echo -e "${YELLOW}To run the container:${NC}"
+echo -e "  docker run -p 8080:8080 ${FULL_IMAGE_NAME}"
+echo ""
+
+# Optional: Image auch mit 'latest' Tag erstellen für lokale Entwicklung
+if [ "$IMAGE_TAG" != "latest" ]; then
+    echo -e "${YELLOW}Tagging image as 'latest' for local development...${NC}"
+    docker tag "$FULL_IMAGE_NAME" "${IMAGE_NAME}:latest"
+    echo -e "${GREEN}✓ Tagged as ${IMAGE_NAME}:latest${NC}"
+    echo ""
+fi

docker/nginx.conf

@@ -48,9 +48,19 @@ http {
         root /usr/share/nginx/html;
         index index.html;
 
-        # Angular Routing
+        # Redirect root to default locale (de) - using relative redirect
+        location = / {
+            return 301 $scheme://$http_host/de/;
+        }
+
+        # Serve each locale
+        location ~ ^/(de|de-DE|en)/ {
+            try_files $uri $uri/ /$1/index.html;
+        }
+
+        # Fallback for any other routes to default locale
         location / {
-            try_files $uri $uri/ /index.html;
+            return 301 $scheme://$http_host/de$request_uri;
         }
 
         # Static Assets Caching

docker/push-to-gitea.sh

@@ -1,68 +0,0 @@
-#!/usr/bin/env bash
-set -e  # Skript bei Fehlern sofort beenden
-
-# === .env-Datei laden ===
-if [ -f .env ]; then
-  echo "📄 Lade Umgebungsvariablen aus .env..."
-  export $(grep -v '^#' .env | xargs)
-else
-  echo "⚠️  Keine .env-Datei gefunden – verwende Umgebungsvariablen oder Defaults."
-fi
-
-# === KONFIGURATION ===
-GITEA_REGISTRY="${GITEA_REGISTRY:-gitea.example.com}"
-GITEA_USER="${GITEA_USER:-}"
-GITEA_TOKEN="${GITEA_TOKEN:-}"
-
-DEFAULT_IMAGE="angular-web-app"
-DEFAULT_TAG="latest"
-
-# === PARAMETER ===
-IMAGE_NAME="${1:-$DEFAULT_IMAGE}"
-TAG="${2:-$DEFAULT_TAG}"
-
-# === BUILD AUSFÜHREN ===
-echo "🏗️  Baue Docker-Image..."
-./build.sh "$IMAGE_NAME" "$TAG"
-
-# === IMAGE-TAGGING ===
-FULL_IMAGE="${GITEA_REGISTRY}/${GITEA_USER}/${IMAGE_NAME}:${TAG}"
-echo "🏷️  Tagge Image für Gitea-Registry: ${FULL_IMAGE}"
-docker tag "${IMAGE_NAME}:${TAG}" "${FULL_IMAGE}"
-
-# === LOGIN ===
-if [ -n "$GITEA_USER" ] && [ -n "$GITEA_TOKEN" ]; then
-  echo "🔐 Melde bei Gitea Registry an (${GITEA_REGISTRY})..."
-  echo "$GITEA_TOKEN" | docker login "$GITEA_REGISTRY" -u "$GITEA_USER" --password-stdin
-else
-  echo "⚠️  Kein Benutzername oder Token angegeben – überspringe Login."
-fi
-
-# === PRÜFEN, OB IMAGE SCHON EXISTIERT ===
-echo "🔎 Prüfe, ob Image bereits in Registry existiert..."
-EXISTS=false
-if docker manifest inspect "${FULL_IMAGE}" >/dev/null 2>&1; then
-  EXISTS=true
-  echo "🟡 Image ${FULL_IMAGE} existiert bereits in der Registry."
-else
-  echo "🟢 Image ${FULL_IMAGE} ist neu – wird gepusht."
-fi
-
-# === DIGESTS VERGLEICHEN (wenn vorhanden) ===
-if [ "$EXISTS" = true ]; then
-  LOCAL_DIGEST=$(docker inspect --format='{{index .RepoDigests 0}}' "${FULL_IMAGE}" 2>/dev/null | cut -d'@' -f2)
-  REMOTE_DIGEST=$(docker manifest inspect "${FULL_IMAGE}" 2>/dev/null | sha256sum | awk '{print $1}')
-
-  if [ -n "$LOCAL_DIGEST" ] && [ -n "$REMOTE_DIGEST" ] && [ "$LOCAL_DIGEST" = "$REMOTE_DIGEST" ]; then
-    echo "✅ Lokales und entferntes Image sind identisch – Push wird übersprungen."
-    exit 0
-  else
-    echo "🆕 Unterschiede festgestellt – Push wird ausgeführt."
-  fi
-fi
-
-# === PUSH ===
-echo "⬆️  Push zum Gitea-Repository..."
-docker push "${FULL_IMAGE}"
-
-echo "✅ Upload abgeschlossen: ${FULL_IMAGE}"

docker/push.sh

@@ -0,0 +1,119 @@
+#!/bin/bash
+
+# ==============================================
+# Docker Push Script für Gitea Registry
+# ==============================================
+# Dieses Script liest Registry-Daten aus der
+# .env Datei und pusht das Image zur Registry
+# ==============================================
+
+set -e  # Exit on error
+
+# Farben für Output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Script-Verzeichnis ermitteln
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${SCRIPT_DIR}/.env"
+
+echo -e "${GREEN}=== Docker Push Script für Gitea Registry ===${NC}"
+echo ""
+
+# Prüfen ob .env Datei existiert
+if [ ! -f "$ENV_FILE" ]; then
+    echo -e "${RED}ERROR: .env file not found at ${ENV_FILE}${NC}"
+    exit 1
+fi
+
+# .env Datei laden
+echo -e "${YELLOW}Loading environment variables from .env...${NC}"
+set -a  # Automatisch alle Variablen exportieren
+source "$ENV_FILE"
+set +a
+
+# Validierung der erforderlichen Variablen
+if [ -z "$REGISTRY_URL" ]; then
+    echo -e "${RED}ERROR: REGISTRY_URL not set in .env${NC}"
+    exit 1
+fi
+
+if [ -z "$NAMESPACE" ]; then
+    echo -e "${RED}ERROR: NAMESPACE not set in .env${NC}"
+    exit 1
+fi
+
+if [ -z "$REPO_NAME" ]; then
+    echo -e "${RED}ERROR: REPO_NAME not set in .env${NC}"
+    exit 1
+fi
+
+if [ -z "$CI_GITEA_USER" ]; then
+    echo -e "${RED}ERROR: CI_GITEA_USER not set in .env${NC}"
+    exit 1
+fi
+
+if [ -z "$CI_GITEA_TOKEN" ]; then
+    echo -e "${RED}ERROR: CI_GITEA_TOKEN not set in .env${NC}"
+    exit 1
+fi
+
+# Image Name und Tag zusammensetzen
+IMAGE_TAG="${IMAGE_TAG:-latest}"
+FULL_IMAGE_NAME="${REGISTRY_URL}/${NAMESPACE}/${REPO_NAME}:${IMAGE_TAG}"
+
+echo -e "${BLUE}Registry:${NC} ${REGISTRY_URL}"
+echo -e "${BLUE}Image:${NC}    ${FULL_IMAGE_NAME}"
+echo -e "${BLUE}User:${NC}     ${CI_GITEA_USER}"
+echo ""
+
+# Prüfen ob das Image lokal existiert
+echo -e "${YELLOW}Checking if image exists locally...${NC}"
+if ! docker image inspect "$FULL_IMAGE_NAME" > /dev/null 2>&1; then
+    echo -e "${RED}ERROR: Image ${FULL_IMAGE_NAME} not found locally${NC}"
+    echo -e "${YELLOW}Please build the image first using ./build.sh${NC}"
+    exit 1
+fi
+echo -e "${GREEN}✓ Image found locally${NC}"
+echo ""
+
+# Login zur Gitea Registry
+echo -e "${YELLOW}Logging in to Gitea Registry...${NC}"
+echo "$CI_GITEA_TOKEN" | docker login "$REGISTRY_URL" -u "$CI_GITEA_USER" --password-stdin
+
+if [ $? -eq 0 ]; then
+    echo -e "${GREEN}✓ Successfully logged in to ${REGISTRY_URL}${NC}"
+else
+    echo -e "${RED}ERROR: Failed to login to registry${NC}"
+    exit 1
+fi
+echo ""
+
+# Image pushen
+echo -e "${YELLOW}Pushing image to registry...${NC}"
+docker push "$FULL_IMAGE_NAME"
+
+if [ $? -eq 0 ]; then
+    echo ""
+    echo -e "${GREEN}✓ Successfully pushed image!${NC}"
+    echo ""
+    echo -e "${GREEN}Image available at:${NC}"
+    echo -e "  ${FULL_IMAGE_NAME}"
+    echo ""
+
+    # Pull-Befehl anzeigen
+    echo -e "${BLUE}To pull this image:${NC}"
+    echo -e "  docker pull ${FULL_IMAGE_NAME}"
+    echo ""
+else
+    echo -e "${RED}ERROR: Failed to push image${NC}"
+    exit 1
+fi
+
+# Logout
+echo -e "${YELLOW}Logging out from registry...${NC}"
+docker logout "$REGISTRY_URL" > /dev/null 2>&1
+echo -e "${GREEN}✓ Logged out${NC}"