Kubernetes

Stellen Sie FoxIDs in Ihrem Kubernetes (K8s) Cluster oder in Docker Desktop mit aktiviertem Kubernetes bereit.

Dies ist eine Beschreibung, wie Sie eine Standard Bereitstellung durchführen und sich erstmals anmelden sowie einige Überlegungen. Es wird erwartet, dass Sie die yaml Dateien an Ihre Bedürfnisse, Präferenzen und Umgebung anpassen müssen.

Eine FoxIDs Installation ist wie ein Eimer, es gibt keine externen Abhängigkeiten und es ist einfach, mit wenig Aufwand eine sehr hohe Verfügbarkeit zu erreichen. FoxIDs werden aktualisiert, indem die beiden Docker Images foxids/foxids und foxids/foxids-control auf eine neue Version aktualisiert werden. Neue FoxIDs Releases sind abwärtskompatibel, konsultieren Sie bitte die release notes vor dem Update.

Voraussetzungen:

• Sie haben einen Kubernetes Cluster oder Docker Desktop mit aktiviertem Kubernetes.
• Grundkenntnisse in Kubernetes.
• Sie haben kubectl installiert.

Dies ist eine Liste nützlicher Befehle am Ende dieser Beschreibung.

Diese Bereitstellung umfasst:

• Zwei Websites, eine für FoxIDs und eine für FoxIDs Control (der Admin Client und API) in zwei Docker Images foxids/foxids und foxids/foxids-control.
• Die beiden Websites werden auf zwei verschiedenen Domains mit automatisch generierten Let's Encrypt Zertifikaten bereitgestellt.
• MongoDB ist eine NoSQL Datenbank und enthält alle Daten einschließlich Tenants, Umgebungen und Benutzer. Bereitgestellt mit dem offiziellen MongoDB Docker Image. Optional können Sie Ihre eigene PostgreSQL Instanz statt MongoDB verwenden.
• Standardmäßig wird der Cache in der Datenbank gehalten. Optional nutzen Sie einen Redis cache, wenn Sie ein FoxIDs Cluster mit hoher Durchsatzrate installieren. Der Cache hält Sequenzen (z. B. Login und Logout) und verwaltet Zähler, um die Authentifizierung gegen verschiedene Angriffe zu schützen, sowie Daten Cache (nur Redis) zur Leistungsverbesserung. Redis wird mit dem offiziellen Redis Docker Image bereitgestellt.
• Logs werden in stdout geschrieben, wo sie von Kubernetes aufgenommen werden können.

Bereitstellung

Die Bereitstellung erfolgt in der beschriebenen Reihenfolge.

Vorbereitung

Klonen Sie das git repository oder laden Sie es als ZIP herunter. Die K8s yaml Konfigurationsdateien befinden sich im Ordner ./Kubernetes.
Öffnen Sie eine Konsole und navigieren Sie zum Ordner ./Kubernetes.

Persistente Volumes

Sie benötigen persistente Volumes für MongoDB und optional Redis.

In einem Kubernetes Cluster verwenden oder erstellen Sie geeignete persistente Volumes und erstellen Sie einen persistent volume claim mit dem Namen mongo-data-pvc für MongoDB und optional einen für Redis mit dem Namen redis-data-pvc.

Sie können möglicherweise dynamische Storage Bereitstellung mit StorageClass verwenden.

persistent volume claim für Mongo erstellen

kubectl apply -f k8s-mongo-pvc-dynamic.yaml

Optional persistent volume claim für Redis erstellen

kubectl apply -f k8s-redis-pvc-dynamic.yaml

Kubernetes in Docker Desktop

Wenn Sie Kubernetes in Docker Desktop verwenden, können Sie persistente Volumes auf dem Host Dateisystem erstellen - nicht empfohlen für Produktion.

persistent volume für MongoDB erstellen

kubectl apply -f k8s-mongo-pv-dockerdesktop.yaml

persistent volume claim für MongoDB erstellen

kubectl apply -f k8s-mongo-pvc-dockerdesktop.yaml

Optional persistent volume für Redis erstellen

kubectl apply -f k8s-redis-pv-dockerdesktop.yaml

Optional persistent volume claim für Redis erstellen

kubectl apply -f k8s-redis-pvc-dockerdesktop.yaml

Namespace

Diese Anleitung verwendet in der Regel den Namespace foxids, erwägen Sie, den Namespace an Ihre Kubernetes Umgebung anzupassen.

Namespace erstellen

kubectl create namespace foxids

MongoDB

Ändern Sie Benutzername und Passwort für MongoDB in k8s-mongo-secret.yaml. Benutzername und Passwort sind base64 codiert.

Sie base64 codieren "the text" in einer Eingabeaufforderung abhängig von Ihrer Plattform:

