Kubernetes

Distribuer FoxIDs i Kubernetes (K8s) klusteret ditt eller Docker Desktop med Kubernetes aktivert.

Dette er en beskrivelse av hvordan du gjør en standard distribusjon og logger inn for første gang samt noen betraktninger. Det forventes at du må tilpasse yaml filene til dine behov, preferanser og miljø.

En FoxIDs installasjon er som en bøtte, det finnes ingen eksterne avhengigheter og det er enkelt å oppnå svært høy oppetid med liten innsats. FoxIDs oppdateres ved å oppdatere de to docker image www.foxids.com/foxids:x.x.x og www.foxids.com/foxidscontrol:x.x.x til en ny versjon. Nye FoxIDs utgivelser er backward compatible. Se release notes før oppdatering. Du finner også gjeldende Docker image versjon der.

En gyldig lisens kreves for å få tilgang til FoxIDs utgivelser. Derfra kan du generere en secret for å autentisere mot Docker image registeret på www.foxids.com, som bruker Basic authentication.

Forutsetninger:

  • Du har et Kubernetes kluster eller Docker Desktop med Kubernetes aktivert.
  • Du har grunnleggende kunnskap om Kubernetes.
  • Du har kubectl installert.

Dette er en liste med nyttige kommandoer på slutten av denne beskrivelsen.

Denne distribusjonen inkluderer:

  • To nettsteder, ett for FoxIDs og ett for FoxIDs Control (admin Client og API) i to docker image www.foxids.com/foxids:x.x.x og www.foxids.com/foxidscontrol:x.x.x.
  • De to nettstedene eksponeres på to forskjellige domener sikret med automatisk genererte Let's Encrypt sertifikater.
  • MongoDB er en NoSQL database og inneholder alle data inkludert tenants, miljøer og brukere. Distribuert med den offisielle MongoDB Docker image. Du kan valgfritt bruke din egen PostgreSQL instans i stedet for MongoDB.
  • Som standard holdes cachen i databasen. Valgfritt bruk en Redis cache hvis du installerer et FoxIDs kluster med høy gjennomstrømming. Cachen holder sekvenser (f.eks. innlogging og utlogging) og håndterer tellere for å sikre autentisering mot ulike angrep og datacache (kun Redis) for å forbedre ytelsen. Redis distribueres med den offisielle Redis Docker image.
  • Logger skrives til stdout der loggene kan plukkes opp av Kubernetes.

Distribusjon

Distribusjonen utføres i den beskrevne rekkefølgen.

Gjør klar

Last ned Kubernetes yaml konfigurasjonsfiler her og plasser dem i en mappe på maskinen din, for eksempel C:\FoxIDs\Kubernetes.

Åpne en konsoll og naviger til mappen Kubernetes.

Persistente volumer

Du trenger persistente volumer for MongoDB og eventuelt Redis.

I et Kubernetes kluster bruk eller opprett passende persistente volumer og opprett en persistent volume claim med navnet mongo-data-pvc for MongoDB og eventuelt en for Redis med navnet redis-data-pvc.

Du kan bruke dynamisk lagringsprovisjonering med StorageClass.

Opprett persistent volume claim for Mongo

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

Valgfritt opprett persistent volume claim for Redis

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

Kubernetes i Docker Desktop

Hvis du bruker Kubernetes i Docker Desktop kan du opprette persistente volumer på vertens filsystem - ikke anbefalt for produksjon.

Opprett persistent volume for MongoDB

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

Opprett persistent volume claim for MongoDB

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

Valgfritt opprett persistent volume for Redis

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

Valgfritt opprett persistent volume claim for Redis

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

Namespace

Denne veiledningen bruker vanligvis namespace foxids, vurder å endre namespace for å passe Kubernetes miljøet ditt.

Opprett namespace

kubectl create namespace foxids

MongoDB

Endre brukernavn og passord for MongoDB i k8s-mongo-secret.yaml. Brukernavn og passord er base64 kodet.

Du base64 koder "the text" i en kommandolinje avhengig av plattform:

Windows

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

Linux / Mac

echo -n "the text" | base64

Legg til MongoDB secret

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

Opprett MongoDB
Valgfritt eksponer MongoDB på port 27017 ved å fjerne kommentar på LoadBalancer

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

Legg til en ConfigMap for MongoDB tjenesten

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

Valgfritt bruk PostgreSQL i stedet for MongoDB

Endre brukernavn i postgres-username og passord i postgres-password for å matche PostgreSQL instansen din i k8s-postgres-secret.yaml. Brukernavn og passord er base64 kodet.

