Kubernetes

Implementa FoxIDs en tu clúster de Kubernetes (K8s) o en Docker Desktop con Kubernetes habilitado.

Esta es una descripción de cómo hacer un despliegue predeterminado y iniciar sesión por primera vez, además de algunas consideraciones. Se espera que necesites personalizar los archivos yaml para adaptarlos a tus necesidades, preferencias y entorno.

Una instalación de FoxIDs es autocontenida, tiene pocas dependencias externas y puede lograr una disponibilidad muy alta con poco esfuerzo. FoxIDs se actualiza actualizando las dos imágenes Docker www.foxids.com/foxids:x.x.x y www.foxids.com/foxidscontrol:x.x.x a una nueva versión. Las nuevas versiones de FoxIDs son backward compatible. Revise las notas de versión antes de actualizar. Allí también puede encontrar la versión actual de la imagen Docker.

Se requiere una licencia válida para acceder a las versiones de FoxIDs. Desde allí, puede generar un secret para autenticarse en el registro de imágenes Docker en www.foxids.com, que usa autenticación Basic.

Requisitos previos:

  • Tienes un clúster de Kubernetes o Docker Desktop con Kubernetes habilitado.
  • Tienes conocimientos básicos de Kubernetes.
  • Tienes instalado kubectl.

Esta es una lista de comandos útiles al final de esta descripción.

Este despliegue incluye:

  • Dos sitios web, uno para FoxIDs y otro para FoxIDs Control (el cliente de administración y la API) en dos imágenes Docker www.foxids.com/foxids:x.x.x y www.foxids.com/foxidscontrol:x.x.x.
  • Los dos sitios web están expuestos en dos dominios distintos, asegurados con certificados Let’s Encrypt generados automáticamente.
  • MongoDB es una base de datos NoSQL y contiene todos los datos, incluidos tenants, entornos y usuarios. Se implementa con la imagen Docker oficial de MongoDB. Opcionalmente puedes usar tu propia instancia de PostgreSQL en lugar de MongoDB.
  • De forma predeterminada, la caché se almacena en la base de datos configurada. Redis solo es necesario si ejecutas un clúster FoxIDs de alto rendimiento con PostgreSQL. MongoDB tiene una caché integrada que funciona bien cuando la instancia MongoDB tiene memoria suficiente. La caché de FoxIDs mantiene secuencias (p. ej., inicio y cierre de sesión), gestiona contadores para proteger la autenticación contra varios ataques y una caché de datos (solo Redis) para mejorar el rendimiento. Redis se implementa con la imagen Docker oficial de Redis.
  • Los registros se escriben en stdout, donde Kubernetes puede recogerlos. Se recomienda usar OpenSearch para logging salvo que la instalación de FoxIDs sea pequeña. Con OpenSearch, los errores, eventos y trazas se pueden ver directamente en FoxIDs Control Client además del log de Kubernetes, lo que facilita mucho la administración del sistema.

Deployment

El despliegue se realiza en el orden descrito.

Preparar

Descargue los archivos de configuración Kubernetes yaml aquí y colóquelos en una carpeta en su equipo, por ejemplo C:\FoxIDs\Kubernetes.

Abra una consola y navegue a la carpeta Kubernetes.

Volúmenes persistentes

Necesitas volúmenes persistentes para MongoDB, opcionalmente OpenSearch y, opcionalmente, Redis si usas Redis con PostgreSQL para un clúster FoxIDs de alto rendimiento.

En un clúster de Kubernetes, usa o crea volúmenes persistentes adecuados y crea una persistent volume claim con el nombre mongo-data-pvc para MongoDB y, opcionalmente, una para Redis con el nombre redis-data-pvc.

Puedes usar el aprovisionamiento dinámico de almacenamiento con StorageClass.

Crear persistent volume claim para Mongo

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

Crear opcionalmente persistent volume claim para Redis

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

Crear opcionalmente persistent volume claim para OpenSearch

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

Kubernetes en Docker Desktop

Si usas Kubernetes en Docker Desktop puedes crear volúmenes persistentes en el sistema de archivos del host; no se recomienda para producción.

Crear persistent volume para MongoDB

