Skip to content
FA

Falco

Category: IaC Security
License: Free (Open-Source, Apache 2.0)
Suphi Cankurt
Suphi Cankurt
AppSec Enthusiast
Updated February 12, 2026
3 min read
0 Comments

Falco is a CNCF graduated runtime security tool that detects threats in Kubernetes, containers, and cloud environments by monitoring kernel-level events. Originally created by Sysdig and donated to the CNCF in 2018, Falco reached graduated status in 2024 and has 8.7k GitHub stars with 208 contributors.

Falco architecture diagram showing kernel event capture, enrichment, and alerting pipeline

The tool runs as a DaemonSet in Kubernetes clusters, capturing system calls through eBPF or a kernel module. It enriches those events with container and Kubernetes metadata, then evaluates them against YAML-based detection rules. Adopters include Shopify, GitLab, Skyscanner, and Booz Allen Hamilton.

What is Falco?

Falco intercepts system calls at the kernel level and checks them against detection rules in real time. Unlike static analysis tools that scan images before deployment, Falco catches threats during execution — containers spawning unexpected shells, processes attempting privilege escalation, applications reading sensitive files like /etc/shadow.

The latest release is v0.43.0 (January 2026). Falco runs on x86_64 and aarch64 architectures and deploys via an official Helm chart. It works with GKE, EKS, and AKS.

Real-time Detection
Monitors kernel events and alerts on threats as they happen rather than after-the-fact analysis
Plugin Architecture
Extensible data source system supports AWS CloudTrail, GitHub, Okta, and custom integrations beyond kernel events
Forensic Integration
Works with Stratoshark for deep forensic analysis triggered by Falco alerts during incident investigation

Key Features

Feature Details
Detection engine eBPF-based kernel syscall monitoring (preferred) or kernel module
Rule format Declarative YAML with macros, lists, and boolean logic
Platforms x86_64 and aarch64 Linux, GKE, EKS, AKS
Alert outputs stdout, files, syslog, program execution, HTTPS endpoints
Plugin sources AWS CloudTrail, GitHub audit logs, Okta events
Deployment Kubernetes DaemonSet via Helm chart
CNCF status Graduated (2024)
License Apache 2.0

Detection Rules

Falco’s rules engine uses YAML with conditions, outputs, and priority levels. Rules fire on specific syscall patterns — for example, detecting when a container spawns a shell process or when someone modifies files in /etc, /usr/bin, or /usr/sbin.

The rule syntax supports macros (reusable condition fragments), lists (sets of values), and complex boolean logic. Teams can tune rules to reduce false positives or add detection logic specific to their applications.

Kubernetes Context

Falco enriches kernel events with Kubernetes metadata like pod names, namespaces, labels, and service accounts. When a rule fires, the alert includes which pod triggered it, what namespace it runs in, and who owns it. This context makes incident response faster because you immediately know the blast radius.

Falcosidekick UI dashboard showing runtime security event overview and statistics

Falcosidekick
Falcosidekick is a companion project that forwards Falco alerts to 50+ destinations including Slack, PagerDuty, Elasticsearch, Loki, and cloud-native messaging systems. Falcosidekick-UI provides a web dashboard for viewing events.

Plugin System

Falco extends beyond kernel monitoring through plugins. Plugins pull events from cloud APIs, parse audit logs, or integrate custom telemetry. This turns Falco into a detection engine for cloud environments, not just containers.

Current plugins cover AWS CloudTrail for cloud API activity, GitHub audit logs for repository events, and Okta for identity-related threats.

Falcosidekick UI showing event timeline with rule priorities and source filtering

Alert Output

Falco supports five alert delivery mechanisms: standard output, file logging, syslog, program execution, and HTTPS endpoints. JSON-formatted alerts make integration with SIEM systems and data lakes straightforward.

Falcosidekick UI timeline view showing security events across time periods

Getting Started

1
Install via Helm — Deploy Falco as a DaemonSet using the official Helm chart. This ensures every node in the cluster gets monitored.
2
Choose a driver — Select eBPF (recommended for kernels 5.8+) or the kernel module for older systems. The eBPF driver doesn’t require kernel headers.
3
Review default rules — Falco ships with built-in rules covering common attack patterns. Check which rules are active and tune priorities for your environment.
4
Configure outputs — Set up alert destinations. Use Falcosidekick for routing to Slack, PagerDuty, Elasticsearch, or other systems.

When to Use Falco

Falco fills the runtime detection gap that static scanners and admission controllers can’t cover. If a container gets compromised after passing all pre-deployment checks, Falco is what catches the attacker running curl inside a production pod.

It pairs well with policy engines like Kyverno or OPA Gatekeeper for admission control, and container scanners like Trivy for pre-deployment vulnerability detection. This layered approach covers the full container lifecycle.

Limitations to keep in mind: Falco requires kernel access and runs as a privileged container. Some managed Kubernetes services restrict kernel module loading. The eBPF driver needs kernel 5.8+. Alert tuning takes time to get right in complex environments.

Best for
Organizations running production Kubernetes who need real-time threat detection to catch attacks that only appear during runtime. Adopted by GitLab, Shopify, and Skyscanner.

Browse other IaC security tools to compare options.

Frequently Asked Questions

What is Falco?
Falco is a CNCF graduated runtime security tool that detects threats in Kubernetes, containers, and cloud environments by monitoring kernel events in real-time. It uses eBPF or kernel modules to inspect system calls and generate alerts based on customizable rules.
How does Falco differ from static security scanners?
Unlike static scanners that analyze images before deployment, Falco monitors runtime behavior after containers are running. It detects anomalous activity like privilege escalation, shell spawning in containers, and unauthorized file access that only occur during execution.
What performance overhead does Falco add?
Falco uses eBPF for kernel-level instrumentation, which is optimized for production workloads. The eBPF driver avoids kernel module dependencies and runs in a sandboxed environment within the kernel. Actual overhead depends on syscall volume and rule complexity.
Is Falco free to use?
Yes, Falco is fully open-source under the Apache 2.0 license and free for commercial use. It is a CNCF graduated project with 8.7k GitHub stars and 208 contributors. Sysdig Secure offers a commercial version with enterprise features built on Falco.

Complement with SCA

Pair IaC scanning with dependency analysis for broader coverage.

See all SCA tools

Comments

Powered by Giscus — comments are stored in GitHub Discussions.