Configurar registos de rede de contentores com serviços avançados de rede de contentores

2025-07-01

Este documento foi concebido para fornecer etapas claras para configurar e utilizar os Registos de Rede de Contentores usando os Serviços Avançados de Rede de Contentores. Esses logs oferecem monitoramento de fluxo de rede persistente sob medida para melhorar a visibilidade em ambientes em contêineres. Ao capturar logs de rede de contêiner, você pode rastrear efetivamente o tráfego de rede, detetar anomalias, otimizar o desempenho e garantir a conformidade com as políticas estabelecidas. Siga as instruções detalhadas fornecidas para configurar e integrar os Logs de Rede de Contêiner para o seu sistema. Para obter mais informações sobre o recurso Logs de Rede de Contentores, consulte Resumo dos Logs de Rede de Contentores

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Se você não tiver uma, crie uma conta gratuita antes de começar.

Utilize o ambiente Bash no Azure Cloud Shell. Para mais informações, veja Get started with Azure Cloud Shell.
Se preferir executar comandos de referência da CLI localmente, instale o CLI do Azure. Se estiver a usar Windows ou macOS, considere executar o Azure CLI num contentor Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.
- Se você estiver usando uma instalação local, entre na CLI do Azure usando o comando az login . Para concluir o processo de autenticação, siga os passos exibidos no seu terminal. Para outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.
- Quando solicitado, instale a extensão do Azure CLI na primeira utilização. Para obter mais informações sobre extensões, consulte Usar e gerenciar extensões com a CLI do Azure.
- Execute az version para descobrir a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

A versão mínima da CLI do Azure necessária para as etapas neste artigo é 2.73.0. Para encontrar a versão, Executar az --version . Se precisar de instalar ou atualizar, consulte Install Azure CLI.
O modo Log de rede de contêiner com logs armazenados funciona apenas para planos de dados da Cilium.
Os registos da Rede de Contentores no modo On-demand funcionam tanto para planos de dados Cilium como para não-Cilium.
Se o cluster existente for <= 1.32, atualize o cluster para a versão mais recente disponível do Kubernetes.
A versão mínima da extensão aks-preview Azure CLI é 18.0.0b2.

Instalar a extensão da CLI do `aks-preview` Azure

Instale ou atualize a extensão de visualização da CLI do Azure usando o az extension add comando or az extension update .

# Install the aks-preview extension
az extension add --name aks-preview
# Update the extension to make sure you have the latest version installed
az extension update --name aks-preview

Configurando o modo de logs armazenados para logs de rede de contêiner

Registre o sinalizador de recurso 'AdvancedNetworkingFlowLogsPreview'

Registe o sinalizador de funcionalidade AdvancedNetworkingFlowLogsPreview com o comando az feature register.

az feature register --namespace "Microsoft.ContainerService" --name "AdvancedNetworkingFlowLogsPreview"

Verifique o registro bem-sucedido usando o az feature show comando. O registo demora alguns minutos a ser concluído.

az feature show --namespace "Microsoft.ContainerService" --name "AdvancedNetworkingFlowLogsPreview"

Depois de o recurso ser exibido Registered, atualize o registro do Microsoft.ContainerService provedor de recursos usando o comando az provider register.

Limitações

Os dados de fluxo L7 são capturados somente quando o suporte à política L7 está habilitado. Para obter orientação sobre como habilitar o suporte à política L7, consulte Configurar a política L7.
Os fluxos DNS e as métricas relacionadas são capturados somente quando uma diretiva de rede FQDN da Cilium é aplicada. Para configurar políticas FQDN, consulte Configurar política FQDN.
Durante a fase de visualização pública, esse recurso pode ser configurado somente por meio dos modelos CLI e ARM. A integração usando o Terraform não é suportada no momento.
Quando o Azure Log Analytics não está configurado para armazenamento de logs, os Logs de Rede de Contêiner são limitados a um máximo de 50 MB de armazenamento. Quando esse limite for atingido, os logs mais antigos serão substituídos por novas entradas.
Se o plano da tabela de log estiver definido como Basic Logs, os painéis do Grafana pré-construídos não funcionarão conforme o esperado.
O esquema da tabela de Logs Auxiliares não é suportado.

Habilitar Serviços Avançados de Rede de Contêiner em um novo cluster

O az aks create comando com o sinalizador Advanced Container Networking Services, --enable-acns, cria um novo cluster AKS com todos os recursos Advanced Container Networking Services. Estas características abrangem:

