Políticas de rede do Kubernetes do Azure

As políticas de rede fornecem microssegmentação para pods, assim como os NSGs (Network Security Groups) fornecem microssegmentação para VMs. A implementação do Azure Network Policy Manager dá suporte à especificação de política de rede padrão do Kubernetes. Você pode usar rótulos para selecionar um grupo de pods e definir uma lista de regras de entrada e saída para filtrar o tráfego de e para esses pods. Saiba mais sobre as políticas de rede do Kubernetes na documentação do Kubernetes.

A implementação do Azure Network Policy Management funciona com a CNI do Azure que fornece integração de rede virtual para contêineres. O Network Policy Manager é suportado no Linux e no Windows Server. A implementação impõe filtragem de tráfego configurando regras de permissão e negação de IP com base nas políticas definidas em Linux IPTables ou Host Network Service (HNS) ACLPolicies for Windows Server.

Planejando a segurança para seu cluster Kubernetes

Ao implementar a segurança para o cluster, use NSGs (grupos de segurança de rede) para filtrar o tráfego que entra e sai da sub-rede do cluster (tráfego Norte-Sul). Use o Gerenciador de Políticas de Rede do Azure para tráfego entre pods em seu cluster (tráfego Leste-Oeste).

Usando o Gerenciador de Políticas de Rede do Azure

O Azure Network Policy Manager pode ser usado das seguintes maneiras para fornecer microssegmentação para pods.

Azure Kubernetes Service (AKS)

O Network Policy Manager está disponível nativamente no AKS e pode ser ativado no momento da criação do cluster.

Para obter mais informações, consulte Proteger o tráfego entre pods usando políticas de rede no Serviço Kubernetes do Azure (AKS).

Faça você mesmo (DIY) clusters Kubernetes no Azure

Para clusters DIY, primeiro instale o plug-in CNI e habilite-o em todas as máquinas virtuais de um cluster. Para obter instruções detalhadas, veja Implementar o plug-in para um cluster do Kubernetes que implementar por conta própria.

Depois que o cluster for implantado, execute o seguinte kubectl comando para baixar e aplicar o daemon do Azure Network Policy Manager definido ao cluster.

Para Linux:

kubectl apply -f https://raw.githubusercontent.com/Azure/azure-container-networking/master/npm/azure-npm.yaml

Para Windows:

 kubectl apply -f https://raw.githubusercontent.com/Azure/azure-container-networking/master/npm/examples/windows/azure-npm.yaml

A solução também é de código aberto e o código está disponível no repositório do Azure Container Networking.

Monitorar e visualizar configurações de rede com o Azure NPM

O Azure Network Policy Manager inclui métricas informativas do Prometheus que lhe permitem monitorizar e compreender melhor as suas configurações. Disponibiliza visualizações incorporadas no portal do Azure ou no Grafana Labs. Pode começar a recolher estas métricas com o Azure Monitor ou um servidor Prometheus.

Benefícios das métricas do Azure Network Policy Manager

Anteriormente, os usuários só podiam aprender sobre sua configuração de rede e iptables ipset comandos executados dentro de um nó de cluster, o que produz uma saída detalhada e difícil de entender.

No geral, as métricas fornecem:

• Contagens de políticas, regras de ACL, ipsets, entradas ipset e entradas em qualquer ipset

• Tempos de execução para chamadas individuais do SO e para lidar com eventos de recursos do kubernetes (mediana, percentil 90 e percentil 99)

• Informações de falha para lidar com eventos de recursos do kubernetes (esses eventos de recurso falham quando uma chamada do sistema operacional falha)

Exemplos de casos de uso de métricas

Alertas através de um Prometheus AlertManager

Consulte uma configuração para esses alertas da seguinte maneira.

1. Alertar quando o Network Policy Manager tiver uma falha com uma chamada de SO ou ao traduzir uma política de rede.

2. Alerta quando o tempo médio para aplicar alterações a um evento create foi superior a 100 milissegundos.

Visualizações e depuração por meio de nosso painel do Grafana ou pasta de trabalho do Azure Monitor

1. Veja quantas regras IPTables suas políticas criam (ter um grande número de regras IPTables pode aumentar ligeiramente a latência).

2. Correlacione contagens de cluster (por exemplo, ACLs) aos tempos de execução.

3. Obtenha o nome amigável para humanos de um ipset em uma determinada regra IPTables (por exemplo, azure-npm-487392 representa podlabel-role:database).

