Kubernetes

Wdróż FoxIDs w klastrze Kubernetes (K8s) lub w Docker Desktop z włączonym Kubernetes.

To opis sposobu wykonania domyślnego wdrożenia i pierwszego logowania, a także kilku zagadnień. Zakłada się, że będziesz musiał dostosować pliki yaml do swoich potrzeb, preferencji i środowiska.

Instalacja FoxIDs jest samodzielna, ma niewiele zewnętrznych zależności i może osiągnąć bardzo wysoką dostępność przy niewielkim wysiłku. FoxIDs aktualizuje się przez aktualizację dwóch obrazów Docker www.foxids.com/foxids:x.x.x i www.foxids.com/foxidscontrol:x.x.x na nową wersję. Nowe wydania FoxIDs są backward compatible. Przed aktualizacją sprawdź informacje o wydaniu. Znajdziesz tam również aktualną wersję obrazu Docker.

Do uzyskania dostępu do wydań FoxIDs wymagana jest ważna licencja. Stamtąd możesz wygenerować secret do uwierzytelniania w rejestrze obrazów Docker pod adresem www.foxids.com, który używa uwierzytelniania Basic.

Wymagania wstępne:

• Masz klaster Kubernetes lub Docker Desktop z włączonym Kubernetes.
• Masz podstawową wiedzę o Kubernetes.
• Masz zainstalowany kubectl.

Na końcu tego opisu znajduje się lista przydatnych poleceń.

To wdrożenie obejmuje:

• Dwie witryny: FoxIDs oraz FoxIDs Control (admin Client i API) w dwóch obrazach Docker www.foxids.com/foxids:x.x.x i www.foxids.com/foxidscontrol:x.x.x.
• Dwie witryny są wystawione na dwóch różnych domenach, zabezpieczone automatycznie generowanymi certyfikatami Let's Encrypt.
• MongoDB to baza NoSQL zawierająca wszystkie dane, w tym tenantów, środowiska i użytkowników. Wdrożona z oficjalnego obrazu MongoDB. Opcjonalnie możesz użyć własnej instancji PostgreSQL zamiast MongoDB.
• Domyślnie cache jest przechowywany w skonfigurowanej bazie danych. Redis jest potrzebny tylko wtedy, gdy uruchamiasz klaster FoxIDs o wysokiej przepustowości z PostgreSQL. MongoDB ma wbudowany cache, który działa dobrze, gdy instancja MongoDB ma wystarczająco dużo pamięci. Cache FoxIDs przechowuje sekwencje (np. logowanie i wylogowanie), liczniki do ochrony uwierzytelniania przed różnymi atakami oraz cache danych (tylko Redis) w celu poprawy wydajności. Redis jest wdrażany z oficjalnego obrazu Redis Docker.
• Logi są zapisywane do stdout, gdzie mogą być zbierane przez Kubernetes. Zaleca się użycie OpenSearch do logowania, chyba że instalacja FoxIDs jest mała. Dzięki OpenSearch błędy, eventy i trace można przeglądać bezpośrednio w FoxIDs Control Client oprócz logu Kubernetes, co znacznie ułatwia administrację systemem.

Wdrożenie

Wdrożenie jest wykonywane w opisanej kolejności.

Przygotowanie

Pobierz pliki konfiguracyjne Kubernetes yaml tutaj i umieść je w folderze na swoim komputerze, np. C:\FoxIDs\Kubernetes.

Otwórz konsolę i przejdź do folderu Kubernetes.

Wolumeny trwałe

Potrzebujesz wolumenów trwałych dla MongoDB, opcjonalnie OpenSearch i opcjonalnie Redis, jeśli używasz Redis z PostgreSQL dla klastra FoxIDs o wysokiej przepustowości.

W klastrze Kubernetes użyj lub utwórz odpowiednie wolumeny trwałe i utwórz persistent volume claim o nazwie mongo-data-pvc dla MongoDB oraz opcjonalnie jeden dla Redis o nazwie redis-data-pvc.

