Manage Azure AI Video Indexer extensions for real-time analysis - Preview

To create a Video Indexer extension that supports real-time analysis in the Azure portal, complete the following steps:

1. In the Azure portal, go to your Azure Arc-connected Kubernetes cluster.

2. On the Kubernetes cluster, under Settings, select Extensions.

3. Select Add > Azure AI Video Indexer Arc Extension.

4. Select Create.

5. On the Basic tab, provide the following information:

   Field	Value
   Subscription	Select the subscription for your extension.
   Resource group	Select the resource group for your extension.
   Region	Select the region to create the extension.
   Connected K8S cluster	Select the Azure Arc connected Kubernetes cluster.
   Extension name	Enter a name for your extension.
   Video indexer account ID	Select the Azure AI Video Indexer account that the extension connects to.
   Ingress endpoint	Enter the cluster endpoint, either an IP address or DNS name, to use as the API endpoint.
   Storage class name	Provide the storage class supported by your Kubernetes distribution. For example, use azurefile-cli for AKS. See Storage Classes in AKS for more info. For other distributions, see your Kubernetes documentation.
   Content type	Select the following options: • Live video to enable real-time analysis • Media uploads to allow upload media files to the extension

   

6. Select Next.

7. On the Processing + AI tab, provide the following information:

   Field	Description
   Agentic capabilities	Includes advanced video investigation capabilities. Requires two dedicated H100 GPUs. Toggle to enable or disable.
   Summarization capabilities	Includes advanced vision event summary capabilities. Requires a dedicated H100 GPU. Toggle to enable or disable.
   Processing	Live video requires four GPU units: one dedicated to live streaming, two for agentic capabilities, and one for summarization capabilities. Media uploads requires one GPU unit for summarization capabilities.
   Toleration Key for GPU	Enter the toleration key for GPU nodes (for example, nvidia.com/gpu). Required for GPU workloads.
   Node selector (optional)	If there are multiple GPU node types, you can add a node selector to select the desired node. Specify the node name and value for each of the following (optional): Live video stream Agentic capabilities Summarization capabilities

   

8. Select Review + create > Create.

Use the following Bicep template to create a Video Indexer extension that supports real-time analysis. The template includes all the necessary parameters and configurations to deploy the extension on your Azure Arc connected Kubernetes cluster. Name the file vi.arcextension.template.bicep.

param accountId string = '<enter_vi_account_id>'
param videoIndexerEndpointUri string = '<enter_endpoint_uri>'
param arcConnectedClusterName string = '<enter_arc_cluster_name>'
param extensionName string = '<extension_name>'
param releaseTrain string = 'preview'
param version string = '1.2.53'
param useGpuForSummarization bool = false
param nodeSelectorForSummarization object = { }
param nodeSelectorForLiveSummarization object = { }
param deepstreamNodeSelector string = ''
param tolerationsKeyForGpu string = 'nvidia.com/gpu'
param liveSummarizationEnabled bool = true

var storageClass = '<storage_class_name>'

var baseConfigProperties = {
  'videoIndexer.endpointUri': videoIndexerEndpointUri
  'videoIndexer.accountId': accountId
  'videoIndexer.mediaFilesEnabled': string(true)
  'videoIndexer.liveStreamEnabled': string(true)
  'mediaServerStreams.enabled': string(true)
  'storage.storageClass': storageClass
  'storage.accessMode': 'ReadWriteMany'
  'ViAi.gpu.enabled': string(useGpuForSummarization)
  'ViAi.gpu.tolerations.key': tolerationsKeyForGpu
  'ViAi.LiveSummarization.enabled': string(liveSummarizationEnabled)
}

var summarizationNodeSelectorProps = reduce(
  items(nodeSelectorForSummarization),
  {},
  (cur, next) => union(cur, {'ViAi.gpu.nodeSelector.${next.key}': next.value})
)

var liveSummarizationNodeSelectorProps = reduce(
  items(nodeSelectorForLiveSummarization),
  {},
  (cur, next) => union(cur, {'ViAi.LiveSummarization.gpu.nodeSelector.${next.key}': next.value})
)

var deepstreamNodeSelectorProps = !empty(deepstreamNodeSelector) && deepstreamNodeSelector != ' ' ? {
  'viai.deepstream.nodeselector': deepstreamNodeSelector
} : {}

var extensionConfigPropertiesWithSelector = union(
  baseConfigProperties,
  summarizationNodeSelectorProps,
  liveSummarizationNodeSelectorProps,
  deepstreamNodeSelectorProps
)
resource connectedCluster 'Microsoft.Kubernetes/connectedClusters@2024-01-01' existing = {
  name: arcConnectedClusterName

}
resource extension 'Microsoft.KubernetesConfiguration/extensions@2022-11-01' = {
  name: extensionName
  scope: connectedCluster
  identity: {
    type: 'SystemAssigned'
  }
  properties: {
    extensionType: 'microsoft.videoindexer'
    autoUpgradeMinorVersion: false
    releaseTrain: releaseTrain
    version: version
    scope: {
      cluster: {}
    }
    configurationSettings: extensionConfigPropertiesWithSelector
  }
}

output result string = extension.properties.provisioningState

Edit parameters

After you save the Bicep file, edit the following parameters:

Use the following parameters as input for the extension creation command:

Create the extension

To create a VI extension for real-time analysis, run the following command with your parameters:

az deployment group create -g \<resource group\> --template-file \<template file\>

Use the Azure CLI to create a Video Indexer extension that supports real-time analysis. The following parameters are input to the extension creation command:

To create a Video Indexer extension for real-time analysis, run the following command with your parameters as explained in the previous table.

az k8s-extension create
--name <extension_name>
--extension-type "Microsoft.videoIndexer"
--scope cluster
--release-namespace "video-indexer"
--cluster-name <cluster_name>
--resource-group <cluster_resource_group>
--cluster-type "connectedClusters"
--version "1.2.0"
--release-train "preview"
--auto-upgrade-minor-version "false"
--config "videoIndexer.accountId=<account_id>"
--config "videoIndexer.endpointUri=<endpoint>"
--config AI.nodeSelector."beta\.kubernetes\.io/os"=linux
--config "storage.storageClass=azurefile-csi"
--config "storage.accessMode=ReadWriteMany"
--config "ViAi.gpu.enabled=true"
--config "ViAi.gpu.tolerations.key=nvidia.com/gpu"
--config videoIndexer.liveStreamEnabled=true
--config videoIndexer.mediaFilesEnabled=true
--config "ViAi.LiveSummarization.enabled=true"
--config "ViAi.LiveSummarization.gpu.nodeSelector.workload=summarization"
--config "ViAi.gpu.nodeSelector.workload=summarization"

Other parameters

Here are some other parameters that can be used in order to have a fine grain control on the extension creation:

Example deployment script

az k8s-extension create --name videoindexer \
    --extension-type Microsoft.videoindexer \
    .......

    --config AI.nodeSelector."beta\\.kubernetes\\.io/os"=linux
    --config "videoIndexer.webapi.resources.requests.mem=4Gi"\
    --config "videoIndexer.webapi.resources.limits.mem=8Gi"\
    --config "videoIndexer.webapi.resources.limits.cpu=1"\
    --config "storage.storageClass=azurefile-csi"