kubectl apply -f mongo-pv-dockerdesktop.yaml

Crear persistent volume claim para MongoDB

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

Crear opcionalmente persistent volume para Redis

kubectl apply -f redis-pv-dockerdesktop.yaml

Crear opcionalmente persistent volume claim para Redis

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

Crear opcionalmente persistent volume para OpenSearch

kubectl apply -f opensearch-pv-dockerdesktop.yaml

Crear opcionalmente persistent volume claim para OpenSearch

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

Espacio de nombres

Esta guía generalmente usa el espacio de nombres foxids, considera cambiarlo para adaptarlo a tu entorno de Kubernetes.

Crear espacio de nombres

kubectl create namespace foxids

MongoDB

Cambia el nombre de usuario y la contraseña de MongoDB en mongo-secret.yaml. El nombre de usuario y la contraseña están codificados en base64.

Codifica en base64 «the text» en un símbolo del sistema según tu plataforma:

Windows

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

Linux / Mac

echo -n "the text" | base64

Agregar el secreto de MongoDB

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

Crear MongoDB Opcionalmente expón MongoDB en el puerto 27017 descomentando LoadBalancer

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

Agregar un ConfigMap para el servicio de MongoDB

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

Opcionalmente usar PostgreSQL en lugar de MongoDB

Cambia el valor del nombre de usuario en postgres-username y el valor de la contraseña en postgres-password para que coincidan con tu instancia de PostgreSQL en postgres-secret.yaml. El nombre de usuario y la contraseña están codificados en base64.

Agregar el secreto de PostgreSQL

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

Cambia el endpoint de la base de datos PostgreSQL en postgres-db para que coincida con tu instancia de PostgreSQL en postgres-configmap.yaml

Agregar un ConfigMap para el servicio de PostgreSQL

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

Opcionalmente usar Redis

Redis solo es necesario si usas PostgreSQL y ejecutas un clúster FoxIDs de alto rendimiento. Si usas MongoDB, la caché integrada de MongoDB funciona bien cuando la instancia MongoDB tiene memoria suficiente.

Crear Redis opcionalmente

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

Agregar opcionalmente un ConfigMap para el servicio de Redis

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

Usar opcionalmente OpenSearch

OpenSearch se recomienda para logging salvo que la instalación de FoxIDs sea pequeña. Una instalación pequeña puede ejecutarse solo con logging Stdout, donde Kubernetes recoge los logs. Con OpenSearch, los errores, eventos y trazas también se pueden buscar directamente en FoxIDs Control Client, lo que facilita mucho la administración del sistema.

Cambia la contraseña de OpenSearch en opensearch-secret.yaml. La contraseña está codificada en base64.

Agrega el secret de OpenSearch

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

Crear OpenSearch

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

Agrega un ConfigMap para el servicio OpenSearch

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

Sitios web de FoxIDs

Dominios Los dos sitios web de FoxIDs están configurados para usar dos dominios que creas y administras en tu DNS. Configura el archivo foxids-deployment.yaml con tus dominios seleccionados:

  • El dominio del sitio FoxIDs https://id.itfoxtec.com (dos lugares en el archivo) se cambia por tu dominio - id.my-domain.com
  • El dominio del sitio FoxIDs Control https://control.itfoxtec.com se cambia por tu dominio - control.my-domain.com

Proveedor de correo electrónico Puedes configurar un proveedor global de correo o configurar más tarde proveedores de correo por entorno. FoxIDs admite el envío de correos con SendGrid y SMTP. También puedes configurar proveedores de SMS globalmente o por entorno.

El proveedor global de correo se configura en el archivo foxids-deployment.yaml en el contenedor/pod foxids dentro de la sección env:. Este ejemplo muestra cómo agregar Outlook / Microsoft 365 con 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"

Importante si usas PostgreSQL Cambia la configuración de la base de datos y del caché en foxids-deployment.yaml (dos lugares en el archivo).

Selecciona PostgreSQL como base de datos en lugar de MongoDb

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

Selecciona PostgreSQL como caché en lugar de MongoDb a menos que uses Redis

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

Descomenta la configuración de acceso a 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"