Możesz użyć dynamic storage provisioning z StorageClass.

Utwórz persistent volume claim dla Mongo

kubectl apply -f mongo-pvc-dynamic.yaml -n foxids

Opcjonalnie utwórz persistent volume claim dla Redis

kubectl apply -f redis-pvc-dynamic.yaml -n foxids

Opcjonalnie utwórz persistent volume claim dla OpenSearch

kubectl apply -f opensearch-pvc-dynamic.yaml -n foxids

Kubernetes w Docker Desktop

Jeśli używasz Kubernetes w Docker Desktop, możesz utworzyć wolumeny trwałe w systemie plików hosta — niezalecane dla produkcji.

Utwórz persistent volume dla MongoDB

kubectl apply -f mongo-pv-dockerdesktop.yaml

Utwórz persistent volume claim dla MongoDB

kubectl apply -f mongo-pvc-dockerdesktop.yaml -n foxids

Opcjonalnie utwórz persistent volume dla Redis

kubectl apply -f redis-pv-dockerdesktop.yaml

Opcjonalnie utwórz persistent volume claim dla Redis

kubectl apply -f redis-pvc-dockerdesktop.yaml -n foxids

Opcjonalnie utwórz persistent volume dla OpenSearch

kubectl apply -f opensearch-pv-dockerdesktop.yaml

Opcjonalnie utwórz persistent volume claim dla OpenSearch

kubectl apply -f opensearch-pvc-dockerdesktop.yaml -n foxids

Namespace

Ten przewodnik ogólnie używa namespace foxids, rozważ zmianę na lepszy dla Twojego środowiska Kubernetes.

Utwórz namespace

kubectl create namespace foxids

MongoDB

Zmień nazwę użytkownika i hasło dla MongoDB w mongo-secret.yaml. Nazwa użytkownika i hasło są zakodowane base64.

Zakoduj base64 „the text” w wierszu poleceń zależnie od platformy:

Windows

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

Linux / Mac

echo -n "the text" | base64

Dodaj sekret MongoDB

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

Utwórz MongoDB Opcjonalnie wystaw MongoDB na porcie 27017, odkomentowując LoadBalancer

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

Dodaj ConfigMap dla usługi MongoDB

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

Opcjonalnie użyj PostgreSQL zamiast MongoDB

Zmień wartości postgres-username i postgres-password w postgres-secret.yaml, aby pasowały do instancji PostgreSQL. Nazwa użytkownika i hasło są zakodowane base64.

Dodaj sekret PostgreSQL

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

Zmień endpoint bazy PostgreSQL w postgres-db, aby pasował do Twojej instancji w postgres-configmap.yaml

Dodaj ConfigMap dla usługi PostgreSQL

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

Opcjonalnie użyj Redis

Redis jest potrzebny tylko wtedy, gdy używasz PostgreSQL i uruchamiasz klaster FoxIDs o wysokiej przepustowości. Jeśli używasz MongoDB, wbudowany cache MongoDB działa dobrze, gdy instancja MongoDB ma wystarczająco dużo pamięci.

Opcjonalnie utwórz Redis

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

Opcjonalnie dodaj ConfigMap dla usługi Redis

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

Opcjonalnie użyj OpenSearch

OpenSearch jest zalecany do logowania, chyba że instalacja FoxIDs jest mała. Mała instalacja może działać tylko z logowaniem Stdout, gdzie Kubernetes zbiera logi. Dzięki OpenSearch błędy, eventy i trace można także wyszukiwać bezpośrednio w FoxIDs Control Client, co znacznie ułatwia administrację systemem.

Zmień hasło OpenSearch w opensearch-secret.yaml. Hasło jest zakodowane base64.

Dodaj secret OpenSearch

kubectl apply -f opensearch-secret.yaml -n foxids

Utwórz OpenSearch

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

