Kubernetes

Déployez FoxIDs dans votre cluster Kubernetes (K8s) ou Docker Desktop avec Kubernetes activé.

Ceci décrit un déploiement par défaut et une première connexion, ainsi que quelques considérations. Il est attendu que vous deviez personnaliser les fichiers yaml pour répondre à vos besoins, préférences et environnement.

Une installation FoxIDs est autonome, comporte peu de dépendances externes et peut atteindre une très haute disponibilité avec peu d’efforts. FoxIDs se met à jour en mettant à jour les deux images Docker www.foxids.com/foxids:x.x.x et www.foxids.com/foxidscontrol:x.x.x vers une nouvelle version. Les nouvelles versions de FoxIDs sont backward compatible. Veuillez consulter les notes de version avant de mettre à jour. Vous y trouverez également la version actuelle de l’image Docker.

Une licence valide est requise pour accéder aux versions de FoxIDs. À partir de là, vous pouvez générer un secret pour vous authentifier auprès du registre d’images Docker sur www.foxids.com, qui utilise l’authentification Basic.

Prérequis :

Vous disposez d’un cluster Kubernetes ou de Docker Desktop avec Kubernetes activé.
Vous avez des connaissances de base sur Kubernetes.
Vous avez installé kubectl.

Voici une liste de commandes utiles à la fin de cette description.

Ce déploiement inclut :

Deux sites web, un pour FoxIDs et un pour FoxIDs Control (le client d’administration et l’API) dans deux images Docker www.foxids.com/foxids:x.x.x et www.foxids.com/foxidscontrol:x.x.x.
Les deux sites web sont exposés sur deux domaines différents sécurisés par des certificats Let’s Encrypt générés automatiquement.
MongoDB est une base de données NoSQL qui contient toutes les données, y compris les tenants, environnements et utilisateurs. Déployée avec l’image Docker officielle MongoDB. Vous pouvez éventuellement utiliser votre propre instance PostgreSQL au lieu de MongoDB.
Par défaut, le cache est stocké dans la base de données configurée. Redis n’est nécessaire que si vous exécutez un cluster FoxIDs à haut débit avec PostgreSQL. MongoDB dispose d’un cache intégré performant lorsque l’instance MongoDB dispose de suffisamment de mémoire. Le cache FoxIDs conserve les séquences (par exemple, connexion et déconnexion), gère des compteurs pour sécuriser l’authentification contre diverses attaques et un cache de données (Redis uniquement) pour améliorer les performances. Redis est déployé avec l’image Docker officielle Redis.
Les journaux sont écrits sur stdout où ils peuvent être collectés par Kubernetes. Il est recommandé d’utiliser OpenSearch pour le logging, sauf si l’installation FoxIDs est petite. Avec OpenSearch, les erreurs, événements et traces peuvent être consultés directement dans FoxIDs Control Client en plus du journal Kubernetes, ce qui facilite fortement l’administration du système.

Deployment

Le déploiement est réalisé dans l’ordre décrit.

Préparer

Téléchargez les fichiers de configuration Kubernetes yaml ici et placez-les dans un dossier sur votre machine, par exemple C:\FoxIDs\Kubernetes.

Ouvrez une console et accédez au dossier Kubernetes.

Volumes persistants

Vous avez besoin de volumes persistants pour MongoDB, éventuellement OpenSearch et, éventuellement, Redis si vous utilisez Redis avec PostgreSQL pour un cluster FoxIDs à haut débit.

Dans un cluster Kubernetes, utilisez ou créez des volumes persistants adaptés et créez une persistent volume claim nommée mongo-data-pvc pour MongoDB et, éventuellement, une autre pour Redis nommée redis-data-pvc.

Vous pouvez utiliser le provisionnement dynamique du stockage avec une StorageClass.

Créer une persistent volume claim pour Mongo

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

Créer éventuellement une persistent volume claim pour Redis

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

Créer éventuellement une persistent volume claim pour OpenSearch

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

Kubernetes dans Docker Desktop

Si vous utilisez Kubernetes dans Docker Desktop, vous pouvez créer des volumes persistants sur le système de fichiers hôte - déconseillé pour la production.

Créer un persistent volume pour MongoDB

kubectl apply -f mongo-pv-dockerdesktop.yaml

