Implementación paso a paso de Falco para detección de amenazas en tiempo real en Docker y Kubernetes
Falco es una herramienta de código abierto desarrollada por Sysdig que permite monitorizar la actividad del kernel en tiempo real y generar alertas basadas en reglas de seguridad. En entornos de contenedores, donde la superficie de ataque es amplia y los cambios son rápidos, contar con una detección de amenazas en tiempo real es esencial. En este artículo vamos a cubrir, paso a paso, cómo instalar y configurar Falco tanto en Docker como en un clúster de Kubernetes, con ejemplos de reglas personalizadas y buenas prácticas.
1. Preparación del entorno
1.1 Requisitos previos
- Sistema operativo: Linux (Ubuntu 20.04+, CentOS 8+, Debian 11+).
- Privilegios: acceso root o sudo.
- Docker: versión 20.10 o superior.
- Kubernetes: clúster 1.21+ (minikube, kind o un clúster productivo).
- Kernel: soporte para eBPF (Linux 4.14+ recomendado).
1.2 Instalación de dependencias
Instalaremos los paquetes necesarios antes de proceder con Falco.
# Actualizar repositorios
sudo apt-get update -y
# Instalar herramientas básicas
sudo apt-get install -y curl gnupg2 lsb-release apt-transport-https
# Verificar versión del kernel
uname -r
2. Instalación de Falco en Docker
2.1 Uso del contenedor oficial
Falco publica una imagen oficial en Docker Hub. La ejecutaremos con los privilegios necesarios para que pueda acceder al socket del kernel.
# Crear directorio para la configuración (opcional)
mkdir -p $HOME/falco/rules
# Ejecutar el contenedor
docker run -d --name falco \
--privileged \
-v /var/run/docker.sock:/host/var/run/docker.sock \
-v /dev:/host/dev \
-v /proc:/host/proc:ro \
-v /boot:/host/boot:ro \
-v /lib/modules:/host/lib/modules:ro \
-v /usr:/host/usr:ro \
-v $HOME/falco/rules:/etc/falco/rules.d \
-e FALCO_BPF_PROBE=true \
falcosecurity/falco:latest
Los volúmenes montados le dan a Falco la visibilidad del host y de Docker. La variable FALCO_BPF_PROBE=true habilita el uso de eBPF, que reduce la sobrecarga.
2.2 Verificación de funcionamiento
Para asegurarnos de que Falco está capturando eventos, podemos generar una actividad sencilla, por ejemplo crear un contenedor que haga curl a un sitio externo.
docker run --rm alpine sh -c "apk add --no-cache curl && curl -s https://example.com"
En los logs del contenedor Falco deberíamos ver una línea similar a:
docker logs falco | grep example.com
3. Instalación de Falco en Kubernetes
3.1 Despliegue mediante Helm
La forma más cómoda de instalar Falco en un clúster es usar Helm. Primero añadimos el repositorio oficial.
# Añadir repo de Falco
helm repo add falcosecurity https://falcosecurity.github.io/charts
# Actualizar índices
helm repo update
# Instalar Falco en el namespace falco
helm install falco falcosecurity/falco \
--namespace falco --create-namespace \
--set falco.ebpf.enabled=true \
--set falco.rulesFile.content="$(cat /etc/falco/default.rules.yaml)"
Con la opción falco.ebpf.enabled=true activamos el motor eBPF. Si el clúster no soporta eBPF, se puede omitir y Falco usará el driver tradicional.
3.2 Configuración de reglas
Las reglas se definen en archivos YAML dentro del ConfigMap falco-rules. A continuación, un ejemplo de regla personalizada que detecta ejecución de shells dentro de contenedores.
- rule: Shell dentro de contenedor
desc: Detecta la ejecución de /bin/sh o /bin/bash dentro de cualquier contenedor
condition: evt.type = execve and (proc.name = bash or proc.name = sh) and container.id != ""
output: "Shell detectado en contenedor %container.id (user=%user.name command=%proc.cmdline)"
priority: WARNING
tags: [container, shell]
Para aplicar esta regla, editamos el ConfigMap:
kubectl edit configmap falco-rules -n falco
# Pegar la regla al final del archivo y guardar
3.3 Integración con Slack
En entornos productivos es recomendable enviar alertas a canales de colaboración. Falco permite usar webhooks.
outputs:
slack:
webhookurl: "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX"
channel: "#alerts-falco"
username: "FalcoBot"
icon_emoji: ":warning:"
Añadimos la sección outputs al ConfigMap falco y reiniciamos los pods:
kubectl rollout restart daemonset falco -n falco
4. Personalización avanzada de reglas
4.1 Uso de macros y listas
Falco soporta macros (macro) y listas (list) para reutilizar patrones.
# macro para procesos críticos
macro: critical_procs proc.name in (mysqld, redis-server, nginx)
# lista de rutas sospechosas
list: suspicious_paths
- /etc/shadow
- /root/.ssh/authorized_keys
Luego utilizamos esas definiciones en una regla:
- rule: Acceso a ficheros críticos
desc: Detecta lecturas/escrituras en archivos sensibles
condition: (evt.type in (open, openat, creat) and fd.name in (suspicious_paths)) and container.id != ""
output: "Acceso a archivo sensible %fd.name por %proc.name en contenedor %container.id"
priority: CRITICAL
tags: [filesystem, host]
4.2 Filtrado por etiquetas de Kubernetes
Podemos crear reglas que solo apliquen a pods con ciertas etiquetas, útil para excluir workloads de prueba.
- rule: Bloqueo de contenedores sin etiqueta de seguridad
desc: Genera alerta si un contenedor corre sin la etiqueta "security=enabled"
condition: container.id != "" and not k8s.pod.labels.security = "enabled"
output: "Contenedor %container.id ejecutándose sin etiqueta de seguridad"
priority: NOTICE
tags: [k8s, compliance]
5. Troubleshooting y errores comunes
5.1 Falco no genera eventos
- Símbolo del kernel: Verificar que el módulo
falcoestá cargado.lsmod | grep falco - Permisos: El daemonset necesita
privileged: trueo la capacidadCAP_SYS_ADMIN. Revisar el pod spec. - eBPF no disponible: Si la opción está habilitada y el kernel no lo soporta, Falco fallará al iniciar. Desactivar
falco.ebpf.enabledo actualizar el kernel.
5.2 Alertas excesivas (false positives)
- Revisar reglas genéricas como
openen todo el sistema; limitar con rutas o procesos específicos. - Usar macros y listas para excluir directorios temporales (
/tmp,/var/run). - Ajustar la prioridad de la regla para que solo las críticas generen notificaciones.
5.3 Problemas de integración con Slack
- Comprobar que la URL del webhook es correcta y que el canal existe.
- Verificar que el contenedor tiene salida a internet (política de red).
- Revisar logs del pod Falco:
kubectl logs -n falco -l app=falcopara mensajes de error de conexión.
5.4 Falco no detecta actividad dentro de contenedores con rootless Docker
Rootless Docker limita el acceso a /proc. En este caso, es necesario montar /proc del host en modo ro y habilitar hostPID: true en la spec del pod.
securityContext:
privileged: true
runAsUser: 0
hostPID: true
6. Conclusión
Falco brinda una capa de detección de amenazas en tiempo real que complementa otras soluciones de seguridad en entornos de contenedores. Su integración nativa con Docker y Kubernetes, combinada con la flexibilidad de sus reglas basadas en eBPF, permite a los administradores de sistemas y equipos de seguridad obtener visibilidad profunda del comportamiento de los workloads.
Siguiendo los pasos descritos —instalación, configuración de reglas, integración con canales de alerta y troubleshooting—, podrás desplegar una solución robusta que reduzca la ventana de exposición frente a actividades sospechosas. Recuerda mantener las reglas actualizadas, revisar periódicamente los logs y adaptar las políticas a la evolución de tu arquitectura de contenedores.