Importante si usas Redis Cambia la configuración del caché en foxids-deployment.yaml (dos lugares en el archivo).

Selecciona Redis como caché en lugar de MongoDb

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

Opcionalmente almacena datos de la base de datos en Redis

- name: "Settings__Options__DataCache"
   # value: "None"
   value: "Default"  # Cache de datos de BD en Redis

Descomenta la configuración de acceso a Redis

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

Importante si usas OpenSearch Cambia la configuración de log en foxids-deployment.yaml (dos lugares en el archivo).

Selecciona OpenSearch logging en lugar de Stdout

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

Descomenta la configuración de acceso a 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 envía logs a OpenSearch y escribe errores en stdout, por lo que Kubernetes sigue recibiendo logs de error. AllowInsecureCertificates se establece en true porque el contenedor OpenSearch predeterminado usa un certificado autofirmado.

Desplegar Configura el nombre de usuario con tu ID de cliente y la contraseña con tu pull secret para el registro Docker de FoxIDs. Después crea el secret del registro.

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

Crear los dos sitios web de FoxIDs

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

La configuración requiere un controlador Nginx. Puedes cambiar la configuración para usar otro controlador.

Requisitos previos:

  • Tienes el instalador Helm. Instala Helm en Windows con este comando CMD winget install Helm.Helm

Instalar el controlador Ingress-Nginx con dos comandos

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

Verificar opcionalmente la instalación de Ingress-Nginx

kubectl get pod -n ingress-nginx

Si lo intentas de nuevo en unos minutos deberías obtener un EXTERNAL-IP

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

Los registros DNS de los dos dominios deben apuntar a la dirección IP de la instalación para permitir la validación en línea de Let’s Encrypt. El firewall debe aceptar solicitudes en los puertos 80 y 443. Let’s Encrypt valida la propiedad del dominio en el puerto 80.

Escalar opcionalmente el controlador Ingress-Nginx

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

Instalar Cert-manager con dos comandos

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

Verificar opcionalmente la instalación de Cert-manager

kubectl get pods -n cert-manager

Agrega tu correo en el archivo letsencrypt-issuer.yaml (dos lugares).

Configurar Let’s Encrypt

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

El archivo foxids-ingress-deployment.yaml está configurado con los dominios:

  • El dominio del sitio FoxIDs id.itfoxtec.com (dos lugares en el archivo) se cambia por tu dominio - id.my-domain.com
  • El dominio del sitio FoxIDs Control control.itfoxtec.com (dos lugares en el archivo) se cambia por tu dominio - control.my-domain.com

Considera comenzar con Let’s Encrypt en staging para evitar alcanzar el límite de tasa en producción (los certificados de staging no son confiables para el navegador). Opcionalmente selecciona staging o producción en el archivo foxids-ingress-deployment.yaml, configurado por defecto para producción.

Agregar ingress con dominios enlazados a los certificados

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

¡Importante! El ingress se instala con las anotaciones nginx.ingress.kubernetes.io/proxy-buffers-number: "4" y nginx.ingress.kubernetes.io/proxy-buffer-size: "32k" para admitir SAML 2.0 donde las respuestas HTTP pueden ser bastante grandes.

Verificar opcionalmente el ingress

kubectl get ingress -n foxids

Verificar opcionalmente el emisor de certificados

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

Verificar opcionalmente si el certificado está listo (READY debe ser True)

kubectl get certificate -n foxids

Y verificar opcionalmente el certificado

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

First login

Abre el dominio del sitio FoxIDs Control en un navegador. Debería redirigir al sitio FoxIDs donde inicias sesión con el usuario administrador predeterminado admin@foxids.com y la contraseña FirstAccess! (debes cambiar la contraseña en el primer inicio de sesión). Luego se te redirige de nuevo al sitio FoxIDs Control en el tenant master. Puedes agregar más usuarios administradores en el tenant master.

Después, haz clic en el tenant main e inicia sesión de nuevo con el mismo usuario administrador predeterminado admin@foxids.com y la contraseña FirstAccess! (de nuevo debes cambiar la contraseña).

El usuario administrador predeterminado y la contraseña son los mismos para el tenant master y el tenant main, pero son dos usuarios diferentes.