Observabilidade da rede de contêineres: fornece informações sobre o tráfego da rede. Para saber mais, visite Observabilidade da rede de contêineres.
Segurança de rede de contêineres: Oferece recursos de segurança como filtragem de domínio totalmente qualificada (FQDN). Para saber mais, visite Segurança de rede de contêiner.

# Set an environment variable for the AKS cluster name. Make sure to replace the placeholder with your own value.
export CLUSTER_NAME="<aks-cluster-name>"
export RESOURCE_GROUP="<aks-resource-group>"

# Create an AKS cluster
az aks create \
    --name $CLUSTER_NAME \
    --resource-group $RESOURCE_GROUP \
    --generate-ssh-keys \
    --location uksouth \
    --max-pods 250 \
    --network-plugin azure \
    --network-plugin-mode overlay \
    --network-dataplane cilium \
    --node-count 2 \
    --pod-cidr 192.168.0.0/16 \
    --kubernetes-version 1.32 \
    --enable-acns

Configurando o recurso personalizado para filtragem de log

A configuração de Logs de Rede de Contêiner no modo de logs armazenados requer a definição de Recursos Personalizados específicos para definir filtros para a coleta de logs. Quando pelo menos um recurso personalizado é definido, os logs são coletados e armazenados no nó do host em "/var/log/acns/hubble/events.log". Para configurar o log, os usuários devem definir e aplicar Recursos Personalizados do tipo "RetinaNetworkFlowLog", especificando filtros como namespace, pod, service, port, protocol ou verdict. Vários recursos personalizados podem existir em um cluster simultaneamente. Se nenhum recurso personalizado for definido com filtros não vazios, nenhum log será salvo no local designado. Esta definição de exemplo de recurso personalizado demonstra como configurar registos de fluxo de rede Retina.

Modelo RetinaNetworkFlowLog

apiVersion: acn.azure.com/v1alpha1
kind: RetinaNetworkFlowLog
metadata:
  name: sample-retinanetworkflowlog # Cluster scoped
spec:
  includefilters: # List of filters
    - name: sample-filter # Filter name
      from:
        namespacedPod: # List of source namespace/pods. Prepend namespace with /
          - sample-namespace/sample-pod
        labelSelector: # Standard k8s label selector
          matchLabels:
            app: frontend
            k8s.io/namespace: sample-namespace
          matchExpressions:
            - key: environment
              operator: In
              values:
                - production
                - staging
        ip: # List of source IPs; can be CIDR
          - "192.168.1.10"
          - "10.0.0.1"
      to:
        namespacedPod:
          - sample-namespace2/sample-pod2
        labelSelector:
          matchLabels:
            app: backend
            k8s.io/namespace: sample-namespace2
          matchExpressions:
            - key: tier
              operator: NotIn
              values:
                - dev
        ip:
          - "192.168.1.20"
          - "10.0.1.1"
      protocol: # List of protocols; can be tcp, udp, dns
        - tcp
        - udp
        - dns
      verdict: # List of verdicts; can be forwarded, dropped
        - forwarded
        - dropped

A seguir está a descrição dos campos nesta definição de recurso personalizado.