Dodaj ConfigMap dla usługi OpenSearch

kubectl apply -f opensearch-configmap.yaml -n foxids

Witryny FoxIDs

Domeny Dwie witryny FoxIDs są skonfigurowane do używania dwóch domen, które tworzysz i zarządzasz nimi w DNS. Skonfiguruj plik foxids-deployment.yaml z wybranymi domenami:

• Domena witryny FoxIDs https://id.itfoxtec.com (dwa miejsca w pliku) jest zmieniona na Twoją domenę — id.my-domain.com
• Domena witryny FoxIDs Control https://control.itfoxtec.com jest zmieniona na Twoją domenę — control.my-domain.com

Dostawca e-mail Możesz opcjonalnie skonfigurować globalnego dostawcę e-maili lub później skonfigurować dostawców e-maili dla każdego środowiska. FoxIDs obsługuje wysyłanie e-maili przez SendGrid i SMTP.

Globalny dostawca e-maili jest konfigurowany w pliku foxids-deployment.yaml na kontenerze/podzie foxids w sekcji env:. Przykład dodania Outlook / Microsoft 365 przez SMTP:

- name: "Settings__Smtp__FromEmail"
    value: "my@email-address.org"
- name: "Settings__Smtp__FromName" # Opcjonalna nazwa nadawcy powiązana z adresem e-mail
    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"

Ważne, jeśli używasz PostgreSQL Zmień konfigurację bazy danych i cache w foxids-deployment.yaml (dwa miejsca w pliku).

Wybierz PostgreSQL jako bazę danych zamiast MongoDb

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

Wybierz PostgreSQL jako cache zamiast MongoDb, chyba że używasz Redis

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

Odkomentuj konfigurację dostępu do PostgreSQL

- 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"

Ważne, jeśli używasz Redis Zmień konfigurację cache w foxids-deployment.yaml (dwa miejsca w pliku).

Wybierz Redis jako cache zamiast MongoDb

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

Opcjonalnie cache'uj dane bazy danych w Redis

- name: "Settings__Options__DataCache"
   # value: "None"
   value: "Default"  # Cache danych DB w Redis

Odkomentuj konfigurację dostępu do Redis

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

Ważne, jeśli używasz OpenSearch Zmień konfigurację logów w foxids-deployment.yaml (dwa miejsca w pliku).

Wybierz OpenSearch logging zamiast Stdout

- name: "Settings__Options__Log"
   # value: "Stdout"
   value: "OpenSearchAndStdoutErrors"

Odkomentuj konfigurację dostępu do OpenSearch

- name: OPENSEARCH_PASSWORD
    valueFrom:
    secretKeyRef:
        name: opensearch-secret
        key: opensearch-password
- name: OPENSEARCH_SERVER
    valueFrom:
    configMapKeyRef:
        name: opensearch-configmap
        key: opensearch_url
- name: "Settings__OpenSearch__Nodes__0"
    value: "https://admin:$(OPENSEARCH_PASSWORD)@$(OPENSEARCH_SERVER):9200"
- name: "Settings__OpenSearch__LogLifetime"
    value: "Max180Days"
- name: "Settings__OpenSearch__AllowInsecureCertificates"
    value: "true"

OpenSearchAndStdoutErrors wysyła logi do OpenSearch i zapisuje błędy do stdout, więc Kubernetes nadal otrzymuje logi błędów. AllowInsecureCertificates jest ustawione na true, ponieważ domyślny kontener OpenSearch używa certyfikatu self-signed.

Wdrożenie Ustaw nazwę użytkownika na identyfikator klienta, a hasło na pull secret dla rejestru Docker FoxIDs. Następnie utwórz registry secret.

kubectl create secret docker-registry foxids-registry-secret --docker-server=www.foxids.com --docker-username=<customer-id> --docker-password=<pull-secret> -n foxids

Utwórz dwie witryny FoxIDs

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

