Skip to main content
skill CX Codex

managing-network-policies · jeremylongshore — Claude Code skill for Kubernetes NetworkPolicy

managing-network-policies builds Kubernetes NetworkPolicy manifests that enforce zero-trust networking between pods. For anyone who needs to lock down pod traffic with least privilege rules.

MIT 1 installs ★ 2,935 updated 2026-11-01

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add jeremylongshore/tons-of-skills-marketplace --skill managing-network-policies -a claude-code
Open on GitHub

What managing-network-policies does

This skill writes ingress and egress rules with label selectors, namespace selectors, CIDR blocks and port specs. It starts from a default-deny baseline, then opens only the paths your services actually need.

The workflow maps communication patterns first: service-to-service, service-to-database, service-to-external. Then a deny-all policy per namespace, then explicit allow rules. DNS gets its own egress rule to kube-system on port 53 because CoreDNS breaks without it.

The output includes default-deny and allow-list manifests, a DNS policy, egress rules for external APIs and connectivity test commands. The cluster needs a CNI that supports NetworkPolicy — Calico, Cilium or Weave Net — and kubectl permissions to manage these resources. If pod labels are inconsistent, selectors will miss their targets.

Error handling is built in: the skill has a table for blocked traffic, DNS failures, selector mismatches and CNI gaps, each with a cause and a fix.

What it helps with

  • generate a default-deny manifest for a namespace
  • allow only the ingress controller to reach web pods on port 443
  • restrict API pod egress to a fixed list of external addresses
  • write the DNS egress rule to CoreDNS on port 53
  • validate connectivity with kubectl exec after applying policies

Example prompts for the agent

  • Create a default-deny policy for the production namespace, then add allow rules so only the ingress controller can reach web pods on port 443.
  • Generate egress policies that restrict the API pods to PostgreSQL (5432), Redis (6379) and external HTTPS APIs.
  • Build network policies for a 3-tier app: frontend to API on 8080, API to database on 5432, API to cache on 6379, all pods to DNS on 53.

How to install managing-network-policies

1Skills CLI (Vercel)

npx skills add jeremylongshore/tons-of-skills-marketplace --skill managing-network-policies -a claude-code

2Manually: put the files in place

~/.claude/skills/managing-network-policies/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/managing-network-policies/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about managing-network-policies

How do I install managing-network-policies in Claude Code?

Run npx skills add jeremylongshore/tons-of-skills-marketplace --skill managing-network-policies -a claude-code. The skill lands in ~/.claude/skills/managing-network-policies/SKILL.md.

What does managing-network-policies do?

It generates Kubernetes NetworkPolicy manifests: default-deny, allow rules for specific communication paths, DNS egress and external access rules, all following least privilege.

What prerequisites does this skill need?

A cluster with a NetworkPolicy-capable CNI such as Calico, Cilium or Weave Net, plus kubectl access to create NetworkPolicy resources and consistent pod labels for selectors.

Source text

SKILL.md · MIT
---
name: managing-network-policies
description: 'Execute use when managing Kubernetes network policies and firewall rules.
  Trigger with phrases like "create network policy", "configure firewall rules", "restrict
  pod communication", or "setup ingress/egress rules". Generates Kubernetes NetworkPolicy
  manifests following least privilege and zero-trust principles.

  '
allowed-tools: Read, Write, Edit, Grep, Glob, Bash(kubectl:*)
version: 1.25.0
author: Jeremy Longshore <[email protected]>
license: MIT
tags:
- devops
- kubernetes
- network-policies
compatibility: Designed for Claude Code
---
# Managing Network Policies

## Overview

Create and manage Kubernetes NetworkPolicy manifests to enforce zero-trust networking between pods, namespaces, and external endpoints. Generate ingress and egress rules with label selectors, namespace selectors, CIDR blocks, and port specifications following the principle of least privilege.

## Prerequisites

- Kubernetes cluster with a CNI plugin that supports NetworkPolicy (Calico, Cilium, Weave Net)
- `kubectl` configured with permissions to create and manage NetworkPolicy resources
- Pod labels consistently defined across deployments for accurate selector targeting
- Service communication map documenting which pods need to talk to which pods on which ports
- Understanding of DNS requirements (pods need egress to kube-dns on port 53 for name resolution)

## Instructions

1. Map the application communication patterns: identify all service-to-service, service-to-database, and service-to-external connections
2. Start with a default-deny policy for both ingress and egress in each namespace to establish zero-trust baseline
3. Add explicit allow rules for each legitimate communication path: specify source pod labels, destination pod labels, and ports
4. Always include a DNS egress rule allowing traffic to `kube-system` namespace on UDP/TCP port 53 for CoreDNS
5. Define egress rules for external API access: use CIDR blocks or namespaceSelector for known external services
6. Apply policies to a test namespace first and verify connectivity with `kubectl exec` curl/wget commands
7. Monitor for blocked traffic in the CNI plugin logs (Calico: `calicoctl node status`, Cilium: `cilium monitor`)
8. Iterate on policies: add missing allow rules for any legitimate traffic that gets blocked
9. Document each policy with annotations explaining the business reason for the allowed communication