Legg til PostgreSQL secret

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

Endre PostgreSQL database endepunktet i postgres-db slik at det matcher PostgreSQL instansen din i k8s-postgres-configmap.yaml

Legg til en ConfigMap for PostgreSQL tjenesten

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

Valgfritt bruk Redis

Valgfritt opprett Redis

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

Valgfritt legg til en ConfigMap for Redis tjenesten

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

FoxIDs nettsteder

Domener
De to FoxIDs nettstedene er konfigurert til å bruke to domener som du oppretter og administrerer i DNS. Konfigurer k8s-foxids-deployment.yaml filen med dine valgte domener:

  • FoxIDs nettstedets domene https://id.itfoxtec.com (to steder i filen) endres til ditt domene - id.my-domain.com
  • FoxIDs Control nettstedets domene https://control.itfoxtec.com endres til ditt domene - control.my-domain.com

E-postleverandør
Du kan valgfritt konfigurere en global e-postleverandør eller senere konfigurere e-postleverandører per miljø. FoxIDs støtter sending av e-post med SendGrid og SMTP.

Den globale e-postleverandøren konfigureres i k8s-foxids-deployment.yaml filen på foxids container/pod i env: seksjonen.
Dette eksempelet viser hvordan du legger til Outlook / Microsoft 365 med SMTP:

- name: "Settings__Smtp__FromEmail"
    value: "my@email-address.org"
- name: "Settings__Smtp__FromName" # Valgfritt avsendernavn tilknyttet 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"

Viktig hvis du bruker PostgreSQL
Endre database og cache konfigurasjonen i k8s-foxids-deployment.yaml (to steder i filen).

Velg PostgreSQL som database i stedet for MongoDb

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

Velg PostgreSQL som cache i stedet for MongoDb med mindre du bruker Redis

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

Fjern kommentar på PostgreSQL tilgangskonfigurasjonen

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

Viktig hvis du bruker Redis
Endre cache konfigurasjonen i k8s-foxids-deployment.yaml (to steder i filen).

Velg Redis som cache i stedet for MongoDb

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

Fjern kommentar på Redis tilgangskonfigurasjonen

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

Distribuer
Sett brukernavnet til kunde-ID-en din og passordet til pull secreten din for FoxIDs Docker registeret. Opprett deretter 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

Opprett de to FoxIDs nettstedene

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

Konfigurasjonen krever en Nginx controller. Du kan valgfritt endre konfigurasjonen til å bruke en annen controller.

Forutsetninger:

  • Du har Helm installert.
    Installer Helm på windows med denne CMD kommandoen winget install Helm.Helm

Installer Ingress-Nginx controller med to kommandoer

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

Valgfritt verifiser Ingress-Nginx installasjon

kubectl get pod -n ingress-nginx

Hvis du prøver igjen om noen minutter skal du få en EXTERNAL-IP

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

DNS oppføringer for de to domenene må peke til installasjonens IP adresse for å aktivere Let's Encrypt online validering.
Brannmuren må akseptere forespørsler på port 80 og 443. Let's encrypt validerer domeneeierskap på port 80.

Valgfritt skaler Ingress-Nginx controller

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

Installer Cert-manager med to kommandoer

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

Valgfritt verifiser Cert-manager installasjon

kubectl get pods -n cert-manager

Legg til e-posten din i k8s-letsencrypt-issuer.yaml (to steder) filen.

Konfigurer Let's Encrypt

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

k8s-foxids-ingress-deployment.yaml filen er konfigurert med domenene:

  • FoxIDs nettstedets domene id.itfoxtec.com (to steder i filen) endres til ditt domene - id.my-domain.com
  • FoxIDs Control nettstedets domene control.itfoxtec.com (to steder i filen) endres til ditt domene - control.my-domain.com

Vurder å starte med Let's Encrypt i staging for å unngå å treffe Let's Encrypt produksjons rate limit (staging sertifikater er ikke betrodd av nettleseren).
Velg eventuelt å bruke staging eller produksjon i k8s-foxids-ingress-deployment.yaml filen, standard konfigurert for produksjon.

Legg til ingress med sertifikat bundne domener

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

Viktig! Ingress er installert med annotasjonene nginx.ingress.kubernetes.io/proxy-buffers-number: "4" og nginx.ingress.kubernetes.io/proxy-buffer-size: "32k" for å støtte SAML 2.0 der HTTP responser kan være ganske store.

Valgfritt verifiser Ingress

kubectl get ingress -n foxids

Valgfritt verifiser certificate issuer

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