Créer une persistent volume claim pour MongoDB

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

Créer éventuellement un persistent volume pour Redis

kubectl apply -f redis-pv-dockerdesktop.yaml

Créer éventuellement une persistent volume claim pour Redis

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

Créer éventuellement un persistent volume pour OpenSearch

kubectl apply -f opensearch-pv-dockerdesktop.yaml

Créer éventuellement une persistent volume claim pour OpenSearch

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

Espace de noms

Ce guide utilise généralement l’espace de noms foxids, envisagez de le modifier en fonction de votre environnement Kubernetes.

Créer un espace de noms

kubectl create namespace foxids

MongoDB

Modifiez le nom d’utilisateur et le mot de passe de MongoDB dans mongo-secret.yaml. Le nom d’utilisateur et le mot de passe sont encodés en base64.

Vous encodez « the text » en base64 dans un invite de commandes selon votre plateforme :

Windows

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

Linux / Mac

echo -n "the text" | base64

Ajouter le secret MongoDB

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

Créer MongoDB Exposez éventuellement MongoDB sur le port 27017 en décommentant LoadBalancer

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

Ajouter un ConfigMap pour le service MongoDB

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

Utiliser éventuellement PostgreSQL au lieu de MongoDB

Modifiez la valeur du nom d’utilisateur dans postgres-username et la valeur du mot de passe dans postgres-password pour correspondre à votre instance PostgreSQL dans postgres-secret.yaml. Le nom d’utilisateur et le mot de passe sont encodés en base64.

Ajouter le secret PostgreSQL

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

Modifier le point de terminaison de la base PostgreSQL dans postgres-db pour correspondre à votre instance PostgreSQL dans postgres-configmap.yaml

Ajouter un ConfigMap pour le service PostgreSQL

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

Utiliser éventuellement Redis

Redis n’est nécessaire que si vous utilisez PostgreSQL et exécutez un cluster FoxIDs à haut débit. Si vous utilisez MongoDB, le cache intégré de MongoDB est performant lorsque l’instance MongoDB dispose de suffisamment de mémoire.

Créer éventuellement Redis

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

Ajouter éventuellement un ConfigMap pour le service Redis

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

Utiliser éventuellement OpenSearch

OpenSearch est recommandé pour le logging, sauf si l’installation FoxIDs est petite. Une petite installation peut fonctionner uniquement avec le logging Stdout, où Kubernetes collecte les journaux. Avec OpenSearch, les erreurs, événements et traces peuvent aussi être recherchés directement dans FoxIDs Control Client, ce qui facilite fortement l’administration du système.

Modifiez le mot de passe OpenSearch dans opensearch-secret.yaml. Le mot de passe est encodé en base64.

Ajouter le secret OpenSearch

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

Créer OpenSearch

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

Ajouter un ConfigMap pour le service OpenSearch

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

Sites web FoxIDs

Domaines Les deux sites FoxIDs sont configurés pour utiliser deux domaines que vous créez et gérez dans votre DNS. Configurez le fichier foxids-deployment.yaml avec vos domaines :

Le domaine du site FoxIDs https://id.itfoxtec.com (deux endroits dans le fichier) doit être remplacé par votre domaine - id.my-domain.com
Le domaine du site FoxIDs Control https://control.itfoxtec.com doit être remplacé par votre domaine - control.my-domain.com

Fournisseur d’email Vous pouvez configurer un fournisseur d’email global ou configurer ultérieurement des fournisseurs d’email par environnement. FoxIDs prend en charge l’envoi d’emails avec SendGrid et SMTP. Vous pouvez également configurer des fournisseurs SMS globalement ou par environnement.

Le fournisseur d’email global est configuré dans le fichier foxids-deployment.yaml sur le conteneur/pod foxids dans la section env:. Cet exemple montre comment ajouter Outlook / Microsoft 365 avec SMTP :

- name: "Settings__Smtp__FromEmail"
    value: "my@email-address.org"
- name: "Settings__Smtp__FromName" # Optional from name associated to the email address
    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"

Important si vous utilisez PostgreSQL Modifiez la configuration de la base de données et du cache dans foxids-deployment.yaml (deux endroits dans le fichier).

Sélectionnez PostgreSQL comme base de données au lieu de MongoDb

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

