Guide Pratique Falco Sidekick : Installation et Configuration Complète

La détection d’anomalies de sécurité ne représente que la moitié du défi. L’autre moitié consiste à acheminer efficacement ces alertes vers les bons outils et équipes. Sans un système de routage centralisé, les équipes de sécurité se retrouvent submergées par des alertes dispersées, perdant un temps précieux à configurer des intégrations multiples.

Falco Sidekick résout précisément ce problème en agissant comme un hub de distribution intelligent pour les événements de sécurité générés par Falco. Ce guide pratique vous accompagne dans la prise en main complète de cet outil essentiel pour toute infrastructure cloud-native sécurisée.

Vous apprendrez à installer et configurer Falco Sidekick, à router vos alertes vers plus de 50 destinations différentes, et à optimiser votre pipeline de sécurité. Que vous souhaitiez envoyer des notifications vers Slack, stocker des événements dans Elasticsearch, ou déclencher des workflows automatisés, ce tutoriel vous guidera étape par étape.

Qu’est-ce que Falco Sidekick ?

Falco Sidekick est un composant open-source développé par la communauté Falco qui étend considérablement les capacités d’export d’événements du moteur de détection Falco. Concrètement, il agit comme un middleware de routage qui récupère les alertes de sécurité générées par Falco et les redistribue vers les systèmes de votre choix.

Cas d’usage principaux

L’outil excelle dans plusieurs scenarios :

• Centralisation des alertes : agrégation des événements de sécurité vers un SIEM comme Splunk ou Elasticsearch
• Notifications en temps réel : alertes instantanées via Slack, Microsoft Teams, ou PagerDuty
• Automatisation des réponses : déclenchement de workflows via webhooks ou systèmes de ticketing (Jira, ServiceNow)
• Archivage et conformité : stockage long terme dans des buckets S3, Azure Blob ou Google Cloud Storage
• Observabilité : exposition de métriques Prometheus pour monitoring du pipeline de sécurité

Avantages vs alternatives

Contrairement aux intégrations natives limitées de Falco, Sidekick offre plus de 50 destinations préconfigurées sans nécessiter de code personnalisé. Là où Logstash ou Fluentd demandent des configurations complexes pour chaque output, Sidekick propose une configuration YAML unifiée et intuitive. Son architecture légère (conteneur de ~20MB) le rend parfaitement adapté aux environnements Kubernetes contraints en ressources.

Prérequis et Installation

Configuration système requise

Avant de débuter l’installation de Falco Sidekick, vérifiez ces prérequis :

Système d’exploitation : Linux (Ubuntu 20.04+, Debian 11+, RHEL 8+) ou environnement Kubernetes 1.19+

Ressources minimales :

• CPU : 0.5 core
• RAM : 256 MB
• Stockage : 100 MB

Logiciels requis :

• Docker 20.10+ (pour installation conteneurisée) ou
• Kubernetes 1.19+ avec Helm 3.8+ (pour déploiement cluster)
• Falco 0.32+ déjà installé et opérationnel

Dépendances essentielles

Falco Sidekick nécessite une instance Falco configurée pour exporter ses événements. Vérifiez la configuration Falco :

# Vérifier que Falco expose son API gRPC
grep -A5 "grpc:" /etc/falco/falco.yaml

La configuration doit contenir :

grpc:
  enabled: true
  bind_address: "0.0.0.0:5060"

Si ce n’est pas le cas, éditez le fichier et redémarrez Falco :

sudo systemctl restart falco

Installation avec Docker

La méthode la plus rapide pour tester Falco Sidekick :

# Télécharger l'image officielle
docker pull falcosecurity/falco-sidekick:latest

# Créer un fichier de configuration
cat > config.yaml <<EOF
listenaddress: 0.0.0.0
listenport: 2801
customfields:
  environment: production
EOF

# Lancer le conteneur
docker run -d \
  --name falco-sidekick \
  -p 2801:2801 \
  -v $(pwd)/config.yaml:/etc/falco-sidekick/config.yaml \
  falcosecurity/falco-sidekick:latest

Installation sur Kubernetes avec Helm

Pour une intégration native dans votre cluster :

# Ajouter le repository Helm Falco Security
helm repo add falcosecurity https://falcosecurity.github.io/charts
helm repo update

# Créer un namespace dédié
kubectl create namespace falco

# Installer Sidekick avec configuration minimale
helm install falco-sidekick falcosecurity/falco-sidekick \
  --namespace falco \
  --set config.slack.webhookurl="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"

Vérification de l’installation

Confirmez que Sidekick fonctionne correctement :

# Pour Docker
docker logs falco-sidekick

# Pour Kubernetes
kubectl logs -n falco deployment/falco-sidekick

# Test de l'endpoint HTTP
curl http://localhost:2801/ping

Une réponse pong confirme que le service est opérationnel.

Guide Pratique Étape par Étape

Étape 1 : Configuration de la connexion Falco

La première étape consiste à connecter Sidekick à votre instance Falco. Ouvrez le fichier de configuration :

# Pour Docker
nano config.yaml

