Kubernetes

Deploy FoxIDs i din Kubernetes (K8s) kluster eller Docker Desktop med Kubernetes aktiverat.

Detta är en beskrivning av hur du gör en standard deployment och loggar in för första gången samt några överväganden. Det förväntas att du behöver anpassa yaml filerna efter dina behov, preferenser och miljö.

En FoxIDs installation är som en bucket, det finns inga externa dependencies och det är enkelt att uppnå mycket hög upptid med liten insats. FoxIDs uppdateras genom att uppdatera de två docker images www.foxids.com/foxids:x.x.x och www.foxids.com/foxidscontrol:x.x.x till en ny version. Nya FoxIDs releases är backward compatible. Granska release notes innan du uppdaterar. Där hittar du även den aktuella Docker image versionen.

En giltig licens krävs för att få tillgång till FoxIDs releases. Där kan du generera en secret för att autentisera mot Docker image registret på www.foxids.com, som använder Basic authentication.

Förutsättningar:

  • Du har ett Kubernetes kluster eller Docker Desktop med Kubernetes aktiverat.
  • Du har grundläggande kunskap om Kubernetes.
  • Du har kubectl installerat.

Detta är en lista med nyttiga kommandon i slutet av denna beskrivning.

Denna deployment inkluderar:

  • Två webbplatser en för FoxIDs och en för FoxIDs Control (admin Client och API) i två docker images www.foxids.com/foxids:x.x.x och www.foxids.com/foxidscontrol:x.x.x.
  • De två webbplatserna exponeras på två olika domäner säkrade med automatiskt genererade Let's Encrypt certifikat.
  • MongoDB är en NoSQL databas och innehåller all data inklusive tenants, miljöer och användare. Deployad med det officiella MongoDB Docker image. Du kan valfritt använda din egen PostgreSQL instance istället för MongoDB.
  • Standard lagrar cache i databasen. Använd valfritt en Redis cache om du installerar ett FoxIDs kluster med hög throughput. Cachen håller sekvenser (t.ex. login och logout) och hanterar räknare för att säkra autentisering mot olika attacker och data cache (endast Redis) för att förbättra performance. Redis deployas med det officiella Redis Docker image.
  • Loggar skrivs till stdout där Kubernetes kan plocka upp dem.

Deployment

Deploymenten utförs i den beskrivna ordningen.

Förbered

Ladda ner Kubernetes yaml konfigurationsfiler här och placera dem i en mapp på din dator, t.ex. C:\FoxIDs\Kubernetes.

Öppna en konsol och navigera till mappen Kubernetes.

Persistenta volumes

Du behöver persistenta volumes för MongoDB och valfritt Redis.

I ett Kubernetes kluster använd eller skapa lämpliga persistenta volumes och skapa en persistent volume claim med namnet mongo-data-pvc för MongoDB och valfritt en för Redis med namnet redis-data-pvc.

Du kan eventuellt använda dynamisk storage provisioning med StorageClass.

Skapa persistent volume claim för Mongo

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

Skapa valfritt persistent volume claim för Redis

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

Kubernetes i Docker Desktop

Om du använder Kubernetes i Docker Desktop kan du skapa persistenta volumes på host file systemet - inte rekommenderat för produktion.

Skapa persistent volume för MongoDB

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

Skapa persistent volume claim för MongoDB

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

Skapa valfritt persistent volume för Redis

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

Skapa valfritt persistent volume claim för Redis

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

Namespace

Denna guide använder vanligtvis namespace foxids, överväg att ändra namespace så att det passar din Kubernetes miljö.

Skapa namespace

kubectl create namespace foxids

MongoDB

Ändra användarnamn och lösenord för MongoDB i k8s-mongo-secret.yaml. Användarnamn och lösenord är base64 kodade.

Du base64 kodar "texten" i en command prompt beroende på din plattform:

Windows

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

Linux / Mac

echo -n "the text" | base64

Lägg till MongoDB secret

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

Skapa MongoDB
Exponera valfritt MongoDB på port 27017 genom att uncomment LoadBalancer

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

Lägg till en ConfigMap för MongoDB service

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

Använd valfritt PostgreSQL istället för MongoDB

Ändra användarnamn värdet i postgres-username och lösenord värdet i postgres-password så de matchar din PostgreSQL instance i k8s-postgres-secret.yaml. Användarnamn och lösenord är base64 kodade.

