Azure IoT Akri: Kubernetes Resource Interface Deep Dive (Updated 2026)

Azure IoT Akri: Kubernetes Resource Interface Deep Dive (Updated 2026)

Akri Kubernetes Resource Interface: 2026 Deep Dive into Leaf-Device Discovery, Project Status and Alternatives

A Kubernetes cluster knows everything about its nodes and almost nothing about the hundreds of cameras, programmable logic controllers and USB sensors wired to them. Those leaf devices cannot run a kubelet, yet every edge workload exists to read them. Akri Kubernetes integration was built to close that gap: it discovers leaf devices, turns each one into a schedulable Kubernetes resource, and runs a broker pod against it automatically.

This matters again in 2026 for three reasons. The open-source project shipped v0.14.0 in September 2026 after a long quiet spell, Microsoft now sells a commercial derivative inside Azure IoT Operations, and Kubernetes Dynamic Resource Allocation (DRA) has gone GA as a more general device API. Architects need to know which of the three to bet on.

You will leave with the internals of Akri, a worked OPC UA walkthrough, capacity arithmetic, a verified status check, and a decision tree that places Akri against its alternatives.

What this covers: history and project health, the Agent, Controller, Discovery Handler and broker model, the Configuration and Instance custom resources, a step-by-step discovery lifecycle, Azure IoT Operations Akri services, DRA and KubeEdge alternatives, failure modes and a practical adoption checklist.

Context and Background

Akri stands for “A Kubernetes Resource Interface”, and the word also means “edge” in Greek. Microsoft’s Azure IoT edge team open-sourced it in 2020, and it was accepted into the Cloud Native Computing Foundation (CNCF) at the Sandbox maturity level on 14 September 2021, according to the CNCF project page. Sandbox is the entry tier of the CNCF ladder: the foundation hosts the project, but makes no promise about production readiness.

The problem Akri addressed was concrete. Before it, a team that wanted a pod per IP camera wrote a gateway deployment with a static ConfigMap of IP addresses. When a camera was replaced, its address changed and the gateway quietly read nothing. When a node died, nobody rescheduled the gateway onto another node that could also reach the camera. Every protocol needed its own bespoke glue.

Kubernetes already had one mechanism for non-CPU hardware: the device plugin framework, which lets a vendor advertise extended resources such as nvidia.com/gpu to the kubelet. Device plugins, however, assume hardware physically inside the node and a fixed inventory. Akri’s insight was to reuse the device plugin interface but drive it from dynamic discovery. Network devices, like an OPC UA server on a subnet, are advertised the same way as local devices, like a USB webcam.

The incumbents around Akri fall into three groups. Edge Kubernetes distributions such as K3s and MicroK8s give you the cluster but no device model; our comparison of KubeEdge, K3s and MicroK8s for edge Kubernetes covers that layer. KubeEdge ships its own device custom resources and protocol “mappers”. Industrial connectivity products, from OPC UA gateways to unified namespace platforms, solve protocol translation but not Kubernetes scheduling.

The old version of this article claimed Akri’s releases had stalled at 0.12.x in late 2022. That was wrong, and it is worth correcting precisely. The release history on GitHub shows v0.12.20 in March 2024 and v0.13.8 in November 2024. After a roughly 21-month gap, v0.14.0 shipped on 1 September 2026. It raised the minimum Kubernetes version from 1.16 to 1.33, moved to kube-rs 1.0 and Rust 1.88, cleared several RUSTSEC advisories and listed 16 contributors, per the v0.14.0 release notes. The project is not archived; it is low-velocity but alive.

My thesis for this post is narrower than most coverage. Akri’s lasting value is its discovery-to-scheduling pattern, not its codebase. You can run upstream Akri today, but you should choose it knowing that Azure IoT Operations has forked the API and that DRA is becoming the standard path for anything local to a node.

Akri Kubernetes Reference Architecture

Direct answer: Akri is a set of Kubernetes controllers that discover leaf devices and expose each as a schedulable resource. A per-node Agent runs pluggable Discovery Handlers for protocols such as udev, OPC UA and ONVIF, records each found device as an Instance custom resource, registers it with the kubelet through the device plugin API, and a Controller schedules broker pods against it.