Campo	Tipo	Descrição	Obrigatório
`includefilters`	[]filtrar	Uma lista de filtros que definem os fluxos de rede a serem incluídos. Cada filtro especifica a origem, o destino, o protocolo e outros critérios de correspondência. Os filtros include não podem estar vazios e devem ter pelo menos um filtro.	Obrigatório
`filters.name`	Cordão	O nome do filtro.	Opcional
`filters.protocol`	[]string	Os protocolos a combinar para este filtro. Os valores válidos são `tcp`, `udp`e `dns`. Como é um parâmetro opcional, se não for especificado, os logs com todos os protocolos serão incluídos.	Opcional
`filters.verdict`	[]string	O veredicto do fluxo a corresponder. Os valores válidos são `forwarded` e `dropped`. Como é um parâmetro opcional, se não for especificado, os logs com todos os veredictos serão incluídos.	Opcional
`filters.from`	Ponto final	Especifica a origem do fluxo de rede. Pode incluir endereços IP, seletores de rótulo ou pares de namespace-pod.	Opcional
`Endpoint.ip`	[]string	Pode ser IP único ou CIDR.	Opcional
`Endpoint.labelSelector`	Objeto	Um Seletor de Rótulos é um mecanismo para filtrar e consultar recursos com base em rótulos, permitindo que os usuários identifiquem subconjuntos específicos de recursos. Um seletor de rótulos pode incluir dois componentes: matchLabels e matchExpressions. Use matchLabels para correspondência direta especificando um par chave-valor (por exemplo, {"app": "frontend"}). Para critérios mais avançados, use matchExpressions, onde você define uma chave de rótulo, um operador (como In, NotIn, Exists ou DoesNotExist) e uma lista opcional de valores. Certifique-se de que as condições em matchLabels e matchExpressions sejam atendidas, pois elas são logicamente ANDed. Se nenhuma condição for especificada, o seletor abrangerá todos os recursos. Para não corresponder a nada, deixe o seletor vazio. Defina cuidadosamente seu seletor de rótulos para direcionar o conjunto correto de recursos.	Opcional
`Endpoint.namespacedPod`	[]string	Uma lista de pares de namespace e pod (formatados como `namespace/pod`) para corresponder à origem. nome deve corresponder ao padrão regex ^.+$	Opcional
`filters.to`	Ponto final	Especifica o destino do fluxo de rede. Pode incluir endereços IP, seletores de rótulo ou pares de namespace-pod.	Opcional
`Endpoint.ip`	[]string	Pode ser IP único ou CIDR.	Opcional
`Endpoint.labelSelector`	Objeto	Um seletor de rótulos para corresponder recursos com base nos seus rótulos.	Opcional
`Endpoint.namespacedPod`	[]string	Uma lista de pares de namespace e pod (formatados como `namespace/pod`) para corresponder ao destino.	Opcional

Aplique RetinaNetworkFlowLog CR para habilitar a coleta de logs no cluster com este comando:

kubectl apply -f <crd.yaml>

Os registos armazenados localmente nos nós do host são temporários, uma vez que o host ou o próprio nó não constitui uma solução de armazenamento persistente. Além disso, os logs nos nós anfitriões são rodados quando atingem 50 MB de tamanho. Para armazenamento e análise de longo prazo, a recomendação é configurar o Agente do Azure Monitor no cluster para coletar e reter logs no espaço de trabalho de análise de log. Como alternativa, serviços de log de terceiros, que um coletor OpenTelemetry pode integrar, oferecem opções adicionais de gerenciamento de log.

Configurando o agente do Azure Monitor para extrair logs no espaço de trabalho do Azure Log Analytics para um novo cluster (armazenamento sob gestão)

# Set an environment variable for the AKS cluster name. Make sure to replace the placeholder with your own value.
  export CLUSTER_NAME="<aks-cluster-name>"
  export RESOURCE_GROUP="<aks-resource-group>"

# Enable azure monitor with high log scale mode
    ### Use default Log Analytics workspace
    az aks enable-addons -a monitoring --enable-high-log-scale-mode -g $RESOURCE_GROUP -n $CLUSTER_NAME 
    ### Use existing Log Analytics workspace
    az aks enable-addons -a monitoring --enable-high-log-scale-mode -g $RESOURCE_GROUP -n $CLUSTER_NAME --workspace-resource-id <workspace-resource-id>

# Update the aks cluster with enable retina flow log flag. 
  az aks update --enable-acns \
    --enable-retina-flow-logs \
    -g $RESOURCE_GROUP \
    -n $CLUSTER_NAME

Observação

Quando habilitado, os logs de fluxo de rede de contêiner são gravados em "/var/log/acns/hubble/events.log" quando o recurso personalizado RetinaNetworkFlowLog é aplicado. Se a integração do Log Analytics for habilitada posteriormente, o Azure Monitor Agent (AMA) começará a coletar logs a partir desse ponto. Logs com mais de dois minutos não são processados; somente novas entradas adicionadas após o início do monitoramento são coletadas no ambiente de trabalho do Log Analytics.

Configurando o cluster existente para armazenar logs no espaço de trabalho de análise de log do Azure

Para ativar os registos de rede dos contentores no cluster existente, siga estas etapas:

Verifique se o complemento de monitoramento já está habilitado nesse cluster com o seguinte comando.
```
 az aks addon list -g $RESOURCE_GROUP -n $CLUSTER_NAME
```
Desative o complemento de monitoramento com o seguinte comando, se o complemento de monitoramento já estiver habilitado.
```
 az aks disable-addons -a monitoring -g $RESOURCE_GROUP -n $CLUSTER_NAME
```
A razão para desativar é que o monitoramento pode já estar ativado, mas não em escala elevada. Para obter mais informações, consulte Modo de alta escala.

