K8

Provides eBPF-based network observability and policy management for Kubernetes via Cilium.

Install

mkdir -p .claude/skills/k8s-cilium && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/7869" && unzip -o skill.zip -d .claude/skills/k8s-cilium && rm skill.zip

Installs to .claude/skills/k8s-cilium

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Cilium and Hubble network observability for Kubernetes. Use when managing network policies, observing traffic flows, or troubleshooting connectivity with eBPF-based networking.
176 chars✓ has a “when” trigger
Advanced

Key capabilities

  • →Manage Cilium network policies
  • →Observe traffic flows via Hubble
  • →Troubleshoot connectivity with eBPF
  • →List and inspect cluster endpoints
  • →Apply L7 filtering policies

How it works

The skill interfaces with Cilium and Hubble tools to manage network policies and query eBPF-based traffic data within a Kubernetes cluster.

Inputs & outputs

You give it
Network policy manifest or observability query
You get back
Applied policy or flow analysis report

When to use k8s-cilium

  • →Manage Kubernetes network policies
  • →Debug dropped network packets
  • →Observe cluster traffic flows

About this skill

Cilium & Hubble Network Observability

Manage eBPF-based networking using kubectl-mcp-server's Cilium tools (8 tools).

Requires the cilium toolset: start kubectl-mcp-server with --toolsets default,cilium (or MCP_TOOLSETS=default,cilium).

When to Apply

Use this skill when:

  • User mentions: "Cilium", "Hubble", "eBPF", "network policy", "flow"
  • Operations: network policy management, traffic observation, L7 filtering
  • Keywords: "network security", "traffic flow", "dropped packets", "connectivity"

Priority Rules

PriorityRuleImpactTools
1Detect Cilium installation firstCRITICALdetect_ecosystem
2Check agent status for healthHIGHcilium_get_status
3Use Hubble for flow debuggingHIGHget_hubble_flows
4Start with default denyMEDIUMCiliumNetworkPolicy

Quick Reference

TaskToolExample
Detect Ciliumdetect_ecosystemdetect_ecosystem()
Agent statuscilium_get_statuscilium_get_status()
List policiescilium_list_policiescilium_list_policies(namespace)
Query flowsget_hubble_flowsget_hubble_flows(namespace)

Check Installation

detect_ecosystem()

Cilium Status

cilium_get_status()

Network Policies

List Policies

cilium_list_policies(namespace="default")

Get Policy Details

cilium_get_policy(name="allow-web", namespace="default")

Create Cilium Network Policy

kubectl_apply(manifest="""
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: allow-web
  namespace: default
spec:
  endpointSelector:
    matchLabels:
      app: web
  ingress:
  - fromEndpoints:
    - matchLabels:
        app: frontend
    toPorts:
    - ports:
      - port: "80"
        protocol: TCP
  egress:
  - toEndpoints:
    - matchLabels:
        app: database
    toPorts:
    - ports:
      - port: "5432"
        protocol: TCP
""")

Endpoints

cilium_list_endpoints(namespace="default")

Identities

cilium_list_identities()

Nodes

cilium_list_nodes()

Hubble Flow Observability

get_hubble_flows(
    namespace="default",
    pod="my-pod",
    last="5m"
)

get_hubble_flows(
    namespace="default",
    verdict="DROPPED"
)

get_hubble_flows(
    namespace="default",
    protocol="http"
)

Create L7 Policy

kubectl_apply(manifest="""
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: api-policy
  namespace: default
spec:
  endpointSelector:
    matchLabels:
      app: api
  ingress:
  - fromEndpoints:
    - matchLabels:
        app: frontend
    toPorts:
    - ports:
      - port: "8080"
        protocol: TCP
      rules:
        http:
        - method: GET
          path: "/api/v1/.*"
        - method: POST
          path: "/api/v1/users"
""")

Cluster Mesh

kubectl_apply(manifest="""
apiVersion: cilium.io/v2
kind: CiliumClusterwideNetworkPolicy
metadata:
  name: allow-cross-cluster
spec:
  endpointSelector:
    matchLabels:
      app: shared-service
  ingress:
  - fromEntities:
    - cluster
    - remote-node
""")

Troubleshooting Workflows

Pod Can't Reach Service

cilium_get_status()
cilium_list_endpoints(namespace)
cilium_list_policies(namespace)
get_hubble_flows(namespace, pod, verdict="DROPPED")

Policy Not Working

cilium_get_policy(name, namespace)
cilium_list_endpoints(namespace)
get_hubble_flows(namespace)

Network Performance Issues

cilium_get_status()
cilium_list_nodes()
get_hubble_flows(namespace, protocol="http")

Best Practices

  1. Start with default deny: Create baseline deny-all policy
  2. Use labels consistently: Policies rely on label selectors
  3. Monitor with Hubble: Observe flows before/after policy changes
  4. Test in staging: Verify policies don't break connectivity

Prerequisites

  • Cilium: Required for all Cilium tools
    cilium install
    

Related Skills

When not to use it

  • →When managing non-Cilium Kubernetes networking

Prerequisites

Cilium installation

Limitations

  • →Requires Cilium to be installed in the cluster
  • →Policies rely heavily on consistent label selectors

How it compares

It provides deep, eBPF-based visibility and control specifically for Cilium-enabled clusters, unlike standard Kubernetes networking tools.

Compared to similar skills

k8s-cilium side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
k8s-cilium (this skill)19moReviewAdvanced
k8s-cost39moReviewIntermediate
linkerd-patterns68moReviewAdvanced
storage-networking610moReviewAdvanced

Try saying

Example prompts that trigger this skill in your AI assistant.

More by rohitg00

View all by rohitg00 →

You might also like

k8s-cost

rohitg00

Optimize Kubernetes costs through resource right-sizing, unused resource detection, and cluster efficiency analysis. Use for cost optimization, resource analysis, and capacity planning.

32

linkerd-patterns

wshobson

Implement Linkerd service mesh patterns for lightweight, security-focused service mesh deployments. Use when setting up Linkerd, configuring traffic policies, or implementing zero-trust networking with minimal overhead.

672

storage-networking

pluginagentmarketplace

Master Kubernetes storage management and networking architecture. Learn persistent storage, network policies, service discovery, and ingress routing.

663

k8s-helm

rohitg00

Manage Helm charts, releases, and repositories. Use for Helm installations, upgrades, rollbacks, chart development, and release management.

857

observability-engineer

sickn33

Build production-ready monitoring, logging, and tracing systems. Implements comprehensive observability strategies, SLI/SLO management, and incident response workflows. Use PROACTIVELY for monitoring infrastructure, performance optimization, or production reliability.

1242

kubernetes-architect

sickn33

Expert Kubernetes architect specializing in cloud-native infrastructure, advanced GitOps workflows (ArgoCD/Flux), and enterprise container orchestration. Masters EKS/AKS/GKE, service mesh (Istio/Linkerd), progressive delivery, multi-tenancy, and platform engineering. Handles security, observability, cost optimization, and developer experience. Use PROACTIVELY for K8s architecture, GitOps implementation, or cloud-native platform design.

636

Search skills

Search the agent skills registry