Falco — Cloud Native Runtime Security & Threat Detection
Falco is an open-source runtime security tool that detects abnormal activity in containers and hosts using eBPF and syscalls. Real-time threat detection for Kubernetes.
What it is
Falco is an open-source runtime security tool that detects abnormal behavior in containers, hosts, and Kubernetes clusters. It uses eBPF to monitor system calls in real time and matches them against security rules. When a rule triggers (e.g., a container spawns an unexpected shell, reads sensitive files, or makes suspicious network connections), Falco generates an alert.
Falco targets security teams and SREs who need runtime threat detection for containerized environments. It acts as an intrusion detection system (IDS) that runs alongside your workloads without modifying application code.
How it saves time or tokens
Falco provides out-of-the-box security rules for common threats: shell execution in containers, sensitive file access, unexpected network activity, and privilege escalation. Without Falco, you would need to build custom monitoring for each of these scenarios. Falco's rules are maintained by the community and updated for new attack patterns. Integration with Kubernetes admission controllers lets you block suspicious workloads before they run.
How to use
- Install Falco via Helm:
helm repo add falcosecurity https://falcosecurity.github.io/charts
helm install falco falcosecurity/falco \
--namespace falco --create-namespace \
--set driver.kind=modern_ebpf
- View Falco alerts:
kubectl logs -n falco -l app.kubernetes.io/name=falco -f
- Customize rules by editing the Falco rules file or adding custom rule ConfigMaps.
Example
# Custom Falco rule: Detect shell in container
- rule: Terminal shell in container
desc: A shell was used as the entrypoint/exec for a container
condition: >
spawned_process and container and
shell_procs and proc.tty != 0
output: >
Shell spawned in container
(user=%user.name container=%container.name
shell=%proc.name parent=%proc.pname)
priority: WARNING
tags: [container, shell, mitre_execution]
Related on TokRepo
- Security Tools — Cloud native security and compliance tools
- DevOps Tools — Kubernetes infrastructure management
This tool integrates with standard development workflows and requires minimal configuration to get started. It is available as open-source software with documentation and community support through the official repository. The project follows semantic versioning for stable releases.
For teams evaluating this tool, the key advantage is reducing manual work in repetitive tasks. The automation provided by the built-in features means less custom code to maintain and fewer integration points to manage. This translates directly to lower maintenance costs and faster iteration cycles.
Common pitfalls
- Falco's eBPF driver requires a recent kernel version (5.8+); older kernels fall back to the kernel module driver, which requires additional privileges.
- Default rules generate many alerts on busy clusters; tune the rules to suppress known-good behaviors to reduce alert fatigue.
- Falco monitors but does not block by default; integrate with Kubernetes admission controllers or response engines (falco-sidekick) for active enforcement.
Frequently Asked Questions
eBPF (extended Berkeley Packet Filter) allows running sandboxed programs in the Linux kernel without loading kernel modules. Falco uses eBPF to intercept system calls efficiently, providing runtime visibility without the security risks of kernel modules.
Yes. Falco monitors system calls on any Linux host, containerized or not. It works with Docker, containerd, CRI-O, and bare metal systems. Kubernetes integration adds container and pod metadata to alerts.
Firewalls filter network traffic based on rules. Falco monitors system call behavior at runtime, detecting actions like file access, process execution, and privilege changes. They serve complementary roles in a defense-in-depth strategy.
Yes. Falco rules are written in YAML using a condition/output format. Conditions match on system call properties (process name, user, container, file path). The rule language supports macros and lists for reusability.
Yes. Falco is a CNCF graduated project, which means it has met the maturity requirements for production adoption. It is maintained by the Falco community with contributions from multiple organizations.
Citations (3)
- Falco GitHub— Falco detects runtime threats using eBPF and custom rules
- CNCF Landscape— Falco is a CNCF graduated project
- Falco Documentation— Falco rules for container runtime security
Related on TokRepo
Discussion
Related Assets
NAPI-RS — Build Node.js Native Addons in Rust
Write high-performance Node.js native modules in Rust with automatic TypeScript type generation and cross-platform prebuilt binaries.
Mamba — Fast Cross-Platform Package Manager
A drop-in conda replacement written in C++ that resolves environments in seconds instead of minutes.
Plasmo — The Browser Extension Framework
Build, test, and publish browser extensions for Chrome, Firefox, and Edge using React or Vue with hot-reload and automatic manifest generation.