Habilite o Monitor Azure com o modo de alto nível de registo.

 ### Use default Log Analytics workspace
 az aks enable-addons -a monitoring --enable-high-log-scale-mode -g $RESOURCE_GROUP -n $CLUSTER_NAME 
 ### Use existing Log Analytics workspace
 az aks enable-addons -a monitoring --enable-high-log-scale-mode -g $RESOURCE_GROUP -n $CLUSTER_NAME --workspace-resource-id <workspace-resource-id>

Atualize o grupo AKS ativando o sinalizador de registo de fluxo retina.

 az aks update --enable-acns \
     --enable-retina-flow-logs \
     -g $RESOURCE_GROUP \
     -n $CLUSTER_NAME

Obter credenciais de cluster

Depois de obter as suas credenciais de cluster usando o comando az aks get-credentials.

az aks get-credentials --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP

Validar a configuração

Valide se a capacidade de log de fluxo da Rede Retina está ativada com o seguinte comando –

   az aks show -g $RESOURCE_GROUP -n $CLUSTER_NAME

A saída esperada do comando acima é:

"netowrkProfile":{
	"advancedNwtworking": {
	 "enabled": true,
	 "observability":{
	   "enabled": true
	    }
	}
}
----------------------------
"osmagent":{
	"config":{
		"enableRetinaNetworkFlags": "True"
	}
}

Valide se o CRD do tipo RetinaNetworkFlowLog é aplicado

   kubectl describe retinanetworkflowlogs <cr-name>

Espere ver um nó Spec que contenha 'Incluir filtros' e um nó Status. Estado. O estado deve ser 'CONFIGURADO' e não 'FALHADO'

Spec:
  Includefilters:
    From:
      Namespaced Pod:
        namespace/pod-
    Name:  sample-filter
    Protocol:
      tcp
    To:
      Namespaced Pod:
        namespace/pod-
    Verdict:
      dropped
Status:
  State:      CONFIGURED
  Timestamp:  2025-05-01T11:24:48Z

Azure gerenciado Grafana

Se você não tiver uma instância existente do Grafana, precisará criar uma para visualizar o painel pré-criado de logs de fluxo de rede.

Criar instância do Azure Managed Grafana

Use az grafana create para criar uma instância Grafana. O nome da instância de Grafana deve ser único.

# Set an environment variable for the Grafana name. Make sure to replace the placeholder with your own value.
export GRAFANA_NAME="<grafana-name>"

# Create Grafana instance
az grafana create \
    --name $GRAFANA_NAME \
    --resource-group $RESOURCE_GROUP

Certifique-se de que seu espaço de trabalho Grafana possa acessar e pesquisar todos os dados de monitoramento na(s) assinatura(s) relevante(s). Isso é obrigatório para aceder aos painéis de controlo pré-configurados para logs de fluxo de rede.

Caso de Uso 1 - Se fores um proprietário de subscrição ou um administrador de acesso de utilizador: quando um espaço de trabalho do Grafana é criado, é-lhe atribuída uma função de Leitor de Monitorização, concedida a todos os dados do Azure Monitor e aos recursos do Log Analytics dentro da subscrição. Isso significa que o novo espaço de trabalho do Grafana pode acessar e pesquisar todos os dados de monitoramento na assinatura. Ele pode exibir as métricas e os logs do Azure Monitor de todos os recursos e quaisquer logs armazenados nos espaços de trabalho do Log Analytics na assinatura.

Caso de Uso 2 - Caso não seja um Proprietário/Administrador de Acesso a Utilizadores da assinatura ou se a análise de logs e o espaço de trabalho do Grafana estiverem em uma assinatura diferente – Em qualquer caso, o Grafana não teria acesso à análise de logs e à assinatura. O espaço de trabalho do Grafana deve ter permissão de Leitor de Monitoramento nas assinaturas relevantes para ganhar acesso a painéis pré-criados. Siga estas etapas para habilitar isso -

Vá para o seu espaço de trabalho Grafana -> Configurações -> Identidade

Selecione Atribuições de função do Azure e escolha Adicionar atribuições de função.

Adicione Escopo à assinatura, escolha a(s) assinatura(s) relevante(s), escolha a função de Leitor de Monitoramento e salve.

Verificar fonte de dados para instância do Grafana - O utilizador pode verificar a subscrição da fonte de dados para os painéis do Grafana consultando a guia da fonte de dados na instância do Grafana, conforme mostrado abaixo -

Visualização em painéis do Grafana

O usuário pode visualizar o log de fluxo de rede de contêiner para análise com dois painéis Grafana pré-construídos. Os clientes têm várias opções para acessar esses painéis