# Pour Kubernetes
kubectl edit configmap -n falco falco-sidekick

Ajoutez la section de connexion Falco :

listenaddress: 0.0.0.0
listenport: 2801

# Point de connexion vers Falco
falco:
  grpcaddress: "falco.falco.svc.cluster.local:5060"  # Pour K8s
  # grpcaddress: "localhost:5060"  # Pour Docker local
  grpctimeout: 10s

Important : Sur Kubernetes, utilisez le nom de service complet du pod Falco. En environnement Docker, assurez-vous que les conteneurs partagent le même réseau.

Étape 2 : Configurer votre première destination (Slack)

Activons l’intégration Slack pour recevoir des alertes en temps réel :

slack:
  webhookurl: "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX"
  minimumpriority: "warning"  # emergency, alert, critical, error, warning, notice, info, debug
  messageformat: "long"  # long, short
  footer: "https://github.com/falcosecurity/falco"
  icon: "https://raw.githubusercontent.com/falcosecurity/falco/master/logo.png"
  username: "Falco Sidekick"

Obtenir votre webhook Slack :

1. Accédez à https://api.slack.com/apps
2. Créez une nouvelle application
3. Activez « Incoming Webhooks »
4. Générez l’URL de webhook pour votre canal

Après modification, redémarrez Sidekick :

# Docker
docker restart falco-sidekick

# Kubernetes
kubectl rollout restart deployment/falco-sidekick -n falco

Étape 3 : Tester la configuration avec un événement simulé

Générez un événement de test depuis Falco :

# Déclencher une règle Falco en lisant un fichier sensible
kubectl exec -it <nom-pod-falco> -- cat /etc/shadow

Vérifiez la réception dans Slack. Si aucun message n’apparaît, consultez les logs :

# Activer le mode debug
kubectl set env deployment/falco-sidekick -n falco DEBUG=true
kubectl logs -n falco deployment/falco-sidekick --follow

Étape 4 : Ajouter des destinations multiples

L’une des forces de Sidekick est la capacité à router simultanément vers plusieurs systèmes. Exemple de configuration multi-destinations :

# Elasticsearch pour stockage long terme
elasticsearch:
  hostport: "https://elasticsearch.example.com:9200"
  index: "falco-events"
  type: "_doc"
  minimumpriority: "notice"
  username: "falco-user"
  password: "secure-password"

# Slack pour alertes critiques
slack:
  webhookurl: "https://hooks.slack.com/services/..."
  minimumpriority: "critical"

# Webhook personnalisé pour automatisation
webhook:
  address: "https://automation.example.com/webhooks/falco"
  minimumpriority: "warning"
  customHeaders:
    Authorization: "Bearer YOUR_TOKEN"

# Prometheus metrics pour observabilité
prometheus:
  extralabels: "environment:production,cluster:main"

Cette configuration envoie :

• Tous les événements notice+ vers Elasticsearch (archivage)
• Événements critiques uniquement vers Slack (alerting)
• Warnings et plus vers un webhook (automatisation)
• Métriques globales exposées pour Prometheus

Étape 5 : Utiliser les filtres et règles personnalisées

Affinez le routage avec des règles basées sur les champs :

customfields:
  environment: "production"
  team: "security-ops"

# Filtrer par priorité et règle
slack:
  webhookurl: "https://hooks.slack.com/services/..."
  minimumpriority: "warning"
  outputfields:
    - rule
    - priority
    - output
    - source
    - tags

# Exclure certaines règles bruyantes
mutelocation: "/etc/falco-sidekick/mute-rules.yaml"

Créez le fichier de règles à ignorer :

# /etc/falco-sidekick/mute-rules.yaml
rules:
  - "Terminal shell in container"  # Trop fréquent en dev
  - "Read sensitive file untrusted"  # Faux positifs connus

Étape 6 : Configuration avancée pour SIEM (exemple Splunk)

Pour une intégration enterprise avec Splunk :

splunk:
  hostport: "splunk-hec.example.com:8088"
  token: "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
  index: "falco-security"
  source: "falco:sidekick"
  sourcetype: "_json"
  minimumpriority: "notice"
  checkcert: true

# Enrichissement des événements pour Splunk
customfields:
  datacenter: "us-west-2"
  kubernetes_cluster: "prod-cluster-01"

Étape 7 : Activer l’interface Web UI

Sidekick propose une interface optionnelle pour visualiser les statistiques :

webui:
  url: "http://falco-sidekick-ui.falco.svc.cluster.local:2802"

Déployez l’UI séparément :

helm install falco-sidekick-ui falcosecurity/falco-sidekick-ui \
  --namespace falco \
  --set webui.url="http://falco-sidekick:2801"

# Accéder via port-forward
kubectl port-forward -n falco svc/falco-sidekick-ui 2802:2802

Ouvrez http://localhost:2802 pour voir le dashboard des événements.

Étape 8 : Configurer la persistance et résilience

Pour éviter la perte d’événements en cas de redémarrage :

# Mode file output pour backup local
file:
  enabled: true
  directory: "/var/log/falco-sidekick"
  minimumpriority: "warning"

