Pular para o conteúdo
Skillpedia
Segurança35 mil · #5919

implementing-network-policies-for-kubernetes

Faz seu agente escrever regras de rede para Kubernetes que funcionam em diferentes sistemas, controlando a comunicação entre partes da aplicação.

O que ela faz

Esta ferramenta cria regras de rede para o Kubernetes. Ela ajuda a controlar qual tráfego pode ir e vir dos seus aplicativos, tornando-os mais seguros.

Quando usar

  • ✓Quando você precisa proteger seus aplicativos de acessos não autorizados.
  • ✓Ao configurar a segurança de rede em um novo ambiente Kubernetes.
  • ✓Para garantir que apenas os serviços necessários possam se comunicar entre si.

Exemplo do que pedir para a IA

“Crie uma regra que impeça todo o tráfego de entrada e saída para o namespace 'producao'.”

Quer saber mais? Abra as seções abaixo.

Como usar

O jeito mais fácil: copie a mensagem abaixo e cole no Claude, ChatGPT, Cursor ou outra IA. Ela lê a skill e segue as instruções.

Link da skill

https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/implementing-network-policies-for-kubernetes/SKILL.md

Mensagem pronta para colar

Use esta skill para me ajudar: https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/implementing-network-policies-for-kubernetes/SKILL.md Leia o arquivo SKILL.md desse link e siga as instruções dele na minha tarefa.
Como funciona

A ferramenta gera arquivos de configuração (YAML) que definem as políticas de rede. Você aplica esses arquivos ao seu cluster Kubernetes usando uma ferramenta chamada kubectl.

Instalação

Jeito mais fácil: copie o link da skill e cole no Claude, ChatGPT ou Cursor pedindo para seguir as instruções.

No terminal (Claude Code, Codex, Cursor), na pasta do projeto:

npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill implementing-network-policies-for-kubernetes

Ou baixe só o arquivo:

curl -L https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/main/skills/implementing-network-policies-for-kubernetes/SKILL.md -o SKILL.md
Conteúdo técnico (SKILL.md)

Tradução do texto original do autor no GitHub. Os comandos e códigos estão como no original.

Implementando Políticas de Rede para Kubernetes

Visão Geral

As Políticas de Rede do Kubernetes fornecem segmentação de rede no nível de pod, definindo regras de entrada (ingress) e saída (egress) que controlam o fluxo de tráfego entre pods, namespaces e endpoints externos. Combinadas com plugins CNI como Calico ou Cilium, as políticas de rede aplicam microsegmentação de confiança zero para prevenir movimento lateral dentro do cluster.

Quando Usar

  • Ao implantar ou configurar a implementação de políticas de rede para funcionalidades do Kubernetes em seu ambiente
  • Ao estabelecer controles de segurança alinhados a requisitos de conformidade
  • Ao construir ou melhorar a arquitetura de segurança para este domínio
  • Ao realizar avaliações de segurança que exigem esta implementação

Pré-requisitos

  • Cluster Kubernetes com CNI que suporte NetworkPolicy (Calico, Cilium, Antrea)
  • kubectl configurado com acesso de administrador
  • Compreensão de rótulos (labels) e seletores de pod

Fluxo de Trabalho

Passo 1: Negar Todo o Tráfego por Padrão

# default-deny-all.yaml - Apply to every namespace
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: production
spec:
  podSelector: {}  # Applies to all pods
  policyTypes:
    - Ingress
    - Egress

Passo 2: Permitir Saída de DNS (Necessário para Descoberta de Serviços)

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns
  namespace: production
spec:
  podSelector: {}
  policyTypes:
    - Egress
  egress:
    - to:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: kube-system
      ports:
        - protocol: UDP
          port: 53
        - protocol: TCP
          port: 53

Passo 3: Políticas Específicas da Aplicação

# Allow frontend to reach backend only
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-allow-frontend
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
    - Ingress
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: frontend
      ports:
        - protocol: TCP
          port: 8080
---
# Allow backend to reach database only
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: database-allow-backend
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: database
  policyTypes:
    - Ingress
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: backend
      ports:
        - protocol: TCP
          port: 5432

Passo 4: Políticas Entre Namespaces

# Allow monitoring namespace to scrape metrics
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-monitoring-scrape
  namespace: production
spec:
  podSelector: {}
  policyTypes:
    - Ingress
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              purpose: monitoring
      ports:
        - protocol: TCP
          port: 9090  # Prometheus metrics port

Passo 5: Restrições de Saída

# Restrict egress to specific external services
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: restrict-egress
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
    - Egress
  egress:
    - to:
        - podSelector:
            matchLabels:
              app: database
      ports:
        - protocol: TCP
          port: 5432
    - to:  # Allow external API
        - ipBlock:
            cidr: 203.0.113.0/24
      ports:
        - protocol: TCP
          port: 443
    - to:  # DNS
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: kube-system
      ports:
        - protocol: UDP
          port: 53

Passo 6: Bloquear Acesso a Metadados da Nuvem

# Prevent SSRF to cloud metadata service
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: block-metadata
  namespace: production
spec:
  podSelector: {}
  policyTypes:
    - Egress
  egress:
    - to:
        - ipBlock:
            cidr: 0.0.0.0/0
            except:
              - 169.254.169.254/32  # AWS/GCP metadata
              - 100.100.100.200/32  # Azure metadata

Comandos de Validação

# Verificar se as políticas foram aplicadas
kubectl get networkpolicies -n production

# Testar conectividade (deve ser bloqueada)

…
Perguntas frequentes

O que é Kubernetes?

É um sistema que ajuda a gerenciar e automatizar aplicativos que rodam em contêineres (pacotes de software).

O que é CNI?

É um plugin que gerencia como os contêineres se comunicam em uma rede dentro do Kubernetes.

O que são 'labels' e 'selectors'?

São como etiquetas que você pode colocar nos seus aplicativos e regras para que eles se encontrem e se comuniquem.

Detalhes

Descrição original do autor

Writes portable upstream Kubernetes NetworkPolicy YAML - default-deny-all, DNS egress, namespace and pod selector rules - that works on any conformant CNI such as Calico or Cilium. Use when segmentation must stay CNI-portable, introducing a default-deny posture, or restricting east-west traffic between pods and namespaces without depending on a vendor CRD. Keywords: NetworkPolicy, default deny, po

repo: mukul975/Anthropic-Cybersecurity-Skills

Popularidade

Estrelas no GitHub
35 mil
Posição no ranking
#5919
Licença
Apache-2.0
Atualizada em
31/08/2026

Essa skill é útil?

0

Entre para votar.

Comentários

  • …

Mais skills deste repositório

Skills parecidas