Compartir a través de

Detección de cámaras ONVIF con Akri

  • Artículo

Akri es una interfaz de recursos de Kubernetes que permite exponer fácilmente dispositivos hoja heterogéneos (como cámaras IP y dispositivos USB) como recursos en un clúster de Kubernetes y detecta continuamente nodos que tienen acceso a estos dispositivos para programar cargas de trabajo basadas en ellos. Akri es un proyecto de espacio aislado CNCF realizado para el borde, controlando la apariencia dinámica y la desaparición de los dispositivos hoja. Actualmente admite protocolos OPC UA, ONVIF y udev, pero también puede implementar controladores de protocolo personalizados proporcionados por la plantilla. Obtenga más información sobre Akri aquí.

En este artículo se describe cómo puede detectar cámaras ONVIF conectadas a la misma red que el clúster de AKS Edge Essentials. ONVIF es un estándar abierto del sector para dispositivos de seguridad IP, que se suelen usar para la vigilancia de vídeo. Obtenga más información sobre los perfiles ONVIF aquí. Esta demostración le ayuda a empezar a usar Akri para detectar cámaras IP a través del protocolo ONVIF y usarlas a través de un agente de vídeo que le permite consumir las imágenes de la cámara y mostrarlas en una aplicación web.

Diagrama que muestra el flujo de la demostración de Akri ONVIF.

Requisitos previos

  • Una implementación de una sola máquina o una implementación completa de AKS Edge Essentials en funcionamiento (si usa una cámara IP ONVIF real, debe crear una implementación completa con un conmutador externo).
  • Akri solo funciona en Linux: use nodos de Linux para este ejercicio.
  • Una cámara IP ONVIF conectada a la misma red que el clúster de conmutadores externos o un contenedor ONVIF ficticio que se ejecuta (pasos de implementación como se indica a continuación).

Nota

Actualmente, este agente ONVIF de ejemplo no admite la conexión a cámaras que requieren autenticación. Para ejecutar esta demostración, deshabilite la autenticación en la cámara ONVIF.

Simulación de contenedor ONVIF

Si no tiene una cámara IP ONVIF, puede usar nuestro contenedor ONVIF ficticio para este ejercicio. El contenedor ficticio funciona en una sola máquina o en una implementación completa.

  1. (Opcional) Si desea configurar una fuente de vídeo RTSP personalizada para el contenedor ONVIF, guarde el vídeo mp4 (funciona mejor si la calidad es SD en lugar de HD) y copie el archivo del directorio del equipo host en el nodo de Linux mediante el siguiente comando (asegúrese de reemplazar el directorio de la máquina host y el nombre de archivo de vídeo adecuado):

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

  2. Abra un archivo YAML vacío y copie o pegue el contenido siguiente. Asegúrese de reemplazar el valor después /mnt/ por el nombre del archivo de vídeo en MP4FILE. Guarde el archivo 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 YAML y asegúrese de que el pod se está ejecutando:

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

  4. Para habilitar las reglas IP de esta cámara ONVIF ficticia que se va a detectar:

    • Si su CNI es Flannel:

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

    • Si su CNI es Calico:

      1. Busque la dirección IP del contenedor ONVIF ficticio:

        kubectl get pods -o wide

      2. Busque el nombre de la interfaz de red que coincida con la dirección IP del pod ONVIF (es decir cali909b8c65537, ):

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

      3. Ahora habilite la detección de ONVIF:

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

    • Además, si ejecuta una implementación completa con un conmutador externo, habilite dport 3702 y guarde las tablas 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"

Ahora ya está listo para ejecutar Akri y descubrir la cámara ONVIF simulada.

Ejecución de Akri

  1. Agregue los gráficos de Helm de Akri si aún no lo ha hecho:

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

    Si ya ha agregado el gráfico de Helm de Akri anteriormente, actualice el repositorio para la compilación más reciente:

    helm repo update

  2. Instale Akri mediante Helm. Al instalar Akri, especifique que desea implementar los controladores de detección de ONVIF estableciendo el valor onvif.discovery.enabled=truede Helm . Además, especifique que desea implementar el 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'

    Obtenga más información sobre los valores de configuración de ONVIF aquí.

Abra el puerto de WS-Discovery

Para que el clúster de AKS Edge Essentials detecte la cámara, abra el puerto para WS-Discovery (detección dinámica de servicios web), que es un protocolo de detección de multidifusión que funciona a través del puerto 3702TCP y UDP.

  1. Ejecute el siguiente comando para abrir sport 3702 en el nodo de Linux y guardar las tablas 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. Compruebe que Akri ahora puede detectar la cámara. Debería ver una instancia de Akri para la cámara ONVIF:

    kubectl get akrii

    Captura de pantalla que muestra la instancia de Akri para la cámara ONVIF detectada.

Implementación de una aplicación web de streaming de vídeo

  1. Abra un archivo YAML en blanco y copie o pegue el siguiente contenido en el archivo:

    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. Guarde el archivo como akri-video-streaming-app.yaml.

  3. En la ventana de PowerShell, cambie el directorio a la ubicación del archivo akri-video-straming-app.yaml e impleméntelo en el clúster:

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

  4. Asegúrese de que todos los pods están en funcionamiento:

    Captura de pantalla que muestra los pods de Akri y el pod de la aplicación de vídeo se está ejecutando.

  5. Busque la dirección IP del nodo de Linux y el puerto del servicio de aplicaciones web:

    Get-AksEdgeNodeAddr

    kubectl get svc

    Captura de pantalla que muestra la dirección del nodo y el puerto del servicio de aplicaciones web.

  6. Ahora puede ver el vídeo navegando a la aplicación web, que es <NODE IP>:<PORT OF SERVICE>:

    Captura de pantalla que muestra imágenes de streaming en vivo de la cámara IP que se muestra en la aplicación web.

Limpieza

  1. Elimine la aplicación web de streaming de vídeo:

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

  2. Desinstale Akri del clúster:

    helm delete akri

  3. (Opcional) Si usó la cámara ONVIF simulada, elimine la implementación:

    kubectl delete -f onvif-mock.yaml

Pasos siguientes

Introducción a AKS Edge Essentials