Windows

powershell "[convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes(\"the text\"))"

Linux / Mac

echo -n "the text" | base64

MongoDB Secret hinzufügen

kubectl apply -f k8s-mongo-secret.yaml -n foxids

MongoDB erstellen
Optional MongoDB auf Port 27017 exponieren, indem LoadBalancer auskommentiert wird

kubectl apply -f k8s-mongo-deployment.yaml -n foxids

ConfigMap für den MongoDB Service hinzufügen

kubectl apply -f k8s-mongo-configmap.yaml -n foxids

Optional PostgreSQL statt MongoDB verwenden

Ändern Sie den Benutzernamenwert in postgres-username und den Passwortwert in postgres-password, damit sie zu Ihrer PostgreSQL Instanz in k8s-postgres-secret.yaml passen. Benutzername und Passwort sind base64 codiert.

PostgreSQL Secret hinzufügen

kubectl apply -f k8s-postgres-secret.yaml -n foxids

Ändern Sie den PostgreSQL Datenbank Endpunkt in postgres-db, damit er zu Ihrer PostgreSQL Instanz in k8s-postgres-configmap.yaml passt

ConfigMap für den PostgreSQL Service hinzufügen

kubectl apply -f k8s-postgres-configmap.yaml -n foxids

Optional Redis verwenden

Optional Redis erstellen

kubectl apply -f k8s-redis-deployment.yaml -n foxids

Optional ConfigMap für den Redis Service hinzufügen

kubectl apply -f k8s-redis-configmap.yaml -n foxids

FoxIDs Websites

Domains
Die beiden FoxIDs Websites sind so konfiguriert, dass sie zwei Domains verwenden, die Sie in DNS erstellen und verwalten. Konfigurieren Sie die Datei k8s-foxids-deployment.yaml mit Ihren ausgewählten Domains:

• Die FoxIDs Site Domain https://id.itfoxtec.com (zwei Stellen in der Datei) wird in Ihre Domain geändert - id.my-domain.com
• Die FoxIDs Control Site Domain https://control.itfoxtec.com wird in Ihre Domain geändert - control.my-domain.com

E Mail Provider
Optional können Sie einen globalen E Mail Provider konfigurieren oder später E Mail Provider pro Umgebung konfigurieren. FoxIDs unterstützt das Senden von E Mails mit SendGrid und SMTP.

Der globale E Mail Provider wird in der Datei k8s-foxids-deployment.yaml beim foxids Container/Pod im Abschnitt env: konfiguriert.
Dieses Beispiel zeigt, wie Sie Outlook / Microsoft 365 mit SMTP hinzufügen:

- name: "Settings__Smtp__FromEmail"
    value: "my@email-address.org"
- name: "Settings__Smtp__FromName" # Optionaler Absendername zur E Mail Adresse 
    value: "e.g, my company name"
- name: "Settings__Smtp__Host"
    value: "smtp.office365.com"
- name: "Settings__Smtp__Port"
    value: "587"
- name: "Settings__Smtp__Username"
    value: "my@email-address.com"
- name: "Settings__Smtp__Password"
    value: "xxxxxxx"

Wichtig, wenn Sie PostgreSQL verwenden
Ändern Sie die Datenbank und Cache Konfiguration in k8s-foxids-deployment.yaml (zwei Stellen in der Datei).

PostgreSQL als Datenbank statt MongoDb auswählen

- name: "Settings__Options__DataStorage"
   # value: "MongoDb"
   value: "PostgreSql"  # PostgreSql Datenbank

PostgreSQL als Cache statt MongoDb auswählen, es sei denn, Sie verwenden Redis

- name: "Settings__Options__Cache"
   # value: "MongoDb"
   value: "PostgreSql"  # Cache in PostgreSql Datenbank
   # value: "Redis"  # Cache in Redis 

PostgreSQL Zugriffskonfiguration auskommentieren

- name: POSTGRES_USERNAME
    valueFrom:
    secretKeyRef:
        name: postgres-secret
        key: postgres-username
- name: POSTGRES_PASSWORD
    valueFrom: 
    secretKeyRef:
        name: postgres-secret
        key: postgres-password
- name: POSTGRES_SERVER
    valueFrom: 
    configMapKeyRef:
        name: postgres-configmap
        key: database_url
- name: "Settings__PostgreSql__ConnectionString"
    value: "Host=$(POSTGRES_SERVER);Username=$(POSTGRES_USERNAME);Password=$(POSTGRES_PASSWORD);Database=FoxIDs"

Wichtig, wenn Sie Redis verwenden
Ändern Sie die Cache Konfiguration in k8s-foxids-deployment.yaml (zwei Stellen in der Datei).

Redis als Cache statt MongoDb auswählen