Valgfritt sjekk om sertifikatet er klart (READY skal være True)

kubectl get certificate -n foxids

Og valgfritt verifiser sertifikatet

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

Første innlogging

Åpne FoxIDs Control nettstedets domene i en nettleser. Det bør omdirigere til FoxIDs nettstedet der du logger inn med standard admin bruker admin@foxids.com og passord FirstAccess! (du må endre passord ved første innlogging).
Du blir deretter omdirigert tilbake til FoxIDs Control nettstedet i master tenant. Du kan legge til flere admin brukere i master tenant.

Klikk deretter på main tenant og autentiser igjen med samme standard admin bruker admin@foxids.com og passord FirstAccess! (igjen, du må endre passordet).

Standard admin bruker og passord er det samme for både master tenant og main tenant, men det er to forskjellige brukere.

Du er nå logget inn i main tenant og kan begynne å konfigurere applikasjoner og autentiseringsmetoder.

Seed data

Databasen seedes automatisk basert på de konfigurerte domenene. Derfor må du slette databasen hvis domenene endres.
For å slette dataene; du kan enten stoppe database podden og slette den fysiske database mappen eller filene. Eller eksponere database endepunktet og åpne databasen i MongoDB Compress (last ned MongoDB Compass (GUI)) og slette databasen.
Deretter må FoxIDs Control podden restartes for å initiere en ny seed prosess.

Avansert alternativ: Domenene kan også endres manuelt i databasen.

Betraktninger

Denne seksjonen lister noen distribusjons og sikkerhetsbetraktninger.

Kubernetes Service Mesh
Det anbefales å bruke en Kubernetes Service Mesh for å oppnå en zero-trust arkitektur. Der intern trafikk sikres med mutual TLS (mTLS) og kryptering.

Intern PKI / rot CA
Hvis intern trafikk termineres og krypteres på nytt av en proxy eller service mesh med en intern rot CA, konfigurer FoxIDs containerne til å stole på den CAen. Se Kubernetes intern CA.

Namespace
Denne veiledningen bruker vanligvis namespace foxids, vurder å endre namespace for å passe Kubernetes miljøet ditt.

Opprett namespace

kubectl create namespace test

List namespaces

kubectl get namespaces

Bruk namespace ved pod opprettelse

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

Logg
Alle logger fra FoxIDs inkludert feil, trace og hendelser skrives til stdout. Vurder hvordan du håndterer applikasjonslogger og samler logger fra containerne.

Rate Limiting
Konfigurer begrensninger på tilkoblinger og overføringshastigheter i k8s-foxids-ingress-deployment.yaml.

MongoDB Operator
Vurder MongoDB Operator hvis du trenger flere instanser av MongoDB.

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

Redis flere pods / kluster
Vurder en skalert Redis oppsett hvis du trenger flere instanser av Redis.

Backup
Vurder om MongoDB data må sikkerhetskopieres og på hvilket nivå, her er tre mulige løsninger. Det anses som mindre viktig å sikkerhetskopiere Redis.

  1. Sikkerhetskopier persistent volume fysiske datalager.
  2. Backup med en Kubernetes Cron Job.
  3. Backup støttes i MongoDB Enterprise Kubernetes Operator.

Oppdatering

FoxIDs oppdateres ved å oppdatere hvert FoxIDs image til en ny versjon, de to FoxIDs image er bakoverkompatible. Oppdater først foxids/foxids image og deretter foxids/foxids-control image.

Det bør også være mulig å oppdatere MongoDB image og Redis image med data i persistente volumer.

Nyttige kommandoer

Dette er en liste med kommandoer som kan være nyttige under distribusjon for å se detaljer og gjøre endringer i distribusjonen.

Opprett pod

kubectl apply -f ks8-xxx.yaml

Steng pod

kubectl delete -f ks8-xxx.yaml

List pods

kubectl get pods

Hent pod beskrivelse

kubectl describe pod xxx

Hent pod logger

kubectl logs xxx

List deployments

kubectl get deployments

List services

kubectl get services

List secrets

kubectl get secrets

List persistent volumes

kubectl get pv

List persistent volume claims

kubectl get pvc

List ingress

kubectl get ingress

Beskriv ingress

kubectl describe ingress xxx

Ditt personvern

Vi bruker cookies for å gjøre opplevelsen av nettstedene våre bedre. Klikk på 'Godta alle cookies' for å samtykke til bruk av cookies. For å reservere deg mot ikke-nødvendige cookies, klikk på 'Kun nødvendige cookies'.

Besøk vår personvernerklæring for mer