Lägg till PostgreSQL secret

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

Ändra PostgreSQL database endpoint i postgres-db så det matchar din PostgreSQL instance i k8s-postgres-configmap.yaml

Lägg till en ConfigMap för PostgreSQL service

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

Använd valfritt Redis

Skapa valfritt Redis

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

Lägg till valfritt en ConfigMap för Redis service

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

FoxIDs webbplatser

Domäner
De två FoxIDs webbplatserna är konfigurerade att använda två domäner som du skapar och hanterar i din DNS. Konfigurera k8s-foxids-deployment.yaml filen med dina valda domäner:

  • FoxIDs site domänen https://id.itfoxtec.com (två ställen i filen) ändras till din domän - id.my-domain.com
  • FoxIDs Control site domänen https://control.itfoxtec.com ändras till din domän - control.my-domain.com

Email provider
Du kan valfritt konfigurera en global email provider eller senare konfigurera email providers per miljö. FoxIDs stödjer att skicka e-post med SendGrid och SMTP.

Den globala email providern konfigureras i k8s-foxids-deployment.yaml filen på foxids container/pod i env: sektionen.
Detta exempel visar hur du lägger till Outlook / Microsoft 365 med SMTP:

- name: "Settings__Smtp__FromEmail"
    value: "my@email-address.org"
- name: "Settings__Smtp__FromName" # Valfritt avsändarnamn kopplat till e-postadressen 
    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"

Viktigt om du använder PostgreSQL
Ändra databasen och cache konfigurationen i k8s-foxids-deployment.yaml (två ställen i filen).

Välj PostgreSQL som databas istället för MongoDb

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

Välj PostgreSQL som cache istället för MongoDb om du inte använder Redis

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

Uncomment PostgreSQL access konfigurationen

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

Viktigt om du använder Redis
Ändra cache konfigurationen i k8s-foxids-deployment.yaml (två ställen i filen).

Välj Redis som cache istället för MongoDb

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

Uncomment Redis access konfigurationen

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

Deploy
Ange användarnamnet som ditt kund-ID och lösenordet som din pull secret för FoxIDs Docker registret. Skapa sedan 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

Skapa de två FoxIDs webbplatserna

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

Konfigurationen kräver en Nginx controller. Du kan valfritt ändra konfigurationen för att använda en annan controller.

Förutsättningar:

  • Du har Helm installerat.
    Installera Helm på Windows med detta CMD kommando winget install Helm.Helm

Installera Ingress-Nginx controller med två kommandon

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

Valfritt verifiera Ingress-Nginx installation

kubectl get pod -n ingress-nginx

Om du försöker igen efter några minuter ska du få en EXTERNAL-IP

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

DNS records till de två domänerna måste peka på installationens IP adress för att möjliggöra Let's Encrypt online validering.
Brandväggen måste acceptera requests på port 80 och 443. Let's Encrypt validerar domänägarskap på port 80.

Valfritt skala Ingress-Nginx controller

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

Installera Cert-manager med två kommandon

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

Valfritt verifiera Cert-manager installation

kubectl get pods -n cert-manager

Lägg till din e-post i k8s-letsencrypt-issuer.yaml (två ställen) filen.

Konfigurera Let's Encrypt

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

k8s-foxids-ingress-deployment.yaml filen är konfigurerad med domänerna:

  • FoxIDs site domänen id.itfoxtec.com (två ställen i filen) ändras till din domän - id.my-domain.com
  • FoxIDs Control site domänen control.itfoxtec.com (två ställen i filen) ändras till din domän - control.my-domain.com

Överväg att börja med Let's Encrypt i staging för att undvika att träffa Let's Encrypt production rate limit (staging certifikat är inte betrodda av webbläsaren).
Du kan valfritt välja staging eller production i k8s-foxids-ingress-deployment.yaml filen, standard är production.

Lägg till ingress med certificate bound domäner

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

Viktigt! Ingress är installerad med annoteringarna nginx.ingress.kubernetes.io/proxy-buffers-number: "4" och nginx.ingress.kubernetes.io/proxy-buffer-size: "32k" för att stödja SAML 2.0 där HTTP svar kan vara ganska stora.

Valfritt verifiera Ingress

kubectl get ingress -n foxids

Valfritt verifiera certificate issuer

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

Valfritt kontrollera om certifikatet är redo (READY ska vara True)