Visualização usando o Azure Managed Grafana

Verifique se os pods de logs do Azure estão em execução usando o kubectl get pods comando.

kubectl get pods -o wide -n kube-system | grep ama-logs

Sua saída deve ser semelhante à saída de exemplo a seguir:

ama-logs-9bxc6                                   3/3     Running   1 (39m ago)   44m
ama-logs-fd568                                   3/3     Running   1 (40m ago)   44m
ama-logs-rs-65bdd98f75-hqnd2                     2/2     Running   1 (43m ago)   22h

Para simplificar a análise de logs, fornecemos dois painéis do Azure Managed Grafana pré-configurados. Você pode encontrá-los como
- Azure / Insights / Containers / Networking / Flow Logs - Este painel fornece visualizações nas quais as cargas de trabalho do Kubernetes estão se comunicando entre si, incluindo solicitações de rede, respostas, quedas e erros. Atualmente, o usuário precisa importar esses painéis com ID. (ID: 23155)
- Azure / Insights / Containers / Networking / Flow Logs (Tráfego Externo) - Este painel fornece visualizações nas quais as cargas de trabalho do Kubernetes estão enviando/recebendo comunicações de fora de um cluster Kubernetes, incluindo solicitações de rede, respostas, quedas e erros. (ID: 23156) Para obter mais informações sobre o uso deste painel, consulte Visão geral dos logs de rede de contêineres

Visualização de logs de rede de contêiner no portal do Azure.

O utilizador pode visualizar, consultar e analisar registos de fluxo no portal do Azure no espaço de trabalho de análise de logs do Azure do seu cluster:

Configurando o modo sob demanda

O modo sob demanda para fluxos de rede funciona com os planos Cilium e Non-Cilium Data. Para continuar, você deve ter um cluster AKS com Advanced Container Networking Services habilitado.

Observabilidade da rede de contêineres: fornece informações sobre o tráfego da rede. Para saber mais, visite Observabilidade da rede de contêineres.
Segurança de rede de contêiner: Oferece recursos de segurança como filtragem FQDN. Para saber mais, visite Segurança de rede de contêiner.

Cílio
Não-Cilium

Observação

Os clusters com o plano de dados Cilium suportam a Observabilidade da Rede de Contêineres e a segurança da Rede de Contêineres a partir da versão 1.29 do Kubernetes.

# Set an environment variable for the AKS cluster name. Make sure to replace the placeholder with your own value.
export CLUSTER_NAME="<aks-cluster-name>"

# Create an AKS cluster
az aks create \
    --name $CLUSTER_NAME \
    --resource-group $RESOURCE_GROUP \
    --generate-ssh-keys \
    --location eastus \
    --max-pods 250 \
    --network-plugin azure \
    --network-plugin-mode overlay \
    --network-dataplane cilium \
    --node-count 2 \
    --pod-cidr 192.168.0.0/16 \
    --kubernetes-version 1.29 \
    --enable-acns

Observação

O recurso Segurança de Redes de Conteúdos não está disponível para clusters que não sejam Cilium.

# Set an environment variable for the AKS cluster name. Make sure to replace the placeholder with your own value.
export CLUSTER_NAME="<aks-cluster-name>"

# Create an AKS cluster
az aks create \
    --name $CLUSTER_NAME \
    --resource-group $RESOURCE_GROUP \
    --generate-ssh-keys \
    --network-plugin azure \
    --network-plugin-mode overlay \
    --pod-cidr 192.168.0.0/16 \
    --enable-acns

Habilitar Serviços Avançados de Rede de Contêiner em um cluster existente

O comando az aks update com o sinalizador de Serviços Avançados de Rede de Contentores, --enable-acns, atualiza um cluster AKS existente com todas as funcionalidades dos Serviços Avançados de Rede de Contentores, que incluem Observabilidade da Rede de Contentores e a funcionalidade de Segurança da Rede de Contentores.

Observação

Somente clusters com o plano de dados Cilium suportam os recursos de Segurança de Rede de Contêiner dos Serviços Avançados de Rede de Contêiner.

az aks update \
    --resource-group $RESOURCE_GROUP \
    --name $CLUSTER_NAME \
    --enable-acns

Obter credenciais de cluster

Depois de obter as suas credenciais de cluster usando o comando az aks get-credentials.

az aks get-credentials --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP

Instalar a CLI do Hubble

Instale a CLI do Hubble para acessar os dados coletados usando os seguintes comandos:

# Set environment variables
export HUBBLE_VERSION=v1.16.3
export HUBBLE_ARCH=amd64

#Install Hubble CLI
if [ "$(uname -m)" = "aarch64" ]; then HUBBLE_ARCH=arm64; fi
curl -L --fail --remote-name-all https://github.com/cilium/hubble/releases/download/$HUBBLE_VERSION/hubble-linux-${HUBBLE_ARCH}.tar.gz{,.sha256sum}
sha256sum --check hubble-linux-${HUBBLE_ARCH}.tar.gz.sha256sum
sudo tar xzvfC hubble-linux-${HUBBLE_ARCH}.tar.gz /usr/local/bin
rm hubble-linux-${HUBBLE_ARCH}.tar.gz{,.sha256sum}

Visualize os fluxos do Hubble

Verifique se os pods do Hubble estão em execução usando o comando kubectl get pods.
```
kubectl get pods -o wide -n kube-system -l k8s-app=hubble-relay
```
Sua saída deve ser semelhante à saída de exemplo a seguir:
```
hubble-relay-7ddd887cdb-h6khj     1/1  Running     0       23h 
```

Porta para frente Hubble Relay usando o kubectl port-forward comando.

kubectl port-forward -n kube-system svc/hubble-relay --address 127.0.0.1 4245:443

O TLS mútuo (mTLS) garante a segurança do servidor Hubble Relay. Para permitir que o cliente Hubble recupere fluxos, você precisa obter os certificados apropriados e configurar o cliente com eles. Aplique os certificados usando os seguintes comandos:

#!/usr/bin/env bash

set -euo pipefail
set -x

# Directory where certificates will be stored
CERT_DIR="$(pwd)/.certs"
mkdir -p "$CERT_DIR"

declare -A CERT_FILES=(
  ["tls.crt"]="tls-client-cert-file"
  ["tls.key"]="tls-client-key-file"
  ["ca.crt"]="tls-ca-cert-files"
)

for FILE in "${!CERT_FILES[@]}"; do
  KEY="${CERT_FILES[$FILE]}"
  JSONPATH="{.data['${FILE//./\\.}']}"

  # Retrieve the secret and decode it
  kubectl get secret hubble-relay-client-certs -n kube-system \
    -o jsonpath="${JSONPATH}" | \
    base64 -d > "$CERT_DIR/$FILE"

  # Set the appropriate hubble CLI config
  hubble config set "$KEY" "$CERT_DIR/$FILE"
done

hubble config set tls true
hubble config set tls-server-name instance.hubble-relay.cilium.io

Verifique se os segredos foram gerados usando o seguinte kubectl get secrets comando:

kubectl get secrets -n kube-system | grep hubble-

Sua saída deve ser semelhante à saída de exemplo a seguir:

kube-system     hubble-relay-client-certs     kubernetes.io/tls     3     9d

kube-system     hubble-relay-server-certs     kubernetes.io/tls     3     9d

kube-system     hubble-server-certs           kubernetes.io/tls     3     9d

Verifique se o pod do Hubble Relay está em execução usando o hubble observe comando.
```
hubble observe --pod hubble-relay-7ddd887cdb-h6khj
```

Visualizar usando a interface do Hubble

Para usar a interface do usuário do Hubble, salve o seguinte em hubble-ui.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: hubble-ui
  namespace: kube-system
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: hubble-ui
  labels:
    app.kubernetes.io/part-of: retina
rules:
  - apiGroups:
      - networking.k8s.io
    resources:
      - networkpolicies
    verbs:
      - get
      - list
      - watch
  - apiGroups:
      - ""
    resources:
      - componentstatuses
      - endpoints
      - namespaces
      - nodes
      - pods
      - services
    verbs:
      - get
      - list
      - watch
  - apiGroups:
      - apiextensions.k8s.io
    resources:
      - customresourcedefinitions
    verbs:
      - get
      - list
      - watch
  - apiGroups:
      - cilium.io
    resources:
      - "*"
    verbs:
      - get
      - list
      - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: hubble-ui
  labels:
    app.kubernetes.io/part-of: retina
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: hubble-ui
subjects:
  - kind: ServiceAccount
    name: hubble-ui
    namespace: kube-system
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: hubble-ui-nginx
  namespace: kube-system
