Compartilhar via

Descobrir câmeras ONVIF com a Akri

  • Artigo

O Akri é uma interface de recurso do Kubernetes que permite expor facilmente dispositivos folha heterogêneos (como câmeras IP e dispositivos USB) como recursos em um cluster do Kubernetes e detecta continuamente nós que têm acesso a esses dispositivos para agendar cargas de trabalho com base neles. Akri é um projeto de área restrita CNCF feito para a borda, manipulando a aparência dinâmica e o desaparecimento de dispositivos folha. Atualmente, ele dá suporte a protocolos OPC UA, ONVIF e udev, mas você também pode implementar manipuladores de protocolo personalizados fornecidos pelo modelo. Leia mais sobre Akri aqui.

Este artigo descreve como você pode descobrir câmeras ONVIF conectadas à mesma rede que o cluster do AKS Edge Essentials. O ONVIF é um padrão aberto do setor para dispositivos de segurança IP, comumente usado para vigilância por vídeo. Leia mais sobre perfis ONVIF aqui. Essa demonstração ajuda você a começar a usar o Akri para descobrir câmeras IP por meio do protocolo ONVIF e usá-las por meio de um agente de vídeo que permite consumir as imagens da câmera e exibi-las em um aplicativo Web.

Diagrama que mostra o fluxo da demonstração do Akri ONVIF.

Pré-requisitos

  • Uma implantação de computador único ou uma implantação completa do AKS Edge Essentials em funcionamento (se você estiver usando uma câmera IP ONVIF real, deverá criar uma implantação completa com um comutador externo).
  • O Akri só funciona no Linux: use nós do Linux para este exercício.
  • Uma câmera IP ONVIF conectada à mesma rede que o cluster do comutador externo ou um contêiner ONVIF fictício em execução (etapas de implantação da seguinte maneira).

Observação

Este agente ONVIF de exemplo atualmente não dá suporte à conexão com câmeras que exigem autenticação. Para executar essa demonstração, desabilite a autenticação em sua câmera ONVIF.

Simular contêiner ONVIF

Se você não tiver uma câmera IP ONVIF, poderá usar nosso contêiner ONVIF fictício para este exercício. O contêiner fictício funciona em um único computador ou em uma implantação completa.

  1. (Opcional) Se você quiser configurar um feed de vídeo RTSP personalizado para seu contêiner ONVIF, salve o vídeo mp4 (funciona melhor se a qualidade for SD em vez de HD) e copie o arquivo do diretório do computador host para o nó do Linux usando o seguinte comando (substitua o diretório do computador host e o nome do arquivo de vídeo apropriado):

    Copy-AksEdgeNodeFile -FromFile C:\Users\WinIotUser\Downloads\sample.mp4 -toFile /home/aksedge-user/sample.mp4 -PushFile

  2. Abra um arquivo YAML vazio e copie/cole o conteúdo a seguir. Substitua o valor depois /mnt/ pelo nome do arquivo de vídeo em MP4FILE. Salve o arquivo como onvif-mock.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: onvif-camera-mocking
spec:
  replicas: 1
  selector:
    matchLabels:
      app: onvif-camera-mocking
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
  minReadySeconds: 5    
  template:
    metadata:
      labels:
        app: onvif-camera-mocking
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: azure-vote-front
        image: winiotsaleskit.azurecr.io/onvif-camera-mocking:latest
        ports:
        - containerPort: 8554
        - containerPort: 1000
        - containerPort: 3702
        env:
        - name: INTERFACE
          value: "eth0"
        - name: DIRECTORY
          value: "/onvif-camera-mock"
        - name: MP4FILE
          value: /mnt/sample.mp4 
        volumeMounts:
        - name: sample-volume
          mountPath: /mnt
      volumes:
      - name: sample-volume
        hostPath:
          path: /home/aksedge-user
          type: Directory

  3. Aplique o YAML e verifique se o pod está em execução:

    kubectl apply -f onvif-mock.yaml
kubectl get pods

  4. Para habilitar as regras de IP para que essa câmera ONVIF fictícia seja descoberta:

    • Se sua CNI for Flannel:

      Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo ip route add 239.255.255.250/32 dev cni0"

    • Se sua CNI for Calico:

      1. Localize o IP do contêiner ONVIF fictício:

        kubectl get pods -o wide

      2. Localize o nome do adaptador de rede que corresponde ao IP do pod ONVIF (ou seja, cali909b8c65537):

        Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "route"

      3. Agora, habilite a descoberta de ONVIF:

        Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo ip route add 239.255.255.250/32 dev <insert interface name>"

    • Além disso, se você estiver executando uma implantação completa com um comutador externo, habilite e dport 3702 salve as tabelas de IP:

      Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo iptables -A INPUT -p udp --dport 3702 -j ACCEPT"
Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo sed -i '/-A OUTPUT -j ACCEPT/i-A INPUT -p udp -m udp --dport 3702 -j ACCEPT' /etc/systemd/scripts/ip4save"