kubectl get certificate -n foxids

Och valfritt verifiera certifikatet

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

Första login

Öppna din FoxIDs Control site domän i en browser. Den ska omdirigera till FoxIDs site där du loggar in med standard admin användaren admin@foxids.com och lösenordet FirstAccess! (du måste byta lösenord vid första login).
Du omdirigeras sedan tillbaka till FoxIDs Control site i master tenant. Du kan lägga till fler admin användare i master tenant.

Klicka sedan på main tenant och autentisera igen med samma standard admin användare admin@foxids.com och lösenordet FirstAccess! (igen, du måste byta lösenord).

Standard admin användare och lösenord är samma för både master tenant och main tenant, men det är två olika användare.

Du är nu inloggad på main tenant och kan börja konfigurera dina applikationer och autentiseringsmetoder.

Seed data

Databasen seedas automatiskt baserat på de konfigurerade domänerna. Därför behöver du radera databasen om domänerna ändras.
För att radera data; du kan antingen stoppa database pod och radera den fysiska databas mappen eller filer. Eller exponera database endpointet och öppna databasen i MongoDB Compass (download MongoDB Compass Download (GUI)) och radera databasen.
Därefter måste FoxIDs Control pod startas om för att initiera en ny seed process.

Avancerat alternativ: domänerna kan också ändras manuellt i databasen.

Överväganden

Denna sektion listar vissa deployment och säkerhetsöverväganden.

Kubernetes Service Mesh
Det rekommenderas att använda ett Kubernetes Service Mesh för att uppnå en zero-trust arkitektur, där intern trafik är säkrad med mutual TLS (mTLS) och kryptering.

Intern PKI / root CA
Om intern trafik termineras och krypteras om av en proxy eller service mesh med en intern root CA, konfigurera FoxIDs containrar att lita på den CA. Se Kubernetes internal CA.

Namespace
Denna guide använder vanligtvis namespace foxids, överväg att ändra namespace för att passa din Kubernetes miljö.

Skapa namespace

kubectl create namespace test

Lista namespaces

kubectl get namespaces

Tillämpa namespace vid pod skapande

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

Log
Alla loggar från FoxIDs inklusive fel, trace och events skrivs till stdout. Överväg hur du hanterar application logs och samlar loggar från containrarna.

Rate Limiting
Konfigurera begränsningar på anslutningar och transmissionshastigheter i k8s-foxids-ingress-deployment.yaml.

MongoDB Operator
Överväg MongoDB Operator om du behöver flera instanser av MongoDB.

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

Redis multiple pods / cluster
Överväg en skalerad Redis setup om du behöver flera instanser av Redis.

Backup
Överväg om MongoDB data behöver backup och på vilken nivå, här är tre möjliga lösningar. Det anses mindre viktigt att backup av Redis.

  1. Backup den fysiska data store för det persistenta volume.
  2. Backup med en Kubernetes Cron Job.
  3. Backup stöds i MongoDB Enterprise Kubernetes Operator.

Update

FoxIDs uppdateras genom att uppdatera varje FoxIDs image till en ny version, de två FoxIDs images är backwards compatible. Uppdatera först foxids/foxids image och sedan foxids/foxids-control image.

Det bör även vara möjligt att uppdatera MongoDB image och Redis images med data i persistenta volumes.

Nyttiga kommandon

Detta är en lista med kommandon som kan vara användbara under deployment för att se detaljer och göra deployment ändringar.

Skapa pod

kubectl apply -f ks8-xxx.yaml

Ta bort pod

kubectl delete -f ks8-xxx.yaml

Lista pods

kubectl get pods

Hämta pod beskrivning

kubectl describe pod xxx

Hämta pod logs

kubectl logs xxx

Lista deployments

kubectl get deployments

Lista services

kubectl get services

Lista secrets

kubectl get secrets

Lista persistenta volumes

kubectl get pv

Lista persistenta volume claims

kubectl get pvc

Lista ingress

kubectl get ingress

Beskriv ingress

kubectl describe ingress xxx

Din integritet

Vi använder cookies för att göra din upplevelse av våra webbplatser bättre. Klicka på 'Acceptera alla cookies' för att godkänna användningen av cookies. För att avstå från icke-nödvändiga cookies, klicka på 'Endast nödvändiga cookies'.

Besök vår integritetspolicy för mer