# Configuration dans Kubernetes avec volume persistant

Ajoutez un PersistentVolumeClaim dans votre déploiement Helm :

helm upgrade falco-sidekick falcosecurity/falco-sidekick \
  --namespace falco \
  --set persistence.enabled=true \
  --set persistence.size=10Gi

Bonnes Pratiques et Optimisation

Stratégie de priorités efficace

Ne routez pas tout partout. Adoptez cette hiérarchie de distribution :

• Emergency/Alert/Critical → Notifications immédiates (Slack, PagerDuty, SMS)
• Error/Warning → Systèmes de ticketing (Jira, ServiceNow) et webhooks d’automatisation
• Notice/Informational → SIEM et stockage long terme uniquement
• Debug → Désactivé en production (uniquement pour troubleshooting)

Configuration recommandée :

slack:
  minimumpriority: "critical"  # Alertes urgentes uniquement

jira:
  minimumpriority: "error"  # Incidents nécessitant investigation

elasticsearch:
  minimumpriority: "notice"  # Tout pour analyse forensique

Sécurisation des credentials

Jamais de secrets en clair dans la configuration. Utilisez des secrets Kubernetes :

# Créer un secret pour Slack webhook
kubectl create secret generic sidekick-secrets \
  --from-literal=slack-webhook-url='https://hooks.slack.com/...' \
  -n falco

# Référencer dans le déploiement Helm
helm upgrade falco-sidekick falcosecurity/falco-sidekick \
  --namespace falco \
  --set config.slack.webhookurl="" \
  --set config.existingSecret="sidekick-secrets"

Erreurs courantes à éviter

1. Boucle infinie d’alertes

Problème : Une alerte Falco déclenche une action qui génère elle-même une nouvelle alerte.

Solution : Utilisez mutelocation pour exclure les processus d’automatisation :

mutelocation: "/etc/falco-sidekick/mute-rules.yaml"
# Dans mute-rules.yaml, ajoutez les règles générées par vos outils

2. Surcharge de destinations

Problème : Envoyer tous les événements vers toutes les destinations ralentit le système.

Solution : Configurez minimumpriority différemment pour chaque output et activez le buffering :

# Configuration globale de performance
listenaddress: 0.0.0.0
listenport: 2801
debug: false
bufferpoolsize: 10000  # Augmenter pour haut débit

3. Certificats SSL non vérifiés

En production, toujours valider les certificats :

elasticsearch:
  checkcert: true  # JAMAIS false en prod

webhook:
  checkcert: true

Monitoring de Sidekick lui-même

Exposez les métriques Prometheus pour surveiller la santé de Sidekick :

prometheus:
  enabled: true
  port: 2801
  extralabels: "component:falco-sidekick"

Métriques clés à monitorer :

• falco_sidekick_outputs_total : événements envoyés par destination
• falco_sidekick_outputs_errors_total : échecs d’envoi
• falco_sidekick_inputs_total : événements reçus de Falco

Créez une alerte Prometheus si le taux d’erreur dépasse 5% :

- alert: SidekickHighErrorRate
  expr: rate(falco_sidekick_outputs_errors_total[5m]) / rate(falco_sidekick_outputs_total[5m]) > 0.05
  for: 10m
  annotations:
    summary: "Falco Sidekick rencontre des erreurs d'envoi"

Ressources Complémentaires

Documentation officielle

• Documentation Falco Sidekick : https://github.com/falcosecurity/falco-sidekick/blob/master/docs/
• Liste complète des outputs : https://github.com/falcosecurity/falco-sidekick#outputs
• Falco Rules Repository : https://github.com/falcosecurity/rules

Communauté et support

Rejoignez la communauté Falco pour obtenir de l’aide et partager vos configurations :

• Slack Falco : https://kubernetes.slack.com/messages/falco (canal #falco)
• GitHub Discussions : https://github.com/falcosecurity/falco-sidekick/discussions
• Stack Overflow : Tag falco et falco-sidekick

Projets complémentaires

Pour enrichir votre stack de sécurité cloud-native :

• Falco Exporter : alternative légère pour export Prometheus uniquement
• Falcosidekick-UI : interface web pour visualisation des événements
• Response Engine : automatisation avancée de réponse aux incidents (Kubeless, OpenFaaS)

Conclusion

Falco Sidekick transforme votre installation Falco en un système de détection et réponse complet. En centralisant le routage d’événements, vous gagnez en agilité et en cohérence dans votre posture de sécurité.

Ce guide vous a accompagné de l’installation initiale jusqu’aux configurations avancées multi-destinations. Vous maîtrisez désormais le routage intelligent d’alertes, l’intégration avec vos outils existants, et les bonnes pratiques pour maintenir un pipeline sécurisé et performant.

Prochaines étapes recommandées : testez les destinations spécifiques à votre infrastructure, automatisez les déploiements avec GitOps (ArgoCD, Flux), et explorez les règles Falco personnalisées pour adapter la détection à vos besoins métier.

Partagez vos configurations et cas d’usage sur la communauté Falco pour contribuer à l’écosystème open-source de sécurité cloud-native.