Ta konfiguracja wymaga kontrolera Nginx. Opcjonalnie możesz zmienić konfigurację na inny kontroler.

Wymagania wstępne:

• Masz zainstalowany Helm. Zainstaluj Helm na Windows poleceniem CMD winget install Helm.Helm

Zainstaluj kontroler Ingress-Nginx w dwóch poleceniach

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

Opcjonalnie zweryfikuj instalację Ingress-Nginx

kubectl get pod -n ingress-nginx

Po kilku minutach powinieneś otrzymać EXTERNAL-IP

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

Rekordy DNS dla dwóch domen muszą wskazywać adres IP instalacji, aby umożliwić walidację online Let's Encrypt. Zapora musi akceptować żądania na portach 80 i 443. Let's Encrypt weryfikuje własność domeny na porcie 80.

Opcjonalnie skaluj kontroler Ingress-Nginx

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

Zainstaluj Cert-manager w dwóch poleceniach

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

Opcjonalnie zweryfikuj instalację Cert-manager

kubectl get pods -n cert-manager

Dodaj swój e-mail w pliku letsencrypt-issuer.yaml (w dwóch miejscach).

Skonfiguruj Let's Encrypt

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

Plik foxids-ingress-deployment.yaml jest skonfigurowany z domenami:

• Domena witryny FoxIDs id.itfoxtec.com (dwa miejsca w pliku) jest zmieniona na Twoją domenę — id.my-domain.com
• Domena witryny FoxIDs Control control.itfoxtec.com (dwa miejsca w pliku) jest zmieniona na Twoją domenę — control.my-domain.com

Rozważ rozpoczęcie od Let's Encrypt w trybie staging, aby uniknąć limitów produkcyjnych (certyfikaty staging nie są zaufane przez przeglądarkę). Opcjonalnie wybierz staging lub production w pliku foxids-ingress-deployment.yaml, domyślnie skonfigurowane na production.

Dodaj ingress z domenami powiązanymi z certyfikatem

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

Ważne! Ingress jest zainstalowany z adnotacjami nginx.ingress.kubernetes.io/proxy-buffers-number: "4" i nginx.ingress.kubernetes.io/proxy-buffer-size: "32k" aby wspierać SAML 2.0, gdzie odpowiedzi HTTP mogą być dość duże.

Opcjonalnie zweryfikuj Ingress

kubectl get ingress -n foxids

Opcjonalnie zweryfikuj issuer certyfikatu

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

Opcjonalnie sprawdź, czy certyfikat jest gotowy (READY powinno być True)

kubectl get certificate -n foxids

I opcjonalnie zweryfikuj certyfikat

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

Pierwsze logowanie

Otwórz domenę witryny FoxIDs Control w przeglądarce. Powinna przekierować do witryny FoxIDs, gdzie zalogujesz się domyślnym użytkownikiem admin admin@foxids.com i hasłem FirstAccess! (podczas pierwszego logowania musisz zmienić hasło). Następnie zostaniesz przekierowany z powrotem do witryny FoxIDs Control w tenancie master. Możesz dodać więcej adminów w tenancie master.

Następnie kliknij tenant main i uwierzytelnij się ponownie tym samym domyślnym użytkownikiem admin admin@foxids.com i hasłem FirstAccess! (ponownie wymagane jest ustawienie nowego hasła).

Domyślny użytkownik admin i hasło są takie same dla tenanta master i tenanta main, ale to dwaj różni użytkownicy.

Jesteś teraz zalogowany w tenancie main i możesz rozpocząć konfigurację aplikacji i metod uwierzytelniania.

Seed data

Baza danych jest automatycznie zasiewana na podstawie skonfigurowanych domen. Dlatego, jeśli domeny zostaną zmienione, musisz usunąć bazę danych. Aby usunąć dane: możesz zatrzymać pod bazy danych i usunąć fizyczny folder lub pliki bazy. Albo wystawić endpoint bazy danych i otworzyć bazę w MongoDB Compass (download MongoDB Compass Download (GUI)) i usunąć bazę danych. Następnie pod FoxIDs Control musi zostać zrestartowany, aby zainicjować nowy proces seedowania.