Akri Kubernetes reference architecture with Agent, Discovery Handlers, Controller, Configuration and Instance CRDs and broker pods

Figure 1: Akri Kubernetes component architecture. A Configuration tells every Agent what to look for; Discovery Handlers probe leaf devices and stream results to the Agent; the Agent writes Instances and registers device plugins with the kubelet; the Controller turns Instances into broker pods and Services.

Read the figure from the top. An operator applies a Configuration, which is the only object a user normally writes. The Agent, a DaemonSet on every participating node, watches Configurations and asks the matching Discovery Handler to search. Results come back over gRPC. For each device the Agent creates or updates an Instance and registers a device plugin, so the kubelet sees a new extended resource named under akri.sh/. The Controller, a single Deployment, watches Instances and creates broker pods and Services. Brokers are ordinary containers you supply; they open the actual protocol session.

Four components, two custom resources

The Agent is written in Rust and does three jobs. It watches Configuration objects, hosts the registration service that Discovery Handlers connect to, and implements one device plugin per discovered device. Device plugins talk to the kubelet over the standard Unix socket under /var/lib/kubelet/device-plugins/. That reuse is the core trick: the scheduler already knows how to place a pod that requests an extended resource, so Akri never needs a custom scheduler.

Discovery Handlers implement a DiscoveryHandler gRPC service defined in Akri’s discovery.proto. Since v0.4.0 they run as separate DaemonSets rather than inside the Agent, which isolates protocol libraries and lets the community add handlers without touching the Agent. The upstream project ships udev, OPC UA, ONVIF and a debug-echo handler for testing, per the project README.

The Controller owns the workload side. It creates broker pods (or, since the v0.10 line, Kubernetes Jobs for one-shot work), plus two optional Services. It also cleans up brokers whose Instance has disappeared. The admission webhook validates Configurations before they are stored; v0.14.0 extended it to check device mount permissions for udev.

The two custom resources live in the akri.sh/v0 API group. A Configuration declares the discovery handler name, an opaque discoveryDetails string the handler parses, optional discoveryProperties pulled from Secrets or ConfigMaps, a capacity, and a brokerSpec that holds either a brokerPodSpec or a brokerJobSpec. It can also define an instanceServiceSpec, a configurationServiceSpec and brokerProperties that are injected into brokers as environment variables. An Instance represents one discovered device and is managed by the Agent; you should treat it as read-only.

Why the device plugin API, and what it costs

Mapping devices onto the device plugin API buys three things for free. The scheduler handles placement, quotas and requests exactly as it does for GPUs. The kubelet handles allocation and injects environment variables and mounts at container start. And standard tooling, from kubectl describe node to cluster autoscalers, can see the resource without Akri-specific plugins.

The cost is expressiveness. The device plugin API models resources as countable, opaque integers per node. It has no notion of device attributes, so you cannot ask the scheduler for “any camera with resolution above 1080p on VLAN 30” through the resource request itself. Akri works around that with filters in discoveryDetails and with one resource name per Configuration, but filtering happens at discovery time, not at scheduling time. This is precisely the gap that DRA fills, which we return to later.

Shared devices, slots and the capacity knob

Akri distinguishes local devices, which only one node can see, from shared devices, which several nodes can reach. A USB camera is local. An ONVIF camera on a flat network is shared: every Agent on that subnet will find it. To avoid three brokers hammering one camera, Akri names Instances deterministically. For unshared devices the Instance ID is a hash of the device descriptor plus the node name; for shared devices it hashes only the descriptor, so every Agent arrives at the same Instance name, per the Akri documentation on requesting resources.

Each Instance carries a deviceUsage map with one slot per unit of capacity. When the kubelet calls the device plugin’s Allocate, the Agent tries to claim a slot for its node and refuses if another node holds it. The Instance’s nodes list records which nodes can currently see the device. The result is a distributed lock implemented on top of a custom resource, with the API server’s optimistic concurrency doing the arbitration.

How Akri Discovery Works End to End

The architecture diagram shows structure; the lifecycle is where most debugging time goes. This section walks one OPC UA server from discovery to removal, then works through capacity numbers and a broker request.