Todas as métricas suportadas

A lista a seguir é de métricas suportadas. Qualquer quantile rótulo tem valores 0.5possíveis, 0.9, e 0.99. Qualquer had_error rótulo tem valores false possíveis e true, representando se a operação foi bem-sucedida ou falhou.

Há também métricas "exec_time_count" e "exec_time_sum" para cada métrica de Resumo "exec_time".

As métricas podem ser raspadas por meio do Azure Monitor para contêineres ou por meio do Prometheus.

Configurar para o Azure Monitor

A primeira etapa é habilitar o Azure Monitor para contêineres para seu cluster Kubernetes. As etapas podem ser encontradas em Visão geral do Azure Monitor for containers. Depois de habilitar o Azure Monitor para contêineres, configure o Azure Monitor for containers ConfigMap para habilitar a integração do Network Policy Manager e a coleta de métricas do Prometheus Network Policy Manager.

O Azure Monitor for containers ConfigMap tem uma integrations seção com configurações para coletar métricas do Network Policy Manager.

Essas configurações são desabilitadas por padrão no ConfigMap. Ativar a configuração collect_basic_metrics = truebásica , coleta métricas básicas do Network Policy Manager. A ativação da configuração collect_advanced_metrics = true avançada coleta métricas avançadas, além de métricas básicas.

Depois de editar o ConfigMap, salve-o localmente e aplique o ConfigMap ao seu cluster da seguinte maneira.

kubectl apply -f container-azm-ms-agentconfig.yaml

O trecho a seguir é do Azure Monitor for containers ConfigMap, que mostra a integração do Network Policy Manager habilitada com a coleta de métricas avançadas.

integrations: |-
    [integrations.azure_network_policy_manager]
        collect_basic_metrics = false
        collect_advanced_metrics = true

As métricas avançadas são opcionais e ativá-las automaticamente ativa a coleta de métricas básicas. Atualmente, as métricas avançadas incluem apenas Network Policy Manager_ipset_countso .

Saiba mais sobre o Azure Monitor para configurações de coleta de contêineres no mapa de configuração.

Opções de visualização para o Azure Monitor

Depois que a coleta de métricas do Network Policy Manager estiver habilitada, você poderá exibir as métricas no portal do Azure usando informações de contêiner ou no Grafana.

Exibindo no portal do Azure em insights para o cluster

Abre o Portal do Azure. Uma vez nas informações do cluster, navegue até Pastas de trabalho e abra Configuração do Gerenciador de Políticas de Rede (Gerenciador de Políticas de Rede).

Além de visualizar a pasta de trabalho, você também pode consultar diretamente as métricas do Prometheus em "Logs" na seção de insights. Por exemplo, essa consulta retorna todas as métricas que estão sendo coletadas.

| where TimeGenerated > ago(5h)
| where Name contains "npm_"

Você também pode consultar a análise de log diretamente para obter as métricas. Para obter mais informações, consulte Introdução às consultas do Log Analytics.

Visualização no painel do Grafana

Configure seu Grafana Server e configure uma fonte de dados de análise de log conforme descrito aqui. Em seguida, importe o Painel do Grafana com um back-end do Log Analytics para o seu Grafana Labs.

O painel tem elementos visuais semelhantes à Pasta de Trabalho do Azure. Você pode adicionar painéis ao gráfico e visualizar métricas do Network Policy Manager na tabela InsightsMetrics.

Configurar o servidor Prometheus

Alguns usuários podem optar por coletar métricas com um servidor Prometheus em vez do Azure Monitor para contêineres. Você só precisa adicionar dois trabalhos à sua configuração de raspagem para coletar métricas do Network Policy Manager.

Para instalar um servidor Prometheus, adicione este repositório de leme no cluster:

helm repo add stable https://kubernetes-charts.storage.googleapis.com
helm repo update

Em seguida, adicione um servidor

helm install prometheus stable/prometheus -n monitoring \
--set pushgateway.enabled=false,alertmanager.enabled=false, \
--set-file extraScrapeConfigs=prometheus-server-scrape-config.yaml

onde prometheus-server-scrape-config.yaml consiste em:

- job_name: "azure-npm-node-metrics"
  metrics_path: /node-metrics
  kubernetes_sd_configs:
  - role: node
  relabel_configs:
  - source_labels: [__address__]
    action: replace
    regex: ([^:]+)(?::\d+)?
    replacement: "$1:10091"
    target_label: __address__