## Output

- Default-deny NetworkPolicy manifests for ingress and egress per namespace
- Allow-list NetworkPolicy manifests for each service communication path
- DNS egress policy allowing pod name resolution
- External access egress policies with CIDR blocks
- Connectivity test commands for validation

## Error Handling

| Error | Cause | Solution |
|-------|-------|---------|
| `All traffic blocked after applying policy` | Default-deny applied without corresponding allow rules | Apply allow rules before or simultaneously with deny policies; verify with `kubectl exec` tests |
| `DNS resolution fails after network policy` | Missing egress rule for kube-dns/CoreDNS | Add egress policy allowing UDP and TCP port 53 to `kube-system` namespace |
| `Policy not targeting intended pods` | Label mismatch between policy selector and pod labels | Verify labels with `kubectl get pods --show-labels`; match selectors exactly |
| `Traffic still allowed despite deny policy` | CNI plugin does not support NetworkPolicy or policy in wrong namespace | Verify CNI support with `kubectl get networkpolicy -A`; ensure policy is in the correct namespace |
| `Intermittent connection failures` | Policy allows traffic but connection pool or timeout settings too aggressive | Check if the issue is network policy or application-level; test with `kubectl exec` during failures |

## Examples

- "Create a default-deny policy for the `production` namespace, then add allow rules so only the ingress controller can reach web pods on port 443."
- "Generate egress policies that restrict the API pods to communicate only with PostgreSQL (port 5432), Redis (port 6379), and external HTTPS APIs."
- "Build a complete set of network policies for a 3-tier app: frontend -> API (8080), API -> database (5432), API -> cache (6379), all pods -> DNS (53)."

## Resources

- Kubernetes NetworkPolicy: https://kubernetes.io/docs/concepts/services-networking/network-policies/
- Calico network policy: https://docs.tigera.io/calico/latest/network-policy/
- Cilium network policy: https://docs.cilium.io/en/stable/security/policy/
- Network policy editor (visual): https://editor.networkpolicy.io/

© Jeremy Longshore · MIT · jeremylongshore/tons-of-skills-marketplace

Similar skills

All skills for DevOps and infrastructure →

managing-network-policies by other authors comes first.

managing-network-policies celigo managing-network-policies is a Claude Code skill for managing Celigo network policies. It comes into play when limiting MCP servers, API tokens, or user sign-in by IP address. CX Codex +1 1,400installs k8s-security-policies Seth Hobson The k8s-security-policies skill helps define Kubernetes security policies for network isolation, RBAC, and pod security standards. Use it when securing a cluster. CX Codex +1 14,692installs agent-kubernetes-specialist Tony363 The agent-kubernetes-specialist skill supports Kubernetes cluster design, workload orchestration, security hardening, and performance work for production infrastructure. CX Codex +1 101installs gke-workload-security official google This skill for Claude Code, Gemini CLI, and Codex hardens GKE workload security. It runs security audits, isolates namespaces, and locks down pods with gVisor and network policies. CX Codex +1 5,000installs k8s-debug akin-ozer k8s-debug walks through pod failures, stuck rollouts, DNS and storage problems with kubectl. Useful when a cluster misbehaves right after a deploy. CX Codex +1 939installs kubernetes-ops devops-skills kubernetes-ops — a skill that gives your agent ready YAML for Kubernetes workloads plus the kubectl commands to debug and scale them. CX Codex +1 454installs kustomize devops-skills kustomize customizes Kubernetes manifests declaratively without templating. Helps structure base configurations and environment overlays across dev and production. CX Codex +1 415installs

From the same set139

The whole set →
s3-bucket-policy-generator The s3-bucket-policy-generator skill guides S3 bucket policy work, generates configurations, and checks results against common standards when AWS tasks call for it. CX Codex +1 1installs sqs-queue-setup Guides you through Amazon SQS queue setup and generates configurations. It activates on its own when SQS comes up in a request. CX Codex +1 1installs route53-record-manager route53-record-manager automates Amazon Route 53 DNS record management, writes configuration files, and runs AWS CLI commands directly in your coding agent. CX Codex +1 1installs windsurf-multi-file-editing The windsurf-multi-file-editing skill coordinates edits across several files with Cascade. Use it for symbol renames, code moves, and refactors that must stay consistent. CX Codex +1 1installs kubernetes-service-manager kubernetes-service-manager is a Claude Code skill that activates for Kubernetes tasks, generating configurations and providing step-by-step guidance for DevOps environment setup. CX Codex +1 1installs docker-container-basics The docker-container-basics skill assists with basic Docker container work, from guided steps to configuration generation and checks. It activates on Docker-related requests. CX Codex +1 1installs gitlab-ci-basics gitlab-ci-basics — a skill for everyday GitLab CI work: it walks through steps, writes pipeline configs and checks them for common mistakes. Activates on its own when gitlab shows up in a prompt. CX Codex +1 1installs calendar-event-creator calendar-event-creator generates code and configs for calendar event operations in business workflows. Activates automatically when you prompt the agent about calendar setup. CX Codex +1 1installs

Project sponsors

Companies that keep this analytics open