- name: "Settings__Options__Cache"
   # value: "MongoDb"
   # value: "PostgreSql"  # Cache in PostgreSql Datenbank
   value: "Redis"  # Cache in Redis

Redis Zugriffskonfiguration auskommentieren

- name: REDIS_SERVER
    valueFrom: 
    configMapKeyRef:
        name: redis-configmap
        key: database_url
- name: "Settings__RedisCache__ConnectionString"
    value: "$(REDIS_SERVER):6379"

Bereitstellen
Erstellen Sie die beiden FoxIDs Websites

kubectl apply -f k8s-foxids-deployment.yaml -n foxids

Die Konfiguration erfordert einen Nginx Controller. Optional können Sie die Konfiguration so ändern, dass ein anderer Controller verwendet wird.

Voraussetzungen:

• Sie haben Helm installiert.
  Installieren Sie Helm unter Windows mit diesem CMD Befehl winget install Helm.Helm

Ingress-Nginx Controller mit zwei Befehlen installieren

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx --force-update
helm -n ingress-nginx install ingress-nginx ingress-nginx/ingress-nginx --create-namespace

Optional Ingress-Nginx Installation verifizieren

kubectl get pod -n ingress-nginx

Wenn Sie es in ein paar Minuten erneut versuchen, sollten Sie eine EXTERNAL-IP erhalten

kubectl get svc -n ingress-nginx ingress-nginx-controller

DNS Einträge zu den zwei Domains müssen auf die IP Adresse der Installation zeigen, um die Let's Encrypt Online Validierung zu ermöglichen.
Die Firewall muss Anfragen auf Port 80 und 443 akzeptieren. Let's encrypt validiert den Domainbesitz auf Port 80.

Optional Ingress-Nginx Controller skalieren

kubectl scale deployment ingress-nginx-controller -n ingress-nginx --replicas=2

Cert-manager mit zwei Befehlen installieren

helm repo add jetstack https://charts.jetstack.io --force-update
helm install cert-manager jetstack/cert-manager --namespace cert-manager --create-namespace --set crds.enabled=true

Optional Cert-manager Installation verifizieren

kubectl get pods -n cert-manager

Fügen Sie Ihre E Mail in der Datei k8s-letsencrypt-issuer.yaml (an zwei Stellen) hinzu.

Let's Encrypt konfigurieren

kubectl apply -f k8s-letsencrypt-issuer.yaml -n foxids

Die Datei k8s-foxids-ingress-deployment.yaml ist mit den Domains konfiguriert:

• Die FoxIDs Site Domain id.itfoxtec.com (zwei Stellen in der Datei) wird in Ihre Domain geändert - id.my-domain.com
• Die FoxIDs Control Site Domain control.itfoxtec.com (zwei Stellen in der Datei) wird in Ihre Domain geändert - control.my-domain.com

Erwägen Sie, mit Let's Encrypt in staging zu starten, um die Let's Encrypt Produktions Rate Limits nicht zu überschreiten (staging Zertifikate sind nicht vom Browser vertraut).
Optional wählen Sie staging oder Produktion in der Datei k8s-foxids-ingress-deployment.yaml, standardmäßig ist Produktion konfiguriert.

Ingress mit zertifikatsgebundenen Domains hinzufügen

kubectl apply -f k8s-foxids-ingress-deployment.yaml -n foxids

Wichtig! Ingress ist mit den Annotationen nginx.ingress.kubernetes.io/proxy-buffers-number: "4" und nginx.ingress.kubernetes.io/proxy-buffer-size: "32k" installiert, um SAML 2.0 zu unterstützen, bei dem HTTP Antworten recht groß sein können.

Optional Ingress verifizieren

kubectl get ingress -n foxids

Optional certificate issuer verifizieren

kubectl describe ClusterIssuer letsencrypt-production -n foxids
#staging 
# kubectl describe ClusterIssuer letsencrypt-staging -n foxids

Optional prüfen, ob das Zertifikat bereit ist (READY sollte True sein)

kubectl get certificate -n foxids

Und optional das Zertifikat verifizieren

kubectl describe certificate letsencrypt-production -n foxids
#staging 
# kubectl describe certificate letsencrypt-staging -n foxids

Erster Login

Öffnen Sie Ihre FoxIDs Control Site Domain in einem Browser. Sie sollte zur FoxIDs Site weiterleiten, wo Sie sich mit dem Standard Admin Benutzer admin@foxids.com und dem Passwort FirstAccess! anmelden (Sie müssen das Passwort beim ersten Login ändern).
Sie werden dann zurück zur FoxIDs Control Site im master Tenant weitergeleitet. Sie können weitere Admin Benutzer im Master Tenant hinzufügen.