Opcja zaawansowana: domeny można również ręcznie zmienić w bazie danych.

Zagadnienia

Ta sekcja zawiera kilka zagadnień dotyczących wdrożenia i bezpieczeństwa.

Kubernetes Service Mesh Zaleca się użycie Kubernetes Service Mesh, aby osiągnąć architekturę zero trust, w której ruch wewnętrzny jest zabezpieczony wzajemnym TLS (mTLS) i szyfrowaniem.

Wewnętrzny PKI / root CA Jeśli ruch wewnętrzny jest terminowany i ponownie szyfrowany przez proxy lub service mesh z wewnętrznym root CA, skonfiguruj kontenery FoxIDs, aby ufały temu CA. Zobacz Kubernetes internal CA.

Namespace Ten przewodnik ogólnie używa namespace foxids, rozważ zmianę na lepszy dla Twojego środowiska Kubernetes.

Utwórz namespace

kubectl create namespace test

Wyświetl namespace

kubectl get namespaces

Zastosuj namespace przy tworzeniu poda

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

Logi Wszystkie logi z FoxIDs, w tym błędy, śledzenie i zdarzenia, są zapisywane do stdout. Zastanów się, jak obsłużyć logi aplikacji i zbierać logi z kontenerów.

Rate Limiting Skonfiguruj limity połączeń i przepustowości w foxids-ingress-deployment.yaml.

MongoDB Operator Rozważ MongoDB Operator, jeśli potrzebujesz wielu instancji MongoDB.

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

Redis wiele podów / klaster Rozważ skalowany setup Redis, jeśli potrzebujesz wielu instancji Redis.

• Redis master/replica setup w Kubernetes
• Redis w Kubernetes
• Redis Enterprise cluster w Kubernetes i architektura

Backup Rozważ, czy dane MongoDB powinny być backupowane i na jakim poziomie; poniżej trzy możliwe rozwiązania. Za mniej istotne uznaje się backupowanie Redis.

1. Backup fizycznego magazynu danych wolumenu trwałego.
2. Backup z Kubernetes Cron Job.
3. Backup jest obsługiwany w MongoDB Enterprise Kubernetes Operator.

Aktualizacja

FoxIDs aktualizuje si? przez zmian? tag?w wersji obraz?w w foxids-deployment.yaml dla obu kontener?w FoxIDs:

image: www.foxids.com/foxids:x.x.x
image: www.foxids.com/foxidscontrol:x.x.x

Przed aktualizacj? sprawd? informacje o wydaniu. Informacje o wydaniu zawieraj? tak?e bie??c? wersj? obrazu Docker. Nowe wydania FoxIDs s? wstecznie kompatybilne.

Zastosuj zaktualizowany plik deploymentu:

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

Kubernetes wdro?y nast?pnie oba deploymenty z nowymi wersjami obraz?w.

Powinno by? r?wnie? mo?liwe zaktualizowanie obraz?w MongoDB, Redis i OpenSearch z danymi w wolumenach trwa?ych.

Przydatne polecenia

To lista poleceń, które mogą być przydatne podczas wdrożenia do podglądu szczegółów i wprowadzania zmian.

Utwórz pod

kubectl apply -f xxx.yaml

Usuń pod

kubectl delete -f xxx.yaml

Lista podów

kubectl get pods

Opis poda

kubectl describe pod xxx

Logi poda

kubectl logs xxx

Lista wdrożeń

kubectl get deployments

Lista usług

kubectl get services

Lista sekretów

kubectl get secrets

Lista persistent volumes

kubectl get pv

Lista persistent volume claims

kubectl get pvc

Lista ingress

kubectl get ingress

Opis ingress

kubectl describe ingress xxx