Ahora has iniciado sesión en el tenant main y puedes empezar a configurar tus aplicaciones y métodos de autenticación.

Datos de inicialización

La base de datos se inicializa automáticamente según los dominios configurados. Por lo tanto, debes eliminar la base de datos si cambian los dominios. Para eliminar los datos, puedes detener el pod de la base de datos y eliminar la carpeta o los archivos físicos de la base de datos. O exponer el endpoint de la base de datos y abrirla en MongoDB Compass (descargar MongoDB Compass (GUI)) y eliminar la base de datos. Después, el pod de FoxIDs Control debe reiniciarse para iniciar un nuevo proceso de inicialización.

Opción avanzada: los dominios también se pueden cambiar manualmente en la base de datos.

Considerations

Esta sección enumera algunas consideraciones de despliegue y seguridad.

Kubernetes Service Mesh Se recomienda usar un Kubernetes Service Mesh para lograr una arquitectura de zero-trust, donde el tráfico interno esté protegido con mTLS (mutual TLS) y cifrado.

PKI interna / CA raíz Si el tráfico interno es terminado y reencriptado por un proxy o service mesh con una CA raíz interna, configura los contenedores FoxIDs para que confíen en esa CA. Ver Kubernetes internal CA.

Espacio de nombres Esta guía generalmente usa el espacio de nombres foxids, considera cambiarlo para adaptarlo a tu entorno de Kubernetes.

Crear espacio de nombres

kubectl create namespace test

Listar espacios de nombres

kubectl get namespaces

Aplicar el espacio de nombres al crear un pod

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

Registro Todos los registros de FoxIDs, incluidos errores, trazas y eventos, se escriben en stdout. Considera cómo gestionar los registros de la aplicación y recopilar los registros de los contenedores.

Limitación de velocidad Configura límites de conexiones y tasas de transmisión en foxids-ingress-deployment.yaml.

MongoDB Operator Considera MongoDB Operator si necesitas varias instancias de MongoDB.

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

Redis varios pods / clúster Considera una configuración Redis escalada si necesitas varias instancias de Redis.

Copia de seguridad Considera si los datos de MongoDB deben respaldarse y a qué nivel; aquí hay tres soluciones posibles. Se considera menos importante respaldar Redis.

  1. Respaldar el almacenamiento físico del volumen persistente.
  2. Respaldo con un Cron Job de Kubernetes.
  3. El respaldo está soportado en MongoDB Enterprise Kubernetes Operator.

Update

FoxIDs se actualiza cambiando las etiquetas de versi?n de las im?genes en foxids-deployment.yaml para ambos contenedores de FoxIDs:

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

Revisa las notas de la versi?n antes de actualizar. Las notas de la versi?n tambi?n indican la versi?n actual de la imagen Docker. Las nuevas versiones de FoxIDs son compatibles hacia atr?s.

Aplica el archivo de despliegue actualizado:

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

Kubernetes actualiza despu?s los dos despliegues a las nuevas versiones de imagen.

Tambi?n deber?a ser posible actualizar las im?genes de MongoDB, Redis y OpenSearch con datos en los vol?menes persistentes.

Useful commands

Esta es una lista de comandos que pueden ser útiles durante el despliegue para ver detalles y realizar cambios.

Crear pod

kubectl apply -f xxx.yaml

Eliminar pod

kubectl delete -f xxx.yaml

Listar pods

kubectl get pods

Obtener descripción del pod

kubectl describe pod xxx

Obtener registros del pod

kubectl logs xxx

Listar deployments

kubectl get deployments

Listar servicios

kubectl get services

Listar secretos

kubectl get secrets

Listar volúmenes persistentes

kubectl get pv

Listar persistent volume claims

kubectl get pvc

Listar ingress

kubectl get ingress

Describir ingress

kubectl describe ingress xxx
Tu privacidad

Tu privacidad

Usamos cookies para mejorar tu experiencia en nuestros sitios web. Haz clic en «Aceptar todas las cookies» para aceptar su uso. Para rechazar cookies no esenciales, haz clic en «Solo cookies necesarias».

Visita nuestra política de privacidad para saber más