Convert Figma logo to code with AI

openyurtio logoopenyurt

OpenYurt - Extending your native Kubernetes to edge(project under CNCF)

1,693
398
1,693
41

Top Related Projects

Kubernetes Native Edge Computing Framework (project under CNCF)

1,453

The IoT Edge OSS project

27,843

Lightweight Kubernetes

Quick Overview

OpenYurt is an open-source project that extends Kubernetes to support edge computing scenarios. It provides a set of custom controllers and components that enable Kubernetes to manage and orchestrate applications running on edge nodes, even when they are disconnected from the central Kubernetes cluster.

Pros

  • Edge-Aware Workload Management: OpenYurt allows you to deploy and manage applications on edge nodes, even when they are disconnected from the central Kubernetes cluster.
  • Offline Capabilities: Edge nodes can continue to operate and serve applications even when they are disconnected from the central Kubernetes cluster.
  • Lightweight and Scalable: OpenYurt is designed to be lightweight and scalable, making it suitable for deployment in resource-constrained edge environments.
  • Seamless Integration with Kubernetes: OpenYurt extends the Kubernetes API and ecosystem, allowing you to leverage your existing Kubernetes knowledge and tooling.

Cons

  • Complexity: Integrating OpenYurt into an existing Kubernetes cluster may add complexity to the overall system architecture.
  • Limited Ecosystem: As an open-source project, the ecosystem around OpenYurt may not be as mature as some other Kubernetes-related projects.
  • Potential Performance Overhead: The additional components and controllers introduced by OpenYurt may add some performance overhead to the overall system.
  • Dependency on Kubernetes: OpenYurt is tightly coupled with Kubernetes, so any issues or changes in the Kubernetes ecosystem may impact the stability and functionality of OpenYurt.

Getting Started

To get started with OpenYurt, you can follow the official installation guide on the project's website. The guide covers the following steps:

  1. Install the OpenYurt controller manager on your Kubernetes cluster.
  2. Convert your Kubernetes nodes to "edge nodes" using the OpenYurt yurt-app-manager tool.
  3. Deploy your applications on the edge nodes using standard Kubernetes manifests.

Once you have OpenYurt set up, you can start exploring the various features and capabilities it provides for edge computing scenarios.

Competitor Comparisons

Kubernetes Native Edge Computing Framework (project under CNCF)

Pros of KubeEdge

  • More mature project with a larger community and ecosystem
  • Supports broader range of edge computing scenarios, including IoT devices
  • Offers advanced features like device management and edge-cloud message routing

Cons of KubeEdge

  • More complex architecture and setup compared to OpenYurt
  • Steeper learning curve for new users
  • May be overkill for simpler edge computing use cases

Code Comparison

KubeEdge configuration example:

apiVersion: cloudcore.kubeEdge.io/v1alpha1
kind: CloudCore
metadata:
  name: cloudcore
  namespace: kubeedge
spec:
  modules:
    cloudHub:
      advertiseAddress:
        - 10.10.102.78

OpenYurt configuration example:

apiVersion: apps.openyurt.io/v1alpha1
kind: YurtAppSet
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  workloadTemplate:
    deploymentTemplate:
      metadata:
        labels:
          app: nginx

Both projects aim to extend Kubernetes to edge environments, but KubeEdge offers a more comprehensive solution for complex edge computing scenarios, while OpenYurt focuses on simplicity and ease of use for cloud-edge application management. KubeEdge's code tends to be more detailed and feature-rich, while OpenYurt's configuration is often more straightforward and Kubernetes-like.

1,453

The IoT Edge OSS project

Pros of IoT Edge

  • Tightly integrated with Azure cloud services, offering seamless connectivity and management
  • Robust security features, including hardware-based security modules
  • Extensive documentation and community support

Cons of IoT Edge

  • Limited to Azure ecosystem, potentially less flexible for multi-cloud deployments
  • May have higher operational costs due to Azure-specific pricing models
  • Steeper learning curve for users not familiar with Azure services

Code Comparison

OpenYurt:

func (e *EdgeNode) syncEdgeNode() error {
    if err := e.syncNodeInfo(); err != nil {
        return err
    }
    return e.syncPods()
}

IoT Edge:

public async Task<ModuleClient> InitializeModuleClientAsync()
{
    var mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
    ITransportSettings[] settings = { mqttSetting };
    return await ModuleClient.CreateFromEnvironmentAsync(settings);
}

Both projects aim to manage edge computing scenarios, but OpenYurt focuses on extending Kubernetes to edge environments, while IoT Edge is specifically designed for Azure-based IoT solutions. OpenYurt offers more flexibility for multi-cloud deployments, while IoT Edge provides tighter integration with Azure services and potentially easier setup for Azure users.

27,843