Sélectionnez PostgreSQL comme cache au lieu de MongoDb, sauf si vous utilisez Redis

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

Décommentez la configuration d’accès 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"

Important si vous utilisez Redis Modifiez la configuration du cache dans foxids-deployment.yaml (deux endroits dans le fichier).

Sélectionnez Redis comme cache au lieu de MongoDb

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

Mettre éventuellement en cache les données de la base dans Redis

- name: "Settings__Options__DataCache"
   # value: "None"
   value: "Default"  # Cache des données DB dans Redis

Décommentez la configuration d’accès Redis

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

Important si vous utilisez OpenSearch Modifiez la configuration du log dans foxids-deployment.yaml (deux endroits dans le fichier).

Sélectionnez OpenSearch logging au lieu de Stdout

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

Décommentez la configuration d’accès 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 envoie les journaux à OpenSearch et écrit les erreurs sur stdout, afin que Kubernetes reçoive toujours les journaux d’erreur. AllowInsecureCertificates est défini sur true car le conteneur OpenSearch par défaut utilise un certificat auto-signé.

Déployer Définissez le nom d’utilisateur sur votre ID client et le mot de passe sur votre pull secret pour le registre Docker de FoxIDs. Créez ensuite le secret de registre.

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

Créer les deux sites web FoxIDs

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

La configuration nécessite un contrôleur Nginx. Vous pouvez éventuellement modifier la configuration pour utiliser un autre contrôleur.

Prérequis :

Vous avez l’installateur Helm. Installer Helm sur Windows avec cette commande CMD winget install Helm.Helm

Installer le contrôleur Ingress-Nginx avec deux commandes

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

Vérifier éventuellement l’installation d’Ingress-Nginx

kubectl get pod -n ingress-nginx

Si vous réessayez dans quelques minutes, vous devriez obtenir un EXTERNAL-IP

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

Les enregistrements DNS des deux domaines doivent pointer vers l’adresse IP de l’installation pour permettre la validation en ligne de Let’s Encrypt. Le pare-feu doit accepter les requêtes sur les ports 80 et 443. Let’s Encrypt valide la propriété du domaine sur le port 80.

Mettre éventuellement à l’échelle le contrôleur Ingress-Nginx

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

Installer Cert-manager avec deux commandes

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

Vérifier éventuellement l’installation de Cert-manager

kubectl get pods -n cert-manager

Ajoutez votre email dans le fichier letsencrypt-issuer.yaml (deux endroits).

Configurer Let’s Encrypt

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

Le fichier foxids-ingress-deployment.yaml est configuré avec les domaines :

Le domaine du site FoxIDs id.itfoxtec.com (deux endroits dans le fichier) doit être remplacé par votre domaine - id.my-domain.com
Le domaine du site FoxIDs Control control.itfoxtec.com (deux endroits dans le fichier) doit être remplacé par votre domaine - control.my-domain.com

Pensez à commencer avec Let’s Encrypt en staging pour éviter de dépasser la limite de débit en production (les certificats de staging ne sont pas approuvés par le navigateur). Vous pouvez sélectionner staging ou production dans le fichier foxids-ingress-deployment.yaml, configuré par défaut pour la production.

Ajouter l’ingress avec les domaines liés aux certificats

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

Important ! L’ingress est installé avec les annotations nginx.ingress.kubernetes.io/proxy-buffers-number: "4" et nginx.ingress.kubernetes.io/proxy-buffer-size: "32k" pour prendre en charge SAML 2.0 où les réponses HTTP peuvent être assez volumineuses.

Vérifier éventuellement l’ingress

kubectl get ingress -n foxids

Vérifier éventuellement l’émetteur de certificats

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

Vérifier éventuellement si le certificat est prêt (READY doit être True)

kubectl get certificate -n foxids

Et vérifier éventuellement le certificat

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

Ouvrez le domaine de votre site FoxIDs Control dans un navigateur. Il doit rediriger vers le site FoxIDs où vous vous connectez avec l’utilisateur administrateur par défaut admin@foxids.com et le mot de passe FirstAccess! (vous devez changer le mot de passe lors de la première connexion). Vous êtes ensuite redirigé vers le site FoxIDs Control dans le tenant master. Vous pouvez ajouter d’autres utilisateurs administrateurs dans le tenant master.