data:
  nginx.conf: |
    server {
        listen       8081;
        server_name  localhost;
        root /app;
        index index.html;
        client_max_body_size 1G;
        location / {
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            # CORS
            add_header Access-Control-Allow-Methods "GET, POST, PUT, HEAD, DELETE, OPTIONS";
            add_header Access-Control-Allow-Origin *;
            add_header Access-Control-Max-Age 1728000;
            add_header Access-Control-Expose-Headers content-length,grpc-status,grpc-message;
            add_header Access-Control-Allow-Headers range,keep-alive,user-agent,cache-control,content-type,content-transfer-encoding,x-accept-content-transfer-encoding,x-accept-response-streaming,x-user-agent,x-grpc-web,grpc-timeout;
            if ($request_method = OPTIONS) {
                return 204;
            }
            # /CORS
            location /api {
                proxy_http_version 1.1;
                proxy_pass_request_headers on;
                proxy_hide_header Access-Control-Allow-Origin;
                proxy_pass http://127.0.0.1:8090;
            }
            location / {
                try_files $uri $uri/ /index.html /index.html;
            }
            # Liveness probe
            location /healthz {
                access_log off;
                add_header Content-Type text/plain;
                return 200 'ok';
            }
        }
    }
---
kind: Deployment
apiVersion: apps/v1
metadata:
  name: hubble-ui
  namespace: kube-system
  labels:
    k8s-app: hubble-ui
    app.kubernetes.io/name: hubble-ui
    app.kubernetes.io/part-of: retina
spec:
  replicas: 1
  selector:
    matchLabels:
      k8s-app: hubble-ui
  template:
    metadata:
      labels:
        k8s-app: hubble-ui
        app.kubernetes.io/name: hubble-ui
        app.kubernetes.io/part-of: retina
    spec:
      serviceAccountName: hubble-ui
      automountServiceAccountToken: true
      containers:
      - name: frontend
        image: mcr.microsoft.com/oss/cilium/hubble-ui:v0.12.2   
        imagePullPolicy: Always
        ports:
        - name: http
          containerPort: 8081
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8081
        readinessProbe:
          httpGet:
            path: /
            port: 8081
        resources: {}
        volumeMounts:
        - name: hubble-ui-nginx-conf
          mountPath: /etc/nginx/conf.d/default.conf
          subPath: nginx.conf
        - name: tmp-dir
          mountPath: /tmp
        terminationMessagePolicy: FallbackToLogsOnError
        securityContext: {}
      - name: backend
        image: mcr.microsoft.com/oss/cilium/hubble-ui-backend:v0.12.2
        imagePullPolicy: Always
        env:
        - name: EVENTS_SERVER_PORT
          value: "8090"
        - name: FLOWS_API_ADDR
          value: "hubble-relay:443"
        - name: TLS_TO_RELAY_ENABLED
          value: "true"
        - name: TLS_RELAY_SERVER_NAME
          value: ui.hubble-relay.cilium.io
        - name: TLS_RELAY_CA_CERT_FILES
          value: /var/lib/hubble-ui/certs/hubble-relay-ca.crt
        - name: TLS_RELAY_CLIENT_CERT_FILE
          value: /var/lib/hubble-ui/certs/client.crt
        - name: TLS_RELAY_CLIENT_KEY_FILE
          value: /var/lib/hubble-ui/certs/client.key
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8090
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8090
        ports:
        - name: grpc
          containerPort: 8090
        resources: {}
        volumeMounts:
        - name: hubble-ui-client-certs
          mountPath: /var/lib/hubble-ui/certs
          readOnly: true
        terminationMessagePolicy: FallbackToLogsOnError
        securityContext: {}
      nodeSelector:
        kubernetes.io/os: linux 
      volumes:
      - configMap:
          defaultMode: 420
          name: hubble-ui-nginx
        name: hubble-ui-nginx-conf
      - emptyDir: {}
        name: tmp-dir
      - name: hubble-ui-client-certs
        projected:
          defaultMode: 0400
          sources:
          - secret:
              name: hubble-relay-client-certs
              items:
                - key: tls.crt
                  path: client.crt
                - key: tls.key
                  path: client.key
                - key: ca.crt
                  path: hubble-relay-ca.crt
---
kind: Service
apiVersion: v1
metadata:
  name: hubble-ui
  namespace: kube-system
  labels:
    k8s-app: hubble-ui
    app.kubernetes.io/name: hubble-ui
    app.kubernetes.io/part-of: retina
spec:
  type: ClusterIP
  selector:
    k8s-app: hubble-ui
  ports:
    - name: http
      port: 80
      targetPort: 8081

