Przejdź do treści
Biblioteka skilli
DevOps i chmura · Analiza

cloud-native-ebpf-observability

/cloud-native-ebpf-observability

Pomaga badać jądro i procesy przez eBPF, od jednolinijkowców bpftrace po programy libbpf z buforami ringbuf.

Repozytorium
agent-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
10.11.2026

Ocena i bezpieczeństwo

95/ 100Klasa: dobry
Format20 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 10.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Pomaga badać jądro i procesy przez eBPF, od jednolinijkowców bpftrace po programy libbpf z buforami ringbuf.

Wyzwalacze z opisu

ebpf tracingebpf observabilitybpftracetrace syscallskprobetracepointuprobeoff-cpu profiling
Oryginalny opis (EN)

Use this skill when the user says 'ebpf tracing', 'ebpf observability', 'bpftrace', 'trace syscalls', 'kprobe', 'tracepoint', 'uprobe', 'off-cpu profiling', 'continuous profiling ebpf', 'libbpf ringbuf', 'measure latency in kernel'. Builds kernel- and user-level observability with eBPF: bpftrace one-liners for investigation, libbpf CO-RE programs with ring buffers for production agents, and guidance on Kubernetes-ready tools (Pixie, Parca, Tetragon, Beyla/OBI). Do NOT use for: packet processing and Cilium datapath (cloud-native-ebpf-networking), OpenTelemetry SDK tracing (opentelemetry-tracing

Jak działa

  1. Purpose
  2. Agent Protocol
  3. Probe Types
  4. bpftrace for Investigation
  5. libbpf CO-RE Agent (exec events via ring buffer)
  6. Kubernetes-Ready Tools
  7. Overhead Rules
  8. Anti-Patterns
  9. Checklist
  10. References
Sekcje z nagłówków SKILL.md, w oryginale · 140 linii, 860 słów
Podgląd SKILL.md
---
name: cloud-native-ebpf-observability
description: >
  Use this skill when the user says 'ebpf tracing', 'ebpf observability', 'bpftrace', 'trace syscalls', 'kprobe', 'tracepoint', 'uprobe', 'off-cpu profiling', 'continuous profiling ebpf', 'libbpf ringbuf', 'measure latency in kernel'. Builds kernel- and user-level observability with eBPF: bpftrace one-liners for investigation, libbpf CO-RE programs with ring buffers for production agents, and guidance on Kubernetes-ready tools (Pixie, Parca, Tetragon, Beyla/OBI). Do NOT use for: packet processing and Cilium datapath (cloud-native-ebpf-networking), OpenTelemetry SDK tracing (opentelemetry-tracing), runtime threat detection rules (ebpf-threat-detection).
version: "2.0.0"
author: "j4flmao"
license: "MIT"
tags: [cloud-native, ebpf, observability, bpftrace, libbpf, profiling, tracing]
---

# eBPF Observability

## Purpose
Observe what the kernel and processes are actually doing — syscalls, scheduling, I/O latency, network connections, function calls in binaries — with low overhead and no code changes. Start with bpftrace to answer a question in minutes; build a libbpf CO-RE program only when you need a long-running agent.

## Agent Protocol

### Trigger
"ebpf tracing", "ebpf observability", "bpftrace", "trace syscalls", "kprobe", "tracepoint", "uprobe", "off-cpu", "continuous profiling", "ringbuf", "kernel latency".

### Input Context
- Question to answer (which process opens files, where is latency, who connects where).
- Kernel version and BTF availability (`ls /sys/kernel/btf/vmlinux`).
- One-off investigation vs permanent agent; container/Kubernetes context.

### Output Artifact
bpftrace script or libbpf program + user-space loader outline. No file unless requested.

### Response Format
```
Question: {...}
Probe type: {tracepoint|fentry/fexit|kprobe|uprobe|USDT|perf_event}
Tool: {bpftrace one-liner|libbpf CO-RE agent|existing tool}
Overhead note: {event rate, filtering in kernel}
Min kernel: {version}
```

### Completion Criteria
- [ ] Prefer stable tracepoints over kprobes where one exists.
- [ ] Aggregation/filtering happens in kernel (maps/histograms), not per-event to user space, when rates are high.
- [ ] Minimum kernel version stated.

## Probe Types
| Probe | Stability | Use |
|---|---|---|
| Tracepoints (`tracepoint:syscalls:sys_enter_openat`) | Stable ABI | First choice for syscalls, scheduler, block I/O, net events |
| fentry/fexit (BTF trampolines, kernel ≥ 5.5) | Function signatures may change between kernels | Low-overhead kernel function entry/exit with typed args |
| kprobe/kretprobe | Unstable (internal functions can be renamed/inlined) | When no tracepoint exists |
| uprobe/uretprobe | Binary-specific | User-space functions (TLS libraries, Go/Java runtimes with care) |
| USDT | Stable if the app defines them | Instrumented runtimes/databases |
| perf_event (CPU sampling) | Stable | CPU profiling (flame graphs) |

## bpftrace for Investigation
```bash
# Who opens which files (system-wide)
bpftrace -e 'tracepoint:syscalls:sys_enter_openat { printf("%s %s\n", comm, str(args.filename)); }'

# Syscall counts by process
bpftrace -e 'tracepoint:raw_syscalls:sys_enter { @[comm] = count(); }'

# Block I/O latency histogram (µs)
bpftrace -e 'tracepoint:block:block_rq_issue { @s[args.dev, args.sector] = nsecs; }
  tracepoint:block:block_rq_complete /@s[args.dev, args.sector]/ {
    @usecs = hist((nsecs - @s[args.dev, args.sector]) / 1000); delete(@s[args.dev, args.sector]); }'

# New process executions with arguments
bpftrace -e 'tracepoint:syscalls:sys_enter_execve { printf("%d %s\n", pid, str(args.filename)); }'

# CPU profile at 99 Hz, kernel+user stacks
bpftrace -e 'profile:hz:99 { @[kstack, ustack, comm] = count(); }'
```
Older bpftrace versions use `args->field` instead of `args.field`. The bcc-tools/libbpf-tools packages (`execsnoop`, `opensnoop`, `biolatency`, `tcplife`, `runqlat`) cover many common questions already — prefer the libbpf-tools builds.

## libbpf CO-RE Agent (exec events via ring buffer)
```c
// execsnoop.bpf.c — kernel >= 5.8 (BPF ring buffer), BTF enabled
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_core_read.h>

struct event {
    __u32 pid;
    __u32 ppid;
    char comm[16];
    char filename[256];
};

struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);
} events SEC(".maps");

SEC("tracepoint/syscalls/sys_enter_execve")
int handle_execve(struct trace_event_raw_sys_enter *ctx)
{
    struct event *e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
    if (!e)
        return 0;                                   /* buffer full: drop, count if needed */

    struct task_struct *task = (struct task_struct *)bpf_get_current_task();
    e->pid  = bpf_get_current_pid_tgid() >> 32;     /* upper 32 bits = TGID (user-visible PID) */
    e->ppid = BPF_CORE_READ(task, real_parent, tgid);
    bpf_get_current_comm(&e->comm, sizeof(e->comm));
    bpf_probe_read_user_str(&e->filename, sizeof(e->filename), (const char *)ctx->args[0]);

    bpf_ringbuf_submit(e, 0);
    return 0;
}

char LICENSE[] SEC("license") = "GPL";
```
User space (C with skeleton): `bpftool gen skeleton execsnoop.bpf.o > execsnoop.skel.h`, then `execsnoop_bpf__open_and_load()`, `execsnoop_bpf__attach()`, `ring_buffer__new(bpf_map__fd(skel->maps.events), handle_event, NULL, NULL)`, and loop on `ring_buffer__poll(rb, 100)`. In Go use `cilium/ebpf` (`bpf2go` + `ringbuf.NewReader`).

Key details:
- `bpf_get_current_pid_tgid()` returns `tgid << 32 | pid`; the user-visible process ID is the upper half.
- `BPF_CORE_READ` relocates field offsets at load time using BTF → one binary works across kernels.
- Ring buffer (≥ 5.8) preserves event order across CPUs and uses one shared buffer; prefer it over `PERF_EVENT_ARRAY`.

## Kubernetes-Ready Tools
| Need | Tool |
|---|---|
| Auto-instrumented HTTP/gRPC metrics and traces | Grafana Beyla / OpenTelemetry eBPF Instrumentation (OBI), Pixie |
| Continuous CPU profiling | Parca, Pyroscope (eBPF agent) |
| Process/file/network security observability | Tetragon, Falco |
| Network flow visibility | Hubble (Cilium) |
| Ad-hoc tracing in pods | `kubectl debug` + bpftrace, or Inspektor Gadget |

Map host PIDs to containers via cgroup ID (`bpf_get_current_cgroup_id()`) and the container runtime.

## Overhead Rules
- Cost scales with event rate × work per event. Tracing every `sys_enter` on a busy host can be expensive; filter by PID/cgroup in-kernel and aggregate in maps.
- uprobes trap into the kernel per hit (microsecond-scale each) — avoid on very hot user functions.
- Stack collection and string copies are the expensive parts; cap sizes.

## Anti-Patterns
- BCC Python in production agents (runtime compilation, kernel headers required on nodes).
- kprobes on functions that have a tracepoint equivalent.
- Streaming every event to user space and aggregating there.
- Running privileged tracing DaemonSets without restricting who can deploy them (they can read any process memory via probes).

## Checklist
- [ ] BTF present; minimum kernel documented.
- [ ] Tracepoint/fentry chosen before kprobe.
- [ ] In-kernel filtering/aggregation; ring buffer sized; drops counted.
- [ ] Capabilities limited (`CAP_BPF`, `CAP_PERFMON` instead of full root where possible, kernel ≥ 5.8).

## References
- Related skills: `skills/cloud-native/ebpf-networking/SKILL.md`, `skills/low-level/ebpf-engineering/SKILL.md`, `skills/cybersecurity/ebpf-threat-detection/SKILL.md`.

Wersje

W bazie nie ma innych skilli o nazwie cloud-native-ebpf-observability.

Migawka bazy z 13.11.2026 · wersja paczki 327ef9bc623a (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100ebpf-engineering
    Pisze i debuguje produkcyjny eBPF: typy programów, libbpf z CO-RE, mapy, ring buffery i ograniczenia weryfikatora na różnych wersjach jądra.
  • 100ebpf
    Pomaga pisać programy eBPF w libbpf i bpftrace, podpinać kprobes, tracepoints i hooki XDP, debugować błędy weryfikatora oraz zapewniać przenośność CO-RE.
  • 100ebpf
    Pisze programy eBPF w libbpf lub w Rust z aya-ebpf, podpina kprobe, tracepoint i XDP oraz diagnozuje błędy weryfikatora.
  • 100implementing-ebpf-security-monitoring
    Wdraża monitoring bezpieczeństwa oparty na eBPF przez Cilium Tetragon: śledzenie procesów, połączeń sieciowych i dostępu do plików w Linuksie i Kubernetes.
  • 100implementing-runtime-security-with-tetragon
    Wdraża obserwację runtime oparty na eBPF w Kubernetes przez Cilium Tetragon, z blokowaniem niebezpiecznych wywołań systemowych na poziomie jądra.
  • 95cilium-ebpf
    Pomaga w Cilium i eBPF: instalacja CNI, polityki sieciowe, obserwowalność Hubble, multi-cluster i zastępowanie kube-proxy.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.