Ensuite, cliquez sur le tenant main et authentifiez-vous à nouveau avec le même utilisateur administrateur par défaut admin@foxids.com et le mot de passe FirstAccess! (vous devez à nouveau changer le mot de passe).

L’utilisateur administrateur par défaut et le mot de passe sont identiques pour le tenant master et le tenant main, mais ce sont deux utilisateurs différents.

Vous êtes maintenant connecté au tenant main et pouvez commencer à configurer vos applications et méthodes d’authentification.

Données de démarrage

La base de données est automatiquement amorcée en fonction des domaines configurés. Par conséquent, vous devez supprimer la base de données si les domaines changent. Pour supprimer les données, vous pouvez soit arrêter le pod de base de données et supprimer le dossier ou les fichiers physiques de la base de données. Ou exposer le point de terminaison de la base et ouvrir la base dans MongoDB Compass (télécharger MongoDB Compass (GUI)) et supprimer la base de données. Ensuite, le pod FoxIDs Control doit être redémarré pour initier un nouveau processus d’amorçage.

Option avancée : les domaines peuvent également être modifiés manuellement dans la base de données.

Considerations

Cette section répertorie certaines considérations de déploiement et de sécurité.

Kubernetes Service Mesh Il est recommandé d’utiliser un Kubernetes Service Mesh pour obtenir une architecture zero-trust, où le trafic interne est sécurisé par mTLS (mutual TLS) et le chiffrement.

PKI interne / CA racine Si le trafic interne est terminé et ré-chiffré par un proxy ou un service mesh avec une CA racine interne, configurez les conteneurs FoxIDs pour faire confiance à cette CA. Voir Kubernetes internal CA.

Espace de noms Ce guide utilise généralement l’espace de noms foxids, envisagez de le modifier en fonction de votre environnement Kubernetes.

Créer un espace de noms

kubectl create namespace test

Lister les espaces de noms

kubectl get namespaces

Appliquer l’espace de noms lors de la création d’un pod

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

Journalisation Tous les journaux FoxIDs, y compris les erreurs, traces et événements, sont écrits sur stdout. Considérez comment gérer les journaux d’application et collecter les journaux des conteneurs.

Limitation de débit Configurez des limites de connexions et de débits de transmission dans foxids-ingress-deployment.yaml.

MongoDB Operator Envisagez MongoDB Operator si vous avez besoin de plusieurs instances de MongoDB.

Redis multiple pods / cluster Envisagez une configuration Redis mise à l’échelle si vous avez besoin de plusieurs instances de Redis.

Sauvegarde Déterminez si les données MongoDB doivent être sauvegardées et à quel niveau, voici trois solutions possibles. Il est considéré comme moins important de sauvegarder Redis.

Sauvegarder le stockage physique du volume persistant.
Sauvegarde avec un Cron Job Kubernetes.
La sauvegarde est prise en charge dans MongoDB Enterprise Kubernetes Operator.

Update

FoxIDs se met ? jour en changeant les tags de version des images dans foxids-deployment.yaml pour les deux conteneurs FoxIDs :

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

Consultez les notes de version avant la mise ? jour. Les notes de version indiquent aussi la version actuelle de l'image Docker. Les nouvelles versions de FoxIDs sont r?trocompatibles.

Appliquez le fichier de d?ploiement mis ? jour :

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

Kubernetes d?ploie ensuite les deux deployments avec les nouvelles versions d'image.

Il devrait ?galement ?tre possible de mettre ? jour les images MongoDB, Redis et OpenSearch avec les donn?es dans les volumes persistants.

Useful commands

Voici une liste de commandes qui peuvent être utiles pendant le déploiement pour consulter des détails et apporter des modifications.

Créer un pod

kubectl apply -f xxx.yaml

Supprimer un pod

kubectl delete -f xxx.yaml

Lister les pods

kubectl get pods

Obtenir la description d’un pod

kubectl describe pod xxx

Obtenir les journaux d’un pod

kubectl logs xxx

Lister les déploiements

kubectl get deployments

Lister les services

kubectl get services

Lister les secrets

kubectl get secrets

Lister les volumes persistants

kubectl get pv

Lister les persistent volume claims

kubectl get pvc

Lister l’ingress

kubectl get ingress

Décrire l’ingress

kubectl describe ingress xxx