- job_name: "azure-npm-cluster-metrics"
  metrics_path: /cluster-metrics
  kubernetes_sd_configs:
  - role: service
  relabel_configs:
  - source_labels: [__meta_kubernetes_namespace]
    regex: kube-system
    action: keep
  - source_labels: [__meta_kubernetes_service_name]
    regex: npm-metrics-cluster-service
    action: keep
# Comment from here to the end to collect advanced metrics: number of entries for each IPSet
  metric_relabel_configs:
  - source_labels: [__name__]
    regex: npm_ipset_counts
    action: drop

Você também pode substituir o azure-npm-node-metrics trabalho pelo seguinte conteúdo ou incorporá-lo em um trabalho pré-existente para pods do Kubernetes:

- job_name: "azure-npm-node-metrics-from-pod-config"
  metrics_path: /node-metrics
  kubernetes_sd_configs:
  - role: pod
  relabel_configs:
  - source_labels: [__meta_kubernetes_namespace]
    regex: kube-system
    action: keep
  - source_labels: [__meta_kubernetes_pod_annotationpresent_azure_Network Policy Manager_scrapeable]
    action: keep
  - source_labels: [__address__]
    action: replace
    regex: ([^:]+)(?::\d+)?
    replacement: "$1:10091"
    target_label: __address__

Configurar alertas para o AlertManager

Se você usa um servidor Prometheus, você pode configurar um AlertManager assim. Aqui está um exemplo de configuração para as duas regras de alerta descritas anteriormente:

groups:
- name: npm.rules
  rules:
  # fire when Network Policy Manager has a new failure with an OS call or when translating a Network Policy (suppose there's a scraping interval of 5m)
  - alert: AzureNetwork Policy ManagerFailureCreatePolicy
    # this expression says to grab the current count minus the count 5 minutes ago, or grab the current count if there was no data 5 minutes ago
    expr: (npm_add_policy_exec_time_count{had_error='true'} - (npm_add_policy_exec_time_count{had_error='true'} offset 5m)) or npm_add_policy_exec_time_count{had_error='true'}
    labels:
      severity: warning
      addon: azure-npm
    annotations:
      summary: "Azure Network Policy Manager failed to handle a policy create event"
      description: "Current failure count since Network Policy Manager started: {{ $value }}"
  # fire when the median time to apply changes for a pod create event is more than 100 milliseconds.
  - alert: AzurenpmHighControllerPodCreateTimeMedian
    expr: topk(1, npm_controller_pod_exec_time{operation="create",quantile="0.5",had_error="false"}) > 100.0
    labels:
      severity: warning
      addon: azure-Network Policy Manager
    annotations:
      summary: "Azure Network Policy Manager controller pod create time median > 100.0 ms"
      # could have a simpler description like the one for the alert above,
      # but this description includes the number of pod creates that were handled in the past 10 minutes, 
      # which is the retention period for observations when calculating quantiles for a Prometheus Summary metric
      description: "value: [{{ $value }}] and observation count: [{{ printf `(npm_controller_pod_exec_time_count{operation='create',pod='%s',had_error='false'} - (npm_controller_pod_exec_time_count{operation='create',pod='%s',had_error='false'} offset 10m)) or npm_controller_pod_exec_time_count{operation='create',pod='%s',had_error='false'}` $labels.pod $labels.pod $labels.pod | query | first | value }}] for pod: [{{ $labels.pod }}]"

Opções de visualização para Prometheus

Quando você usa um Prometheus Server, apenas o painel do Grafana é suportado.

Se ainda não o fez, configure o seu servidor Grafana e configure uma fonte de dados Prometheus. Em seguida, importe o nosso Painel Grafana com um backend Prometheus para o seu Grafana Labs.

Os elementos visuais desse painel são idênticos ao painel com um back-end de insights de contêiner/análise de log.

Dashboards de exemplo

A seguir estão alguns exemplos de painel para métricas do Network Policy Manager em insights de contêiner (CI) e Grafana.

Contagens sumárias de IC

O IC conta ao longo do tempo

Entradas CI IPSet

Quantis de tempo de execução CI

Contagens de resumo do painel Grafana

O painel Grafana conta ao longo do tempo

Entradas IPSet do painel Grafana

Quantis de tempo de execução do painel Grafana

Próximos passos

• Saiba mais sobre o Serviço Kubernetes do Azure.

• Saiba mais sobre a rede de contêineres.

• Implante o plug-in para clusters Kubernetes ou contêineres do Docker.