Klicken Sie anschließend auf den main Tenant und authentifizieren Sie sich erneut mit demselben Standard Admin Benutzer admin@foxids.com und dem Passwort FirstAccess! (auch hier müssen Sie das Passwort ändern).

Standard Admin Benutzer und Passwort sind für master Tenant und main Tenant gleich, es handelt sich jedoch um zwei unterschiedliche Benutzer.

Sie sind jetzt im main Tenant angemeldet und können mit der Konfiguration Ihrer Anwendungen und Authentifizierungsmethoden beginnen.

Seed Daten

Die Datenbank wird automatisch basierend auf den konfigurierten Domains gesät. Daher müssen Sie die Datenbank löschen, wenn die Domains geändert werden.
Um die Daten zu löschen; Sie können entweder den Datenbank Pod stoppen und den physischen Datenbankordner oder Dateien löschen. Oder den Datenbank Endpunkt exponieren und die Datenbank in MongoDB Compress öffnen (Download MongoDB Compass (GUI)) und die Datenbank löschen.
Danach muss der FoxIDs Control Pod neu gestartet werden, um einen neuen Seed Prozess zu starten.

Fortgeschrittene Option: Die Domains können auch manuell in der Datenbank geändert werden.

Überlegungen

Dieser Abschnitt listet einige Bereitstellungs und Sicherheitsüberlegungen auf.

Kubernetes Service Mesh
Es wird empfohlen, ein Kubernetes Service Mesh zu verwenden, um eine Zero Trust Architektur zu erreichen. Der interne Traffic wird mit mutual TLS (mTLS) und Verschlüsselung gesichert.

Interne PKI / root CA
Wenn interner Traffic durch einen Proxy oder Service Mesh mit einer internen root CA beendet und neu verschlüsselt wird, konfigurieren Sie die FoxIDs Container so, dass sie dieser CA vertrauen. Siehe Kubernetes interne CA.

Namespace
Diese Anleitung verwendet in der Regel den Namespace foxids, erwägen Sie, den Namespace an Ihre Kubernetes Umgebung anzupassen.

Namespace erstellen

kubectl create namespace test

Namespaces auflisten

kubectl get namespaces

Namespace bei Pod Erstellung anwenden

kubectl apply -f xxx.yaml --namespace=test

Log
Alle Logs von FoxIDs einschließlich Fehler, Trace und Events werden in stdout geschrieben. Überlegen Sie, wie Sie application logs handhaben und Logs aus den Containern sammeln.

Rate Limiting
Konfigurieren Sie Limits für Verbindungen und Übertragungsraten in k8s-foxids-ingress-deployment.yaml.

MongoDB Operator
Erwägen Sie MongoDB Operator, wenn Sie mehrere MongoDB Instanzen benötigen.

1. MongoDB Community Kubernetes Operator (kostenlos)
2. MongoDB Enterprise Kubernetes Operator

Redis mehrere Pods / Cluster
Erwägen Sie eine skalierte Redis Einrichtung, wenn Sie mehrere Redis Instanzen benötigen.

• Redis master/replica setup in Kubernetes
• Redis on Kubernetes
• Redis Enterprise cluster on Kubernetes und architecture

Backup
Erwägen Sie, ob MongoDB Daten gesichert werden müssen und auf welchem Niveau. Hier sind drei mögliche Lösungen. Es gilt als weniger wichtig, Redis zu sichern.

1. Sichern Sie den physischen Datenspeicher des persistent volume.
2. Backup mit einem Kubernetes Cron Job.
3. Backup wird im MongoDB Enterprise Kubernetes Operator unterstützt.

Update

FoxIDs wird aktualisiert, indem jedes FoxIDs Image auf eine neue Version aktualisiert wird, die beiden FoxIDs Images sind abwärtskompatibel. Aktualisieren Sie zuerst das foxids/foxids Image und dann das foxids/foxids-control Image.

Ebenso sollte es möglich sein, die MongoDB Images und Redis Images mit Daten in persistenten Volumes zu aktualisieren.

Nützliche Befehle

Dies ist eine Liste von Befehlen, die während der Bereitstellung nützlich sein können, um Details anzusehen und Änderungen an der Bereitstellung vorzunehmen.

Pod erstellen

kubectl apply -f ks8-xxx.yaml

Pod löschen

kubectl delete -f ks8-xxx.yaml

Pods auflisten

kubectl get pods

Pod Beschreibung abrufen

kubectl describe pod xxx

Pod Logs abrufen

kubectl logs xxx

Deployments auflisten

kubectl get deployments

Services auflisten

kubectl get services

Secrets auflisten

kubectl get secrets

Persistente Volumes auflisten

kubectl get pv

Persistente Volume Claims auflisten

kubectl get pvc

Ingress auflisten

kubectl get ingress

Ingress beschreiben

kubectl describe ingress xxx