Lightweight Kubernetes

Pros of k3s

  • Lightweight and resource-efficient, ideal for edge computing and IoT devices
  • Easy installation and minimal setup process
  • Fully CNCF certified Kubernetes distribution

Cons of k3s

  • Limited focus on edge-cloud synergy compared to OpenYurt
  • Lacks built-in edge autonomy features
  • May require additional tools for advanced edge computing scenarios

Code Comparison

k3s:

apiVersion: helm.cattle.io/v1
kind: HelmChart
metadata:
  name: traefik
  namespace: kube-system
spec:
  chart: https://charts.helm.sh/stable/traefik

OpenYurt:

apiVersion: apps.openyurt.io/v1alpha1
kind: YurtAppSet
metadata:
  name: nginx
spec:
  selector:
    matchLabels:
      app: nginx
  workloadTemplate:
    deploymentTemplate:
      metadata:
        labels:
          app: nginx

The code snippets showcase different approaches:

  • k3s uses HelmChart for deploying applications
  • OpenYurt introduces YurtAppSet for edge-native deployments

Both projects aim to simplify Kubernetes deployments, but OpenYurt focuses more on edge computing scenarios with specialized resources like YurtAppSet.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

openyurtio/openyurt

Version License Go Report Card codecov OpenSSF Scorecard CII Best Practices

English | 简体中文

notification What is NEW!
Latest Release: July 16th, 2024. OpenYurt v1.5.0. Please check the CHANGELOG for details.
First Release: May 29th, 2020. OpenYurt v0.1.0-beta.1

OpenYurt is built based on upstream Kubernetes and now hosted by the Cloud Native Computing Foundation(CNCF) as a Sandbox Level Project.

OpenYurt Overview

OpenYurt has been designed to meet various DevOps requirements against typical edge infrastructures. It provides consistent user experience for managing the edge applications as if they were running in the cloud infrastructure. It addresses specific challenges for cloud-edge orchestration in Kubernetes such as unreliable or disconnected cloud-edge networking, edge autonomy, edge device management, region-aware deployment, and so on. OpenYurt preserves intact Kubernetes API compatibility, is vendor agnostic, and more importantly, is SIMPLE to use.

Architecture

OpenYurt follows a classic cloud-edge architecture design. It uses a centralized Kubernetes control plane residing in the cloud site to manage multiple edge nodes residing in the edge sites. Each edge node has moderate compute resources available in order to run edge applications plus the required OpenYurt components. The edge nodes in a cluster can span multiple physical regions, which are referred to as Pools in OpenYurt.

OpenYurt architecture

The above figure demonstrates the core OpenYurt architecture. The major components consist of:

  • YurtHub: YurtHub runs on worker nodes as static pod and serves as a node sidecar to handle requests that comes from components (like Kubelet, Kubeproxy, etc.) on worker nodes to kube-apiserver.
  • Yurt-Manager: include all controllers and webhooks for edge.
  • Raven-Agent: It is focused on edge-edge and edge-cloud communication in OpenYurt, and provides layer 3 network connectivity among pods in different physical regions, as there are in one vanilla Kubernetes cluster.
  • Yurt-Coordinator: One instance of Yurt-Coordinator is deployed in every edge NodePool, and in conjunction with YurtHub to provide heartbeat delegation, cloud-edge traffic multiplexing abilities, etc.
  • YurtIoTDock: One instance of YurtIoTDock is deployed in every edge NodePool, for bridging EdgeX Foundry platform and uses Kubernetes CRD to manage edge devices.

In addition, OpenYurt also includes auxiliary controllers for integration and customization purposes.

Getting started

OpenYurt is currently certified to support up to Kubernetes version 1.28. Compatibility with subsequent versions of Kubernetes is expected, but has not yet been verified. OpenYurt installation is divided into two parts:

Roadmap

Community

Contributing

If you are willing to be a contributor for the OpenYurt project, please refer to our CONTRIBUTING document for details. We have also prepared a developer guide to help the code contributors.

Meeting

ItemValue
APAC Friendly Community meetingAdjust to weekly APAC (Starting May 11, 2022), Wednesday 11:00AM GMT+8
Meeting link APAC Friendly meetinghttps://us02web.zoom.us/j/82828315928?pwd=SVVxek01T2Z0SVYraktCcDV4RmZlUT09
Meeting notesNotes and agenda
Meeting recordingsOpenYurt bilibili Channel

Contact

If you have any questions or want to contribute, you are welcome to communicate most things via GitHub issues or pull requests. Other active communication channels:

dingtalk

License

OpenYurt is under the Apache 2.0 license. See the LICENSE file for details. Certain implementations in OpenYurt rely on the existing code from Kubernetes and the credits go to the original Kubernetes authors.