feat(astrololo): usluga render — raport PDF (PRE-24)

Nowy komponent skladajacy raport PDF. Osobny obraz, bo dzwiga TeX Live (setki MB)
— ta sama zasada co przy izolacji swissepha (LOG-27): obraz produktu zostaje maly,
TeX aktualizuje sie niezaleznie, a awaria renderu nie kladzie aplikacji, tylko
przycisk „Pobierz PDF".

- render.yaml — Deployment + Service. ClusterIP, BEZ NodePortu i Ingressu: nie ma
  powodu, zeby ktokolwiek siegal do tej uslugi z zewnatrz. Rozmawia wylacznie
  z prezentacja.
- Szyfrowanie: wlasny, TRZECI klucz LINK_KEY_PRESENTATION_RENDER z sekretu
  astrololo-link. Osobny, bo tym laczem plynie CALY raport (dane urodzeniowe
  i opisy z baz) — przejecie go nie moze otwierac lacza do logiki ani danych.
  LINK_ENCRYPTION_REQUIRED=true, wiec bez klucza pod NIE wstaje.
- readOnlyRootFilesystem + emptyDir na /tmp: kompilacja pisze tylko do katalogu
  tymczasowego, raport nie zostawia sladu w kontenerze.
- Limity rozjechane celowo (100m/256Mi -> 1500m/1Gi): XeLaTeX na obszernym
  raporcie bierze duzo, ale na krotko.
- presentation: RENDER_URL + trzeci klucz lacza.

Sekret astrololo-link trzeba UZUPELNIC o trzeci klucz PRZED wdrozeniem,
zachowujac dwa dotychczasowe — komenda w instrukcji.

Sprawdzone: kubectl kustomize + apply --dry-run=server na zywym klastrze
(service/render i deployment.apps/render created).

Pelna instrukcja: docs/wdrozenie-render-pdf.md w repo astrololo.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

astrololo/README.md

@@ -3,8 +3,10 @@
 Manifesty k8s składane Kustomize. Obrazy podbija automatycznie image-updater
 (`kustomization.yaml` → `images: newTag`) po każdym buildzie z repo aplikacji.
 
-Warstwy: `presentation` (NodePort, wejście z przeglądarki) → `logic` → `data`
+Warstwy: `presentation` (wejście z przeglądarki przez **Ingress po https**) →
-(pliki Excel montowane **z NFS**, nie z obrazu).
+`logic` → `data` (pliki Excel montowane **z NFS**, nie z obrazu).
+
+Adres aplikacji: **https://astrololo.czernobog.pl** — patrz [TLS](#-tls--wymagane-kroki-przed-wdrożeniem).
 
 ## ⚠️ Sekret `astrololo-auth` — utwórz PRZED wdrożeniem
 
@@ -50,15 +52,156 @@ trzech** usług naraz, inaczej przestaną się dogadywać.)
 ### Sprawdzenie po wdrożeniu
 ```bash
 kubectl -n astrololo rollout status deploy/presentation deploy/logic deploy/data
-NODE_PORT=$(kubectl -n astrololo get svc presentation -o jsonpath='{.spec.ports[0].nodePort}')
+curl -s -o /dev/null -w "bez hasła: %{http_code}\n"  https://astrololo.czernobog.pl/
-curl -s -o /dev/null -w "bez hasła: %{http_code}\n"  http://<adres-noda>:$NODE_PORT/
+curl -s -o /dev/null -w "z hasłem: %{http_code}\n" -u astrololo:'<hasło>' https://astrololo.czernobog.pl/
-curl -s -o /dev/null -w "z hasłem: %{http_code}\n" -u astrololo:'<hasło>' http://<adres-noda>:$NODE_PORT/
 ```
 Oczekiwane: **401** bez hasła, **200** z hasłem. `/health` zostaje publiczny (sondy k8s).
 