Akri Kubernetes discovery sequence from Configuration apply through Instance creation, device plugin allocation and broker teardown

Figure 2: Lifecycle of one OPC UA server under Akri. Discovery results stream from the handler to the Agent, the Agent writes an Instance and registers a device plugin, the Controller creates the broker, and the reverse path runs when the server disappears.

The sequence has four phases. In watch, the Agent sees a new Configuration and opens a Discover stream to the registered OPC UA handler, passing the discoveryDetails string. In discovery, the handler queries one or more OPC UA Local Discovery Servers (LDS), by default opc.tcp://localhost:4840/, applies application-name filters, and streams back the matching servers. In advertise, the Agent writes an Instance per server and registers a device plugin with the kubelet. In schedule, the Controller creates a broker pod that requests the Instance’s resource; the kubelet calls Allocate, the Agent reserves a slot, and the container starts with the server’s endpoint URL in an environment variable.

Removal runs the same path backwards. When the handler stops reporting a server, the Agent does not delete the Instance immediately. Network devices blink in and out, so the Agent waits through a grace period before removing the Instance; the Controller then deletes the broker and Services. Local udev devices are removed promptly because the kernel event is unambiguous.

Step 1: install Akri with the OPC UA handler

The Helm chart is the supported install path. The repository URL and value names below are from the Akri OPC UA discovery handler documentation. The project validated v0.14.0 against Kubernetes 1.33, 1.34 and 1.36, including K3s and MicroK8s builds of those versions.

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

helm install akri akri-helm-charts/akri \
  --namespace akri --create-namespace \
  --set opcua.discovery.enabled=true \
  --set opcua.configuration.enabled=true \
  --set opcua.configuration.name=opcua-plc \
  --set opcua.configuration.discoveryDetails.discoveryUrls[0]="opc.tcp://10.20.0.5:4840/" \
  --set opcua.configuration.discoveryDetails.applicationNames.action=Include \
  --set opcua.configuration.discoveryDetails.applicationNames.items[0]="Line3-Filler" \
  --set opcua.configuration.mountCertificates=true \
  --set opcua.configuration.brokerPod.image.repository=ghcr.io/example/opcua-mqtt-broker \
  --set opcua.configuration.brokerPod.image.tag=1.4.2

Three choices in that command deserve explanation. Pointing discoveryUrls at a specific LDS, rather than relying on localhost, matters on clusters where the nodes are not the machines that host the OPC UA servers. The Include filter restricts the scan to the one application you mean, which avoids accidentally attaching brokers to an engineering workstation that also happens to run an OPC UA server. And mountCertificates=true mounts a Secret named opcua-broker-credentials into each broker at /etc/opcua-certs/client-pki. You create that Secret yourself with the keys client_certificate, client_key, ca_certificate and ca_crl. The broker image name is illustrative; Akri moved its sample brokers to a separate project-akri/examples repository in v0.14.0.

Step 2: read what Helm generated

The Helm values render into a Configuration. The shape below follows the akri.sh/v0 CRD; field placement can shift between releases, so diff it against the CRD shipped with your chart version before you hand-write one.

apiVersion: akri.sh/v0
kind: Configuration
metadata:
  name: opcua-plc
  namespace: akri
spec:
  discoveryHandler:
    name: opcua
    discoveryDetails: |
      opcuaDiscoveryMethod:
        standard:
          discoveryUrls:
          - opc.tcp://10.20.0.5:4840/
      applicationNames:
        action: Include
        items:
        - Line3-Filler
  capacity: 1
  brokerSpec:
    brokerPodSpec:
      containers:
      - name: opcua-broker
        image: ghcr.io/example/opcua-mqtt-broker:1.4.2
        resources:
          requests:
            memory: 64Mi
            cpu: 50m
          limits:
            memory: 128Mi
            cpu: 200m
  instanceServiceSpec:
    type: ClusterIP
    ports:
    - name: grpc
      port: 80
      targetPort: 8083
  configurationServiceSpec:
    type: ClusterIP
    ports:
    - name: grpc
      port: 80
      targetPort: 8083

Note that discoveryDetails is a string containing YAML, not a nested object. The API server cannot validate its contents, which is exactly why the admission webhook exists. A typo inside that block passes schema validation and then silently discovers nothing, so enable the webhook in every environment.