Aplique o manifesto hubble-ui.yaml ao cluster, usando o comando a seguir.
```
kubectl apply -f hubble-ui.yaml
```
Configure o encaminhamento de porta para a interface Hubble usando o comando kubectl port-forward.
```
kubectl -n kube-system port-forward svc/hubble-ui 12000:80
```
Aceda à interface do Hubble introduzindo http://localhost:12000/ no seu navegador.

Resolução de problemas básicos

Os Serviços Avançados de Rede de Contêiner são um pré-requisito para habilitar o recurso de coleta de logs AMA: Tentando habilitar o recurso de logs de fluxo de rede de contêiner em um cluster sem habilitar os Serviços Avançados de Rede de Contêiner:

az aks update -g test-rg -n test-cluster --enable-retina-flow-logs

Resultaria em uma mensagem de erro:

Flow logs requires '--enable-acns', advanced networking to be enabled, and the monitoring addon to be enabled.
Se a versão do cluster do Kubernetes estiver abaixo de 1.32.0, tente ativar '--enable-retina-flow-logs':

The specified orchestrator version %s is not valid. Advanced Networking Flow Logs is only supported on Kubernetes version 1.32.0 or later.

Onde o %s é substituído pela versão K8s do cliente
Se um cliente tentar ativar '--enable-retina-flow-logs' numa subscrição em que o sinalizador AFEC não está ativado:

Feature Microsoft.ContainerService/AdvancedNetworkingFlowLogsPreview is not enabled. Please see https://aka.ms/aks/previews for how to enable features.
Se um cliente tentar aplicar uma CR RetinaNetworkFlowLog em um cluster onde os Serviços Avançados de Rede de Contêiner não estão habilitados:

error: resource mapping not found for <....>": no matches for kind "RetinaNetworkFlowLog" in version "acn.azure.com/v1alpha1" ensure CRDs are installed first

Desabilitar logs de rede de contêiner: modo de logs armazenados no cluster existente

Se todos os CRDs forem excluídos, a coleta do log de fluxo será interrompida, pois não haverá filtros definidos para a coleta. Para desativar a recolha de logs de fluxo de retina pelo agente de monitorização do Azure, utilize o seguinte comando

 az aks update -n $CLUSTER_NAME -g $RESOURCE_GROUP --disable-retina-flow-logs

Limpeza de recursos

Se você não planeja usar este aplicativo, exclua os outros recursos criados neste artigo usando o az group delete comando.

  az group delete --name $RESOURCE_GROUP

Próximos passos

Neste artigo de instruções práticas, aprendeste a habilitar registos de Rede de Contentores com Serviços Avançados de Rede de Contentores para o teu cluster AKS.

Para obter mais informações sobre os Serviços Avançados de Rede de Contêiner para o Serviço Kubernetes do Azure (AKS), consulte O que é Serviços Avançados de Rede de Contêiner para o Serviço Kubernetes do Azure (AKS)?.
Explore os recursos de Observabilidade de Rede de Contêiner em Serviços Avançados de Rede de Contêiner em O que é Observabilidade de Rede de Contêiner

Partilhar via

Configurar registos de rede de contentores com serviços avançados de rede de contentores

Pré-requisitos

Instalar a extensão da CLI do aks-preview Azure

Configurando o modo de logs armazenados para logs de rede de contêiner

Registre o sinalizador de recurso 'AdvancedNetworkingFlowLogsPreview'

Limitações

Habilitar Serviços Avançados de Rede de Contêiner em um novo cluster

Configurando o recurso personalizado para filtragem de log

Modelo RetinaNetworkFlowLog

Configurando o agente do Azure Monitor para extrair logs no espaço de trabalho do Azure Log Analytics para um novo cluster (armazenamento sob gestão)

Configurando o cluster existente para armazenar logs no espaço de trabalho de análise de log do Azure

Obter credenciais de cluster

Validar a configuração

Azure gerenciado Grafana

Criar instância do Azure Managed Grafana

Visualização em painéis do Grafana

Visualização usando o Azure Managed Grafana

Visualização de logs de rede de contêiner no portal do Azure.

Configurando o modo sob demanda

Habilitar Serviços Avançados de Rede de Contêiner em um cluster existente

Obter credenciais de cluster

Instalar a CLI do Hubble

Visualize os fluxos do Hubble

Visualizar usando a interface do Hubble

Resolução de problemas básicos

Desabilitar logs de rede de contêiner: modo de logs armazenados no cluster existente

Limpeza de recursos

Próximos passos

Comentários

Recursos adicionais

Instalar a extensão da CLI do `aks-preview` Azure