+## 🔒 TLS — wymagane kroki przed wdrożeniem
+
+Do tej pory Basic Auth szedł siecią po zwykłym http, czyli **hasło dało się
+podsłuchać** (base64 to nie szyfrowanie). Poza tym http blokował dwie funkcje,
+bo przeglądarki udostępniają je wyłącznie w tzw. *secure context*:
+**geolokalizacja** („Tu i teraz") i **kopiowanie do schowka**. Certyfikat załatwia
+oba tematy naraz.
+
+Certyfikat wystawia **własne CA** trzymane w klastrze (cert-manager). Let's Encrypt
+odpada, bo klaster stoi w LAN — walidacja HTTP-01 nie ma jak do niego dojść z
+internetu, a DNS-01 wymagałby trzymania tu tokena API do domeny.
+
+**Kolejność ma znaczenie — oba kroki PRZED synchronizacją ArgoCD.**
+
+### 1. cert-manager (jednorazowo, cały klaster)
+```bash
+kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.21.0/cert-manager.yaml
+kubectl -n cert-manager rollout status deploy/cert-manager deploy/cert-manager-webhook
+```
+Bez tego API odrzuci `Certificate` i `Issuer` jako nieznane rodzaje zasobów,
+a ArgoCD pokaże aplikację jako niezsynchronizowaną.
+
+### 2. DNS: `astrololo.czernobog.pl` → adres Traefika
+```bash
+kubectl -n kube-system get svc traefik -o jsonpath='{.status.loadBalancer.ingress[*].ip}'; echo
+```
+Wpis w routerze / lokalnym DNS-ie (albo doraźnie `/etc/hosts`). **Service
+`presentation` jest teraz `ClusterIP`** — NodePort był drugą, nieszyfrowaną drogą
+do aplikacji, więc został zdjęty. Zanim DNS zacznie odpowiadać, jedyne wejście to:
+```bash
+kubectl -n astrololo port-forward svc/presentation 8000:8000   # awaryjnie, http://localhost:8000
+```
+
+### 3. Zaufanie do własnego CA (raz na urządzenie)
+Bez tego przeglądarka pokaże ostrzeżenie o certyfikacie. Korzeń ważny 10 lat,
+więc import robisz raz:
+```bash
+kubectl -n astrololo get secret astrololo-ca -o jsonpath='{.data.ca\.crt}' \
+  | base64 -d > astrololo-ca.crt
+
+# macOS — do systemowego zaufania (poprosi o hasło administratora)
+sudo security add-trusted-cert -d -r trustRoot \
+  -k /Library/Keychains/System.keychain astrololo-ca.crt
+
+# Linux (Debian/Ubuntu)
+sudo cp astrololo-ca.crt /usr/local/share/ca-certificates/ && sudo update-ca-certificates
+```
+Firefox ma własny magazyn — tam import przez *Ustawienia → Prywatność →
+Wyświetl certyfikaty → Organy certyfikacji*.
+
+### Sprawdzenie samego TLS
+```bash
+# certyfikat wystawiony i gotowy
+kubectl -n astrololo get certificate
+# oczekiwane: astrololo-ca True, astrololo-tls True
+
+# http odsyła na https
+curl -sI http://astrololo.czernobog.pl/ | head -2       # 301 + Location: https://...
+
+# HSTS obecny
+curl -skI -u astrololo:'<hasło>' https://astrololo.czernobog.pl/ | grep -i strict-transport
+```
+
+### Odnawianie
+Certyfikat serwera żyje 90 dni i odnawia się sam 30 dni przed końcem. Termin jest
+krótki **celowo** — odnawianie sprawdza się wtedy w praktyce co kwartał, a nie
+dopiero za dziesięć lat, gdy nikt nie będzie pamiętał, jak to było skonfigurowane.
+
+## ⚠️ Sekret `astrololo-link` — szyfrowanie między warstwami
+
+Token międzywarstwowy mówi **kto** pyta, ale nie ukrywa **czego dotyczy odpowiedź**
+— a płyną nią surowe wiersze oryginalnych baz. Kto podsłuchał ruch wewnątrz sieci
+(drugi pod, mirror portu na switchu, zrzut z węzła), miał je w całości. Łącza są
+więc szyfrowane **AES-256-GCM**, osobnym kluczem na każdą parę rozmówców.
+
+```bash
+kubectl -n astrololo create secret generic astrololo-link \
+  --from-literal=LINK_KEY_PRESENTATION_LOGIC="$(openssl rand -hex 32)" \
+  --from-literal=LINK_KEY_LOGIC_DATA="$(openssl rand -hex 32)"
+```
+
+Kluczy **nikt nigdy nie musi oglądać** — służą tylko usługom. Rozdzielenie jest
+celowe: przejęcie klucza prezentacji nie daje dostępu do warstwy danych, gdzie
+leżą całe bazy. Logika trzyma oba, bo rozmawia w obie strony; prezentacja i dane
+dostają przez `secretKeyRef` wyłącznie swój.
+
+**Pody nie wstaną bez tych kluczy** (`LINK_ENCRYPTION_REQUIRED=true`) — i tak ma
+być. Usługa, która wstała i po cichu nie szyfruje, jest gorsza niż pod w CrashLoop,
+bo awarii nie widać.
+
+### Wymiana kluczy
+```bash
+kubectl -n astrololo create secret generic astrololo-link \
+  --from-literal=LINK_KEY_PRESENTATION_LOGIC="$(openssl rand -hex 32)" \
+  --from-literal=LINK_KEY_LOGIC_DATA="$(openssl rand -hex 32)" \
+  --dry-run=client -o yaml | kubectl apply -f -
+kubectl -n astrololo rollout restart deploy/presentation deploy/logic deploy/data
+```
+Restart **wszystkich trzech naraz** — w trakcie wymiany warstwy chwilowo się nie
+dogadują (klucze muszą być zgodne po obu stronach łącza).
+
+## Klucze do modeli w chmurze — sekret `astrololo-llm` (opcjonalny)
+
+Domyślnie działa **model lokalny** i nic nie opuszcza sieci. Żeby móc wybrać w UI
+OpenAI lub Anthropic, potrzebne są ich klucze. Ten sekret jest **opcjonalny**
+(`optional: true`) — bez niego pody startują normalnie, tylko chmura jest niedostępna.
+
+```bash
+read -rs -p "OPENAI_API_KEY (Enter = pomiń): " OPENAI_KEY; echo
+read -rs -p "ANTHROPIC_API_KEY (Enter = pomiń): " ANTHROPIC_KEY; echo
+
+kubectl -n astrololo create secret generic astrololo-llm \
+  --from-literal=OPENAI_API_KEY="$OPENAI_KEY" \
+  --from-literal=ANTHROPIC_API_KEY="$ANTHROPIC_KEY"
+
+unset OPENAI_KEY ANTHROPIC_KEY
+kubectl -n astrololo rollout restart deploy/logic     # klucze wstrzykują się przy starcie
+```
+
+Podmiana pojedynczego klucza (bez kasowania drugiego):
+```bash
+kubectl -n astrololo create secret generic astrololo-llm \
+  --from-literal=OPENAI_API_KEY="$(kubectl -n astrololo get secret astrololo-llm \
+      -o jsonpath='{.data.OPENAI_API_KEY}' | base64 -d)" \
+  --from-literal=ANTHROPIC_API_KEY='NOWY-KLUCZ' \
+  --dry-run=client -o yaml | kubectl apply -f -
+kubectl -n astrololo rollout restart deploy/logic
+```
+
+**Adres modelu lokalnego** ustawia `LOCAL_BASE_URL` w `logic.yaml` — dopasuj do miejsca,
+gdzie faktycznie stoi Ollama/vLLM. Konfiguracja jest **per dostawca**
+(`LOCAL_*`, `OPENAI_*`, `ANTHROPIC_*`), więc ustawienia lokalnego modelu nie przejmują
+żądań do chmury.
+
+> Wybór dostawcy w chmurze oznacza, że **oryginalne opisy z baz opuszczają naszą sieć**.
+> Prompt można obejrzeć przed wysłaniem. Warto zawnioskować u dostawcy o Zero Data
+> Retention — patrz LOG-32.
+
 ## Czego to nie załatwia
-- **Brak TLS** — Basic Auth idzie po sieci w postaci łatwej do podsłuchania. Przy
+- **Własne CA to nie to samo co publiczne zaufanie** — każde nowe urządzenie
-  niezaufanej sieci potrzebny ingress z certyfikatem.
+  wymaga importu korzenia (krok 3 powyżej). Gdyby aplikacja miała kiedyś wyjść
+  na świat, właściwą drogą jest Let's Encrypt przez DNS-01.
+- **Szyfrowane są ciała żądań, nie nagłówki** — ścieżka (`/search`) i token
+  międzywarstwowy jadą czytelnie. Sam token nikomu nic nie daje: bez klucza łącza
+  każde żądanie kończy się odmową. Pełne ukrycie metadanych wymagałoby mTLS.
 - **NFS `192.168.1.34:/mnt/Tank1/astrololo`** — kto ma dostęp do share'u, bierze
   pliki baz **z pominięciem całej aplikacji**. Do zamknięcia po stronie infrastruktury
   (eksport tylko dla IP węzłów, `root_squash`, najlepiej read-only).

astrololo/data.yaml

@@ -29,6 +29,17 @@ spec:
             - name: INTERNAL_TOKEN
               valueFrom:
                 secretKeyRef: { name: astrololo-auth, key: INTERNAL_TOKEN }
+            # Szyfrowanie łącza między warstwami (PRE-16). OSOBNY klucz na każdą
+            # parę rozmówców: przejęcie klucza prezentacji nie otwiera warstwy
+            # danych, gdzie leżą całe bazy. Sekret tworzony POZA repo — patrz README.
+            - name: LINK_KEY_LOGIC_DATA
+              valueFrom:
+                secretKeyRef: { name: astrololo-link, key: LINK_KEY_LOGIC_DATA }
+            # Bez klucza usługa ma NIE wstać, a klient ma nie wysłać niczego.
+            # Sam serwer broni się fail-closed, ale to za mało: klient bez klucza
+            # zdążyłby wypuścić zapytanie jawnym tekstem, zanim dostanie odmowę.
+            - name: LINK_ENCRYPTION_REQUIRED
+              value: "true"
           volumeMounts:
             - name: cache
               mountPath: /app/.cache

astrololo/ingress.yaml

@@ -0,0 +1,75 @@
+# Wejście do aplikacji po HTTPS (PRE-16).
+#
+# Poza bezpieczeństwem — Basic Auth po zwykłym http leci siecią czytelny dla
+# każdego, kto słucha — TLS naprawia DWIE funkcje zepsute dziś z tego samego
+# powodu: geolokalizacja przeglądarki („Tu i teraz") oraz kopiowanie promptu do
+# schowka działają wyłącznie w tzw. secure context i po http po prostu odmawiają.
+---
+apiVersion: traefik.io/v1alpha1
+kind: Middleware
+metadata:
+  name: security-headers
+  namespace: astrololo
+spec:
+  headers:
+    stsSeconds: 31536000                  # HSTS: rok
+    stsIncludeSubdomains: false           # dotyczy tylko tego hosta
+    stsPreload: false                     # preload to wpis na listę w przeglądarkach
+                                          # — praktycznie nieodwracalny, nie wchodzimy
+    forceSTSHeader: true                  # nagłówek także przy odpowiedziach z backendu
+    contentTypeNosniff: true
+    frameDeny: true
+    referrerPolicy: same-origin
+---
+apiVersion: traefik.io/v1alpha1
+kind: Middleware
+metadata:
+  name: redirect-https
+  namespace: astrololo
+spec:
+  redirectScheme:
+    scheme: https
+    permanent: true
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: astrololo
+  namespace: astrololo
+  annotations:
+    traefik.ingress.kubernetes.io/router.entrypoints: websecure
+    traefik.ingress.kubernetes.io/router.middlewares: astrololo-security-headers@kubernetescrd
+spec:
+  tls:
+    - hosts: [astrololo.czernobog.pl]
+      secretName: astrololo-tls           # wypełnia cert-manager (tls.yaml)
+  rules:
+    - host: astrololo.czernobog.pl
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service: { name: presentation, port: { number: 8000 } }
+---
+# Osobny Ingress wyłącznie na porcie 80 — istnieje po to, żeby odesłać na https.
+# Rozdzielone świadomie: gdyby przekierowanie wisiało na tym samym routerze, co
+# wejście po https, odsyłałoby samo do siebie w kółko. Backend jest tu formalnością,
+# bo żadne żądanie do niego nie dojdzie.
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: astrololo-redirect
+  namespace: astrololo
+  annotations:
+    traefik.ingress.kubernetes.io/router.entrypoints: web
+    traefik.ingress.kubernetes.io/router.middlewares: astrololo-redirect-https@kubernetescrd
+spec:
+  rules:
+    - host: astrololo.czernobog.pl
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service: { name: presentation, port: { number: 8000 } }

astrololo/kustomization.yaml

@@ -5,10 +5,15 @@ resources:
   - data.yaml
   - logic.yaml
   - presentation.yaml
+  - render.yaml # składanie raportu PDF (PRE-24), osobny obraz z TeX Live
+  - tls.yaml # certyfikat z własnego CA (wymaga cert-managera)
+  - ingress.yaml # wejście po https + przekierowanie z http
 images:
   - name: gitea.czernobog.pl/gitea/astrololo-data
-    newTag: 752f477a
+    newTag: f34016a4
   - name: gitea.czernobog.pl/gitea/astrololo-logic
-    newTag: 4ef90b30
+    newTag: f34016a4
+  - name: gitea.czernobog.pl/gitea/astrololo-render
+    newTag: latest
   - name: gitea.czernobog.pl/gitea/astrololo-presentation
-    newTag: 4ef90b30
+    newTag: f34016a4

astrololo/logic.yaml

@@ -26,6 +26,44 @@ spec:
             - name: INTERNAL_TOKEN
               valueFrom:
                 secretKeyRef: { name: astrololo-auth, key: INTERNAL_TOKEN }
+            # Szyfrowanie łącza między warstwami (PRE-16). OSOBNY klucz na każdą
+            # parę rozmówców: przejęcie klucza prezentacji nie otwiera warstwy
+            # danych, gdzie leżą całe bazy. Sekret tworzony POZA repo — patrz README.
+            - name: LINK_KEY_PRESENTATION_LOGIC
+              valueFrom:
+                secretKeyRef: { name: astrololo-link, key: LINK_KEY_PRESENTATION_LOGIC }
+            - name: LINK_KEY_LOGIC_DATA
+              valueFrom:
+                secretKeyRef: { name: astrololo-link, key: LINK_KEY_LOGIC_DATA }
+            # Bez klucza usługa ma NIE wstać, a klient ma nie wysłać niczego.
+            # Sam serwer broni się fail-closed, ale to za mało: klient bez klucza
+            # zdążyłby wypuścić zapytanie jawnym tekstem, zanim dostanie odmowę.
+            - name: LINK_ENCRYPTION_REQUIRED
+              value: "true"
+
+            # --- Model językowy (LOG-31) ---
+            # Domyślnie LOKALNY: prompt niesie oryginalne opisy z baz, więc nic nie
+            # opuszcza sieci. Dostawcę można przełączyć w UI przy pojedynczym żądaniu.
+            - name: LLM_PROVIDER
+              value: "local"
+            - name: LOCAL_BASE_URL
+              value: "http://ollama.ollama.svc.cluster.local:11434/v1"
+            - name: LOCAL_MODEL
+              value: "llama3.1:8b"
+            - name: LLM_TIMEOUT
+              value: "180"                       # dłuższe horoskopy potrafią trwać
+            - name: LLM_MAX_TOKENS
+              value: "2000"
+
+            # Klucze do chmury — OPCJONALNE (optional: true), bo to funkcja, nie
+            # zabezpieczenie: bez sekretu pody startują normalnie i działa model
+            # lokalny. Wybór chmury w UI oznacza, że treść baz OPUSZCZA naszą sieć.
+            - name: OPENAI_API_KEY
+              valueFrom:
+                secretKeyRef: { name: astrololo-llm, key: OPENAI_API_KEY, optional: true }
+            - name: ANTHROPIC_API_KEY
+              valueFrom:
+                secretKeyRef: { name: astrololo-llm, key: ANTHROPIC_API_KEY, optional: true }
           resources:
             requests: { cpu: "100m", memory: "128Mi" }
             limits:   { cpu: "500m", memory: "512Mi" }

astrololo/presentation.yaml

@@ -30,6 +30,32 @@ spec:
               value: "astrololo"
             - name: RATE_LIMIT_PER_MIN
               value: "120"                       # 0 = bez limitu
+            # Aplikacja stoi za Ingressem, więc bezpośrednim rozmówcą jest zawsze
+            # pod Traefika. Bez tego limit żądań liczyłby WSZYSTKICH do jednego
+            # wiadra i pierwsza osoba, która go wyklika, odcięłaby pozostałych.
+            # Włączać wyłącznie gdy ruch faktycznie idzie przez proxy — inaczej
+            # nagłówek staje się furtką do ominięcia limitu.
+            - name: TRUST_PROXY
+              value: "true"
+            # Szyfrowanie łącza między warstwami (PRE-16). OSOBNY klucz na każdą
+            # parę rozmówców: przejęcie klucza prezentacji nie otwiera warstwy
+            # danych, gdzie leżą całe bazy. Sekret tworzony POZA repo — patrz README.
+            - name: LINK_KEY_PRESENTATION_LOGIC
+              valueFrom:
+                secretKeyRef: { name: astrololo-link, key: LINK_KEY_PRESENTATION_LOGIC }
+            # Bez klucza usługa ma NIE wstać, a klient ma nie wysłać niczego.
+            # Sam serwer broni się fail-closed, ale to za mało: klient bez klucza
+            # zdążyłby wypuścić zapytanie jawnym tekstem, zanim dostanie odmowę.
+            # Usługa składająca PDF (PRE-24) — osobny komponent.
+            - name: RENDER_URL
+              value: "http://render:8004"        # discovery po nazwie Service
+            # Trzeci klucz łącza: prezentacja ↔ render. Osobny, bo tym łączem
+            # idzie CAŁY raport (dane urodzeniowe + opisy z baz).
+            - name: LINK_KEY_PRESENTATION_RENDER
+              valueFrom:
+                secretKeyRef: { name: astrololo-link, key: LINK_KEY_PRESENTATION_RENDER }
+            - name: LINK_ENCRYPTION_REQUIRED
+              value: "true"
           resources:
             requests: { cpu: "100m", memory: "128Mi" }
             limits:   { cpu: "300m", memory: "256Mi" }
@@ -40,7 +66,10 @@ metadata:
   name: presentation
   namespace: astrololo
 spec:
-  type: NodePort                                  # wejście z przeglądarki
+  # Wejście z przeglądarki idzie teraz WYŁĄCZNIE przez Ingress po https
+  # (ingress.yaml). NodePort był drugą, nieszyfrowaną drogą do środka — czyli
+  # obejściem całego PRE-16 — więc znika.
+  type: ClusterIP
   selector: { app: presentation }
   ports: [{ port: 8000, targetPort: 8000 }]
 

astrololo/render.yaml

@@ -0,0 +1,69 @@
+# Usługa render — składanie raportu PDF (PRE-24).
+#
+# OSOBNY komponent, nie część prezentacji, z tego samego powodu co silnik
+# swisseph (LOG-27): obraz dźwiga TeX Live, czyli setki megabajtów. W obrazie
+# produktu spowalniałby każdy build i deploy; tak aktualizuje się niezależnie,
+# a jego awaria nie kładzie aplikacji — psuje się tylko przycisk „Pobierz PDF".
+#
+# Rozmawia WYŁĄCZNIE z prezentacją, po szyfrowanym łączu z własnym, trzecim
+# kluczem. Wystawiona jako ClusterIP — bez NodePort i bez Ingressu, bo nie ma
+# powodu, żeby ktokolwiek sięgał do niej z zewnątrz.
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: render
+  namespace: astrololo
+spec:
+  replicas: 1
+  selector: { matchLabels: { app: render } }
+  template:
+    metadata: { labels: { app: render } }
+    spec:
+      imagePullSecrets: [{ name: gitea-registry }]
+      containers:
+        - name: render
+          image: gitea.czernobog.pl/gitea/astrololo-render:latest
+          ports: [{ containerPort: 8004 }]
+          env:
+            # Token międzywarstwowy (LOG-32) — ta usługa dostaje CAŁY raport:
+            # dane urodzeniowe i opisy z baz.
+            - name: INTERNAL_TOKEN
+              valueFrom:
+                secretKeyRef: { name: astrololo-auth, key: INTERNAL_TOKEN }
+            # Szyfrowanie łącza (PRE-16/PRE-24). OSOBNY klucz na parę rozmówców:
+            # przejęcie klucza renderu nie może otwierać łącza do logiki ani danych.
+            - name: LINK_KEY_PRESENTATION_RENDER
+              valueFrom:
+                secretKeyRef: { name: astrololo-link, key: LINK_KEY_PRESENTATION_RENDER }
+            - name: LINK_ENCRYPTION_REQUIRED
+              value: "true"
+          # XeLaTeX na obszernym raporcie potrafi zjeść sporo pamięci i CPU,
+          # ale tylko na chwilę — stąd wyraźna różnica między request a limit.
+          resources:
+            requests: { cpu: "100m", memory: "256Mi" }
+            limits:   { cpu: "1500m", memory: "1Gi" }
+          # Kompilacja pisze wyłącznie do katalogu tymczasowego, który sprząta po
+          # sobie. Dajemy na to emptyDir i zamykamy resztę systemu plików —
+          # raport nie ma prawa zostawić śladu w kontenerze.
+          volumeMounts:
+            - { name: tmp, mountPath: /tmp }
+          securityContext:
+            readOnlyRootFilesystem: true
+            allowPrivilegeEscalation: false
+          readinessProbe:
+            httpGet: { path: /health, port: 8004 }
+            initialDelaySeconds: 5
+            periodSeconds: 15
+      volumes:
+        - name: tmp
+          emptyDir: { sizeLimit: 512Mi }
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: render
+  namespace: astrololo
+spec:
+  type: ClusterIP            # tylko dla prezentacji, bez wejścia z zewnątrz
+  selector: { app: render }
+  ports: [{ port: 8004, targetPort: 8004 }]

astrololo/tls.yaml

@@ -0,0 +1,65 @@
+# Certyfikat dla wejścia do aplikacji (PRE-16).
+#
+# Dlaczego WŁASNE CA, a nie Let's Encrypt: klaster stoi w LAN (traefik trzyma
+# LoadBalancera na 192.168.1.x), więc walidacja HTTP-01 nie ma jak dojść z
+# internetu, a DNS-01 wymagałby trzymania w klastrze tokena API do domeny.
+# Własne CA nie potrzebuje niczego z zewnątrz, a certyfikaty odnawia samo.
+#
+# WYMAGANIE WSTĘPNE: cert-manager musi być w klastrze PRZED synchronizacją tego
+# katalogu — inaczej API odrzuci poniższe obiekty jako nieznane rodzaje zasobów.
+# Instalacja jednorazowa: patrz README.md.
+#
+# Wszystko jest w namespace `astrololo` (Issuer, nie ClusterIssuer) świadomie:
+# ArgoCD ma tu włączone `prune`, a zasoby o zasięgu całego klastra chcemy trzymać
+# poza aplikacją, która może zostać skasowana.
+---
+apiVersion: cert-manager.io/v1
+kind: Issuer
+metadata:
+  name: selfsigned
+  namespace: astrololo
+spec:
+  selfSigned: {}
+---
+# Korzeń zaufania. TO JEST certyfikat, który raz importujesz do przeglądarki
+# i systemu — patrz README. Stąd długi termin ważności: importu nie chcemy
+# powtarzać co kwartał.
+apiVersion: cert-manager.io/v1
+kind: Certificate
+metadata:
+  name: astrololo-ca
+  namespace: astrololo
+spec:
+  isCA: true
+  commonName: astrololo internal CA
+  secretName: astrololo-ca                # tu lądują klucz i certyfikat korzenia
+  duration: 87600h                        # 10 lat
+  renewBefore: 8760h                      # odnowienie na rok przed końcem
+  privateKey: { algorithm: ECDSA, size: 256 }
+  issuerRef: { name: selfsigned, kind: Issuer, group: cert-manager.io }
+---
+apiVersion: cert-manager.io/v1
+kind: Issuer
+metadata:
+  name: astrololo-ca
+  namespace: astrololo
+spec:
+  ca: { secretName: astrololo-ca }
+---
+# Właściwy certyfikat serwera. Krótki termin CELOWO: przy 90 dniach odnawianie
+# jest sprawdzane w praktyce co kwartał, więc awaria wyjdzie od razu, a nie za
+# dziesięć lat, gdy nikt już nie będzie pamiętał, jak to działa.
+apiVersion: cert-manager.io/v1
+kind: Certificate
+metadata:
+  name: astrololo-tls
+  namespace: astrololo
+spec:
+  secretName: astrololo-tls               # tego szuka Ingress
+  commonName: astrololo.czernobog.pl
+  dnsNames:
+    - astrololo.czernobog.pl
+  duration: 2160h                         # 90 dni
+  renewBefore: 720h                       # 30 dni zapasu
+  privateKey: { algorithm: ECDSA, size: 256, rotationPolicy: Always }
+  issuerRef: { name: astrololo-ca, kind: Issuer, group: cert-manager.io }