Step 3: verify discovery and allocation

kubectl -n akri get akric          # Configurations
kubectl -n akri get akrii -o wide  # Instances, with nodes and shared flag
kubectl get node edge-01 -o jsonpath='{.status.allocatable}' | tr ',' '\n' | grep akri
kubectl -n akri get pods -l akri.sh/configuration=opcua-plc

The node’s allocatable list should show a resource named akri.sh/opcua-plc-<hash> with a count equal to the Configuration’s capacity. Broker pods carry labels akri.sh/configuration, akri.sh/instance and akri.sh/target-node, which are the fastest way to correlate a misbehaving broker with the device and node behind it.

Step 4: consume a device from your own workload

You do not have to let the Controller create brokers. If you omit the broker image, Akri only discovers and advertises, and your own Deployment can request the resource. A pod can ask for one specific device or for any device that a Configuration found.

# Any OPC UA server matched by the opcua-plc Configuration
resources:
  requests:
    akri.sh/opcua-plc: "1"
  limits:
    akri.sh/opcua-plc: "1"

Configuration-level requests let the Agent choose an available Instance, which is the right default for stateless processing. Instance-level requests, using the full akri.sh/opcua-plc-<hash> name, pin a workload to one machine. The hash is stable for a given device descriptor, so GitOps manifests can reference it, but it changes if the server’s endpoint URL changes.

Capacity arithmetic: a worked example

Consider an illustrative line with 3 edge nodes on one flat network, 12 ONVIF cameras, and a vision model that needs 2 brokers per camera for redundancy. All 3 nodes discover all 12 cameras, so each camera becomes one shared Instance with nodes listing all three.

Set capacity: 2. Each Instance gets 2 deviceUsage slots, so the cluster can run at most 12 × 2 = 24 brokers. The scheduler sees each node advertising akri.sh/onvif-camera-<hash>: 2 for every camera, which is 24 per node and 72 advertised units in total, but only 24 can ever be allocated because slot claims are cluster-wide. That mismatch is normal: advertised capacity is per node, enforced capacity is per Instance.

Now the memory budget. If each broker decodes one H.264 stream and holds 250 MB resident, 24 brokers need about 6 GB of memory across the three nodes, or 2 GB per node if balanced. Akri does not balance for you; the scheduler places brokers using normal resource requests, so set realistic memory requests on the broker pod spec or one node will collect all of them. If a node fails, its brokers’ slots are released once the kubelet stops reporting them, and the Controller recreates brokers on the surviving nodes, which then need 3 GB each. Size for N−1, not N.

Discovery load matters too. The ONVIF handler uses a discovery timeout that defaults to one second and repeats discovery periodically. On a network with hundreds of cameras, multicast WS-Discovery probes from every node on every cycle add up. Filter by IP range, MAC address or ONVIF scope in discoveryDetails to keep each Configuration narrow.

Akri in Azure IoT Operations: Same Name, Different API

Most production use of the Akri pattern in 2026 is not upstream Akri at all. Azure IoT Operations, which reached general availability in November 2024, includes what Microsoft calls Akri services: an Akri operator, a set of Akri connectors and an Akri Azure Device Registry service.

Comparison of CNCF Akri Kubernetes with Azure IoT Operations Akri services, connector templates, Azure Device Registry and MQTT data flows

Figure 3: CNCF Akri versus Azure IoT Operations Akri services. Upstream Akri stops at scheduling your broker; the Azure variant adds Microsoft-built connectors, a cloud-synced device and asset registry, and a built-in MQTT path, all managed through an Azure Arc-enabled cluster.

Microsoft’s Akri services overview describes them as a Microsoft-managed commercial version of the CNCF project with enterprise features and support. It also states plainly that the Azure IoT Operations Akri API currently differs from the CNCF project’s API. A Configuration written for upstream Akri will not deploy on Azure IoT Operations, and the reverse is also true.

The workflow is template-driven rather than discovery-first. An IT administrator creates a connector template in the Azure portal or Azure CLI. The template syncs to the edge cluster, and the Akri operator detects it. An operational technology (OT) user then defines a device and inbound endpoint in the operations experience portal, and the operator deploys a matching connector instance. That instance receives an identity, MQTT broker connection details, an OpenTelemetry endpoint and mounted secrets. Optional asset discovery lets connectors create custom resources for what they find, such as one per ONVIF media profile, which the OT user then reviews and onboards.

The Microsoft-provided connectors cover OPC UA telemetry and commands, ONVIF events and pan-tilt-zoom control, a media connector for video and snapshots, HTTP/REST and server-sent events. The Azure IoT Operations 2603 release (v1.3.38), announced in April 2026, added an MQTT connector for onboarding MQTT devices as assets and made the OPC UA connector optionally deployable. For protocols Microsoft does not cover, the Azure/iot-operations-sdks repository publishes connector frameworks, including a Rust crate that handles device and asset lifecycle from Azure Device Registry.

What changes architecturally

Three differences matter more than the API mismatch. First, the broker is no longer yours. Upstream Akri schedules a container you wrote and leaves protocol translation to you; Azure’s connectors do the translation and publish to the built-in MQTT broker. That removes a large engineering burden but also removes control over payload shape and session behaviour.

Second, the source of truth moves to the cloud. Device and asset definitions live in Azure Device Registry and sync down through Azure Arc. That suits fleets managed centrally, and it creates a hard dependency on Arc connectivity for configuration changes, though data flows keep running locally during an outage.

Third, discovery becomes a suggestion, not an action. Upstream Akri schedules a broker the moment a matching device appears. The Azure flow surfaces discovered assets for a human to approve. In regulated plants, where an unreviewed connection to a safety-relevant controller is unacceptable, that review step is a feature rather than friction.

Which one is “Akri” in 2026?

If you search for Akri today, half of what you find describes the Azure product. The honest framing is that there are now two lineages. CNCF Akri is a small, community-maintained Sandbox project with a generic broker model and a Kubernetes-native API. Azure IoT Operations Akri services are a supported product that share the name, the operator idea and the discovery heritage, but not the API. Pick deliberately; do not assume skills or manifests transfer.

Dynamic Resource Allocation, KubeEdge and Other Alternatives

Kubernetes Dynamic Resource Allocation graduated to GA in Kubernetes v1.34, announced on the Kubernetes blog on 1 September 2025, and its feature gate is locked on from v1.35. DRA replaces the integer-count model of device plugins with structured devices. A driver publishes ResourceSlices that list devices and their attributes; administrators define DeviceClasses with Common Expression Language (CEL) selectors; workloads create ResourceClaims, directly or through templates, and the scheduler allocates matching devices.

For Akri’s original problem, DRA is both better and narrower. It is better because attributes become schedulable. A claim can say “a camera device whose resolution attribute is at least 1920 and whose zone is line-3“, and the scheduler evaluates that. It also supports sharing a claim across pods, admin access for monitoring, and device taints for quarantining faulty hardware. Our guides to DRA GPU scheduling and the Kubernetes 1.37 DRA and device plugin changes go deeper on the mechanics.

It is narrower because DRA is an allocation API, not a discovery system. Somebody still has to find the OPC UA server on the network, decide which nodes can reach it, keep the ResourceSlice current as devices come and go, and run something that talks to the device. Akri’s Discovery Handlers and broker scheduling remain the missing half. As of November 2026 I found no published Akri roadmap item to move its Agent from the device plugin API to DRA, so treat any such migration as speculative.

Decision tree choosing between DRA drivers, Akri Kubernetes, Azure IoT Operations Akri connectors and KubeEdge device management

Figure 4: Decision tree for exposing leaf devices to Kubernetes in 2026. Node-local hardware with rich attributes points to DRA; network devices found by protocol scan point to Akri or its Azure derivative; KubeEdge clusters use their own device model.

KubeEdge device management

KubeEdge takes a different route. It defines device model and device instance custom resources in the cloud-side cluster and runs protocol-specific mappers on edge nodes that read and write device properties. The model is twin-oriented: desired and reported property values sync between cloud and edge, which suits fleets with intermittent connectivity. The trade-off is that devices are typically declared rather than discovered, and you adopt the whole KubeEdge runtime rather than adding a component to any conformant cluster.

Plain gateways and the unified namespace

Many plants never need devices to be Kubernetes resources. An OPC UA client or Modbus poller in a single Deployment, publishing to MQTT, is simpler and easier to certify. If your target is a unified namespace for industrial IoT, a gateway that reads a device list from Git can be enough. The brownfield Modbus retrofit gateway comparison shows that pattern. Kubernetes-level device resources earn their keep when the device population churns, when placement must follow physical reachability, or when per-device isolation matters.

Decision matrix

Need CNCF Akri v0.14 Azure IoT Operations Akri services DRA driver KubeEdge devices Plain gateway
Discover network devices automatically Yes, ONVIF and OPC UA Yes, with human review No, driver must implement Limited No
Node-local USB or PCI devices Yes, udev Not the focus Yes, best fit Via mappers Manual
Attribute-based scheduling No, filter at discovery Via asset definitions Yes, CEL selectors No No
Protocol translation included No, bring a broker Yes, Microsoft connectors No Yes, mappers Yes
Vendor support Community only Microsoft Varies by driver Community and vendors Varies
Cloud dependency None Azure Arc None KubeEdge cloud core None
API stability signal Sandbox, v0 API GA product GA in core Kubernetes CNCF Graduated project Your code

The matrix encodes my opinion, not a benchmark. The key reading is the bottom row: the more a decision will outlive this year, the more weight API stability deserves. Akri’s akri.sh/v0 API has not reached even v1alpha semantics in five years, which is a reasonable proxy for how much change you should expect.

Trade-offs, Gotchas, and What Goes Wrong

Low release velocity is the first risk. Between November 2024 and September 2026 there was no tagged release. That gap spanned several Kubernetes minor versions. v0.14.0 then jumped the minimum to Kubernetes 1.33 and broke embedders with dependency upgrades. If you pin Akri, plan to own patching for Rust crate advisories between releases, and budget for a breaking upgrade when the next release lands.

Discovery storms on large flat networks. Every Agent on every node runs its own discovery for every Configuration. With ONVIF on a /22 network with hundreds of cameras, the multicast probes and responses scale with node count multiplied by camera count. Narrow Configurations with IP or scope filters, and dedicate a node label so only a subset of nodes run the ONVIF handler.

Flapping devices churn brokers. A camera on a congested Wi-Fi link that misses discovery cycles can cross the removal grace period, lose its Instance, and get a new broker a minute later. Brokers that hold expensive state, such as a loaded vision model, pay that cost each time. Prefer wired links, keep broker start-up cheap, and put heavy inference in a separate Deployment that reads from the broker.

Device plugin re-registration after kubelet restarts. Device plugins must re-register when the kubelet restarts, and node upgrades restart it. v0.13.8 refactored the Agent so it no longer needs the container runtime socket for slot reconciliation. On older versions, check that slots recover cleanly after a kubelet restart before trusting a node upgrade.

Secrets live in broker pods. ONVIF credentials and OPC UA client certificates are mounted into every broker. A compromised broker image therefore holds credentials for real plant equipment. Use per-Configuration Secrets, read-only mounts and network policies, and follow the OPC UA certificate and security policy hardening guide for the client PKI itself.

udev rules grant real hardware access. A broad udev rule can expose block devices or serial ports you did not intend. The v0.14.0 webhook adds a mount-permission check, but write rules that match on vendor and product IDs, not on broad kernel subsystems.

The Azure fork is not an upgrade path. Teams sometimes assume they can start on upstream Akri and “graduate” to Azure IoT Operations. Because the APIs differ, that is a migration, not an upgrade. Configurations, brokers and operational runbooks all change.

Practical Recommendations

Start by deciding whether devices need to be Kubernetes resources at all. If your devices are a stable list of network endpoints and one gateway pod can serve them, skip Akri and keep the system simple. If devices churn, if workloads must follow physical reachability, or if each device needs its own isolated process, the Akri pattern earns its complexity.

For Azure-centric plants that already use Azure Arc, Azure IoT Operations Akri connectors are the lower-risk choice. You get supported OPC UA and ONVIF connectors, a device registry and an MQTT path, at the cost of an Azure dependency and less control over payloads. For vendor-neutral clusters, especially on K3s at small sites, upstream Akri v0.14 remains a sound discovery engine if you accept owning it. Our production guide to K3s at the edge covers the cluster side. For node-local accelerators and peripherals with attributes worth scheduling on, write or adopt a DRA driver instead of a device plugin.

Treat Akri as infrastructure you vendor. Mirror its images to your registry, pin chart versions, keep the CRD schema in Git, and run its webhook. Write brokers as thin protocol adapters that publish to MQTT or OPC UA PubSub, so replacing Akri later does not touch your analytics.

Checklist before production:

  • Pin the Akri chart and images to v0.14.0 or later, mirrored internally.
  • Confirm cluster Kubernetes version is 1.33 or newer.
  • Enable the admission webhook in every environment.
  • Scope each Configuration with IP, MAC, scope or application-name filters.
  • Set broker resource requests and size nodes for N−1 failure.
  • Store device credentials in per-Configuration Secrets with network policies around brokers.
  • Test kubelet restart and node drain recovery of deviceUsage slots.
  • Record an exit plan to DRA or Azure IoT Operations in your architecture decision record.

Frequently Asked Questions

Is Akri still maintained in 2026?

Yes, but at low velocity. Akri remains a CNCF Sandbox project and is not on the CNCF archived list. Its GitHub repository shows v0.13.8 in November 2024 and then v0.14.0 on 1 September 2026, which modernised the Rust and Kubernetes dependencies, raised the minimum Kubernetes version to 1.33, and listed 16 contributors. A 21-month gap between releases is a real signal, so plan to own patching. It is a usable component, not an abandoned one, and not a fast-moving one either.

What is the difference between Akri and Azure IoT Operations Akri services?

CNCF Akri is the open-source project: Configuration and Instance custom resources, an Agent, a Controller and Discovery Handlers that schedule brokers you write. Azure IoT Operations Akri services are Microsoft’s commercial version, with an Akri operator, connector templates, Microsoft-built connectors for OPC UA, ONVIF, media and REST, and Azure Device Registry integration. Microsoft documents that its Akri API currently differs from the CNCF API, so manifests and brokers do not transfer between them without rework.

Does Akri replace an OPC UA gateway?

No. Akri finds OPC UA servers through Local Discovery Servers and schedules a broker pod per server, but the broker does the protocol work. You still need an OPC UA client stack, security certificates, subscription logic and a northbound publisher such as MQTT. Akri replaces the static device list and manual placement around a gateway, not the gateway’s protocol engine. Commercial gateways add certified stacks, engineering tools and vendor support that Akri does not attempt to provide.

Should I use Kubernetes DRA instead of Akri?

Use DRA for hardware attached to a node whose attributes matter to scheduling, such as accelerators, cameras on specific ports or network interfaces. DRA has been GA since Kubernetes v1.34 and offers CEL selectors, shared claims and device taints. It does not discover devices on a network or run brokers against them, so it does not replace Akri’s discovery half. For network devices found by protocol scans, Akri or a vendor connector framework still fills the gap.

Which Kubernetes distributions does Akri support?

The v0.14.0 release notes list validation against upstream Kubernetes 1.33, 1.34 and 1.36, plus matching K3s and MicroK8s builds. Any conformant cluster at 1.33 or newer that supports the device plugin API should work. SUSE Edge also packages Akri as a Helm chart with a Rancher dashboard extension, though SUSE labels it a tech preview. Lightweight distributions suit Akri well because small edge clusters are where leaf devices concentrate.

Can Akri discover Modbus or other protocols?

Not out of the box. Upstream Akri ships udev, OPC UA, ONVIF and a debug-echo handler. Modbus TCP has no standard discovery mechanism comparable to OPC UA Local Discovery or ONVIF WS-Discovery, so a handler would need to scan address ranges or read an inventory. You can write a custom Discovery Handler by implementing the gRPC DiscoveryHandler service, and the project documents how. Many teams instead declare Modbus devices statically and reserve Akri for protocols with real discovery.

Further Reading

By Riju — about

3 Comments

Leave a Reply

Your email address will not be published. Required fields are marked *