KubeEdge
KubeEdge extends Kubernetes so you can manage containerized workloads and connected devices at remote edge locations. It separates cloud-side control from edge-side execution, allowing edge nodes to keep running workloads when their cloud connection is unreliable.
itCloud native tools and technologies | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: KubeEdge
KubeEdge is Kubernetes wearing a sensible coat for remote places where the network behaves less like infrastructure and more like weather. The central Kubernetes control plane still declares what should exist. CloudCore carries the relevant workload and device state outward, while EdgeCore runs beside the workload or physical device. This is not a tiny Kubernetes control plane hidden in every shed, factory, or roadside cabinet. It is one control model stretched across an unreliable boundary.
The important bit is edge autonomy. MetaManager stores synchronized metadata locally, so Edged can keep managing a workload it already knows when the cloud-edge link disappears. That sounds reassuring because it is reassuring, up to the point where it is not magic. A disconnected node continues with its last available state. It cannot receive a new deployment, a changed Secret, or a new desired device command. The edge has not become independent; it has become temporarily committed to yesterday's mail.
The other useful idea is the device twin. A device model describes reusable properties, a device instance represents a real thing, and the twin keeps desired and reported property state. A mapper then translates between that model and the device's own protocol. Kubernetes does not need to learn how a sensor, controller, or appliance speaks. It states the intended condition, and the mapper performs the conversational diplomacy near the hardware.
The surprise is that the difficult part is usually not scheduling a container. It is deciding what remains safe while the desired state is stale, then proving that the cloud and edge agree again after reconnecting. KubeEdge also needs ordinary but non-negotiable foundations: a working Kubernetes control plane, a compatible container runtime, an address edge nodes can reach, and certificate coverage for that address. The machinery is quite willing to explain these requirements by refusing to join.
Read the Intro for the full architecture and its failure boundaries. Use Slides when you need the cloud-to-edge and device paths in one view. Keep the Cheatsheet nearby for module roles, compatibility checks, and a troubleshooting order. The Practice Reference and Exercise turn the key distinction into evidence: an existing workload may continue through a controlled disconnection, while a new cloud-side change waits for the link to return. That is the mental model to keep: Kubernetes declares, CloudCore distributes, EdgeCore stores and executes, and the mapper translates.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://kubeedge.io/
Supports
- KubeEdge is built on Kubernetes and extends containerized application orchestration to edge hosts
- Cloud-edge coordination supports bidirectional communication with edge nodes in private subnets
- Per-node metadata persistence supports autonomous edge operation during cloud disconnection
- KubeEdge supports x86, ARMv7, and ARMv8 environments
- https://kubeedge.io/docs/
Supports
- KubeEdge extends native containerized application orchestration and device management to edge hosts
- CloudCore includes CloudHub, EdgeController, and DeviceController responsibilities
- EdgeCore includes EdgeHub, Edged, EventBus, ServiceBus, DeviceTwin, and MetaManager responsibilities
- KubeEdge supports Kubernetes-native management and HTTP or MQTT applications
- https://kubeedge.io/docs/category/architecture/
Supports
- The architecture documentation provides component-level references for cloud, edge, and the shared Beehive framework
- CloudCore and EdgeCore separate central control integration from edge execution
- https://kubeedge.io/docs/setup/prerequisites/kubernetes
Supports
- An existing Kubernetes control plane is essential before deploying KubeEdge
- KubeEdge extends Kubernetes to network-unreliable and resource-constrained edge locations
- https://kubeedge.io/docs/setup/prerequisites/runtime/
Supports
- Each edge node needs a container runtime for EdgeCore installation and edge pod execution
- Runtime endpoint and cgroup settings depend on the selected CRI implementation
- Docker Engine requires cri-dockerd in current post-dockershim KubeEdge releases
- https://kubeedge.io/docs/setup/install-with-keadm/
Supports
- keadm installs cloud and edge components but does not install Kubernetes or its runtime environment
- keadm init deploys CloudCore on the cloud side
- keadm join installs EdgeCore and requires a CloudCore address
- CloudCore's advertised address must be reachable by edge nodes and is added to certificate subject alternative names
- CloudCore and EdgeCore should use the same KubeEdge version
- https://kubeedge.io/docs/architecture/edge/edged/
Supports
- Edged manages pod lifecycle on edge nodes
- Edged uses the Container Runtime Interface with OCI-compliant runtimes
- Edged manages probes, ConfigMaps, Secrets, volumes, images, and status
- Edged retrieves metadata through MetaManager and can use locally stored entries
- https://kubeedge.io/docs/architecture/edge/edgehub/
Supports
- EdgeHub communicates with CloudHub through WebSocket or QUIC
- EdgeHub routes messages between cloud and edge modules
- EdgeHub reports connection state to local module groups
- https://kubeedge.io/docs/architecture/edge/metamanager
Supports
- MetaManager processes messages between Edged and EdgeHub
- MetaManager stores and retrieves metadata from a local SQLite database
- MetaManager tracks cloud connection state and periodically synchronizes pod status
- https://kubeedge.io/docs/architecture/cloud/device_controller/
Supports
- DeviceController uses Kubernetes custom resources to describe device metadata and status
- Device models are reusable descriptions, while device instances represent actual devices
- DeviceController synchronizes desired state downstream and reported state upstream
- https://kubeedge.io/docs/concept/device/mapper/
Supports
- A mapper manages devices that use a particular protocol
- Mappers read, write, and report device data and status
- DeviceController, DeviceTwin, and mappers form the device-control path
- https://kubeedge.io/docs/developer/dmi/
Supports
- The Device Management Interface provides a unified connection between EdgeCore and mappers
- The architecture separates the device management plane from the device data plane
- Device data can flow directly to local consumers without always crossing the cloud-edge channel
- https://kubeedge.io/docs/advanced/inclusterconfig/
Supports
- Edge pods cannot normally reach the cloud Kubernetes API through standard in-cluster configuration across separated networks
- KubeEdge can provide edge-side Kubernetes API access by enabling MetaServer and required authorization features
- https://kubeedge.io/docs/faq/setup/
Supports
- CloudCore and EdgeCore logs are primary evidence for installation and runtime diagnosis
- CloudCore address reachability, firewall access, tokens, and certificate identity can prevent edge-node joins
- The CloudCore advertised address must align with the address EdgeCore uses and with certificate coverage
- CloudCore workload failures should be diagnosed through Kubernetes workload state and logs
- https://github.com/sindresorhus/awesome
Supports
- Discovery began from the maintained index of topic-specific awesome lists
- https://github.com/qijianpeng/awesome-edge-computing
Supports
- EdgeMesh, OpenYurt, K3s, and EdgeX Foundry are relevant projects in the edge-computing ecosystem
- EdgeMesh is associated with KubeEdge service communication
- OpenYurt and K3s provide alternative Kubernetes-oriented approaches for edge environments
- EdgeX Foundry provides device and application interoperability at the IoT edge
- https://edgemesh.kubeedge.io/
Supports
- EdgeMesh works with Kubernetes APIs and KubeEdge's edge API endpoint
- EdgeMesh deploys agents across nodes to support edge service communication
- The documentation covers proxying, security, gateways, and high availability
- https://openyurt.io/docs/
Supports
- OpenYurt manages distributed heterogeneous edge resources through a central control side
- YurtHub caches Kubernetes API state locally to support edge autonomy
- OpenYurt documents node pools, cross-node-pool networking, workload upgrades, and device-management integration
- https://docs.k3s.io/
Supports
- K3s is a lightweight, conformant Kubernetes distribution intended for edge, IoT, embedded, and air-gapped environments
- K3s packages control-plane and supporting components into a compact distribution
- https://docs.edgexfoundry.org/4.0.2/
Supports
- EdgeX Foundry is a vendor-neutral edge interoperability framework
- EdgeX device services connect sensors and devices, translate protocols and data, and support actuation
- The documentation provides guidance for building device services and connecting applications
- https://kubeedge.io/blog/archive/
Supports
- KubeEdge published release announcements from v0.2 in 2019 through v1.19 in 2024
- KubeEdge v1.2, v1.10, v1.12, v1.15, and v1.19 release dates are documented in the project archive
- https://kubeedge.io/blog/release-v1.7/
Supports
- KubeEdge v1.7 introduced alpha active-active CloudCore high availability support
- KubeEdge v1.7 introduced a device mapper framework
- https://kubeedge.io/blog/page/4
Supports
- KubeEdge v1.12 introduced alpha next-generation Device Management Interface support
- KubeEdge v1.12 added edge-node upgrades from the cloud and authorization for the edge Kubernetes API endpoint
- https://www.cncf.io/announcements/2024/10/15/cloud-native-computing-foundation-announces-kubeedge-graduation/
Supports
- KubeEdge was open sourced in November 2018
- KubeEdge entered the CNCF Sandbox in 2019, became incubating in September 2020, and graduated in October 2024
- https://www.cncf.io/projects/kubeedge/
Supports
- KubeEdge was accepted to CNCF on March 18, 2019, promoted to incubating on September 16, 2020, and graduated on September 11, 2024
- https://aws.amazon.com/greengrass/
Supports
- AWS IoT Greengrass is an edge runtime and cloud service for building, deploying, and managing device software
- https://docs.edgexfoundry.org/4.0/
Supports
- EdgeX Foundry provides an open framework for IoT edge computing
- EdgeX device services connect physical devices through protocol-specific services