Agora você está pronto para executar a Akri e descobrir a câmera ONVIF fictícia.

Executar o Akri

  1. Adicione os gráficos do Akri Helm se você ainda não tiver:

    helm repo add akri-helm-charts https://project-akri.github.io/akri/

    Se você já adicionou o gráfico do Helm do Akri anteriormente, atualize seu repositório para a compilação mais recente:

    helm repo update

  2. Instale o Akri usando o Helm. Ao instalar o Akri, especifique que você deseja implantar os manipuladores de descoberta ONVIF definindo o valor onvif.discovery.enabled=truehelm . Além disso, especifique que você deseja implantar o agente de vídeo ONVIF:

    helm install akri akri-helm-charts/akri `
 --set onvif.discovery.enabled=true `
 --set onvif.configuration.enabled=true `
 --set onvif.configuration.capacity=2 `
 --set onvif.configuration.brokerPod.image.repository='ghcr.io/project-akri/akri/onvif-video-broker' `
 --set onvif.configuration.brokerPod.image.tag='latest'

    Saiba mais sobre as definições de configuração do ONVIF aqui.

Abrir a porta WS-Discovery

Para que o cluster do AKS Edge Essentials descubra sua câmera, abra a porta para WS-Discovery (Descoberta Dinâmica de Serviços Web), que é um protocolo de descoberta multicast que opera pela porta 3702TCP e UDP.

  1. Execute o seguinte comando para abrir sport 3702 dentro do nó do Linux e salvar as tabelas de IP:

    Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo iptables -A INPUT -p udp --sport 3702 -j ACCEPT"
Invoke-AksEdgeNodeCommand -NodeType "Linux" -command "sudo sed -i '/-A OUTPUT -j ACCEPT/i-A INPUT -p udp -m udp --sport 3702 -j ACCEPT' /etc/systemd/scripts/ip4save"

  2. Verifique se o Akri agora pode descobrir sua câmera. Você deverá ver uma instância do Akri para sua câmera ONVIF:

    kubectl get akrii

    Captura de tela mostrando a instância do Akri para a câmera ONVIF descoberta.

Implantar aplicativo Web de streaming de vídeo

  1. Abra um arquivo YAML em branco e copie/cole o seguinte conteúdo no arquivo:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: akri-video-streaming-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: akri-video-streaming-app
  template:
    metadata:
      labels:
        app: akri-video-streaming-app
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      serviceAccountName: akri-video-streaming-app-sa
      containers:
      - name: akri-video-streaming-app
        image: ghcr.io/project-akri/akri/video-streaming-app:latest-dev
        imagePullPolicy: Always
        env:
        - name: CONFIGURATION_NAME
          value: akri-onvif
---
apiVersion: v1
kind: Service
metadata:
  name: akri-video-streaming-app
  namespace: default
  labels:
    app: akri-video-streaming-app
spec:
  selector:
    app: akri-video-streaming-app
  ports:
  - name: http
    port: 80
    targetPort: 5000
  type: NodePort
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: akri-video-streaming-app-sa
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: akri-video-streaming-app-role
rules:
- apiGroups: [""]
  resources: ["services"]
  verbs: ["list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: akri-video-streaming-app-binding
roleRef:
  apiGroup: ""
  kind: ClusterRole
  name: akri-video-streaming-app-role
subjects:
  - kind: ServiceAccount
    name: akri-video-streaming-app-sa
    namespace: default

  2. Salve o arquivo como akri-video-streaming-app.yaml.

  3. Na janela do PowerShell, altere o diretório para o local do arquivo akri-video-straming-app.yaml e implante-o no cluster:

    kubectl apply -f akri-video-streaming-app.yaml

  4. Verifique se todos os pods estão em execução:

    Captura de tela mostrando os pods do Akri e o pod do aplicativo de vídeo em execução.

  5. Localize o IP do nó do Linux e a porta do serviço de aplicativo Web:

    Get-AksEdgeNodeAddr

    kubectl get svc

    Captura de tela mostrando o endereço do nó e a porta do serviço de aplicativo Web.

  6. Agora você pode exibir as imagens de vídeo navegando até seu aplicativo Web, que é <NODE IP>:<PORT OF SERVICE>:

    Captura de tela mostrando imagens de transmissão ao vivo da câmera IP sendo exibidas no aplicativo Web.

Limpar

  1. Exclua o aplicativo Web de streaming de vídeo:

    kubectl delete -f akri-video-streaming-app.yaml

  2. Desinstale o Akri do cluster:

    helm delete akri

  3. (Opcional) Se você usou a câmera ONVIF fictícia, exclua a implantação:

    kubectl delete -f onvif-mock.yaml

Próximas etapas

Visão geral do AKS Edge Essentials