Top Related Projects
Quick Overview
Liqo is an open-source project that enables dynamic and seamless Kubernetes multi-cluster topologies. It allows users to share and offload computational resources across different Kubernetes clusters, creating a unified "extended" cluster. Liqo facilitates resource sharing, workload offloading, and multi-cluster application deployment.
Pros
- Seamless integration with existing Kubernetes clusters without requiring modifications to applications or the Kubernetes API
- Dynamic and automatic discovery of neighboring clusters, simplifying multi-cluster management
- Supports various infrastructure providers, including on-premises, cloud, and edge environments
- Enhances resource utilization and scalability by allowing workload offloading to other clusters
Cons
- Adds complexity to cluster management and networking configurations
- May introduce additional security considerations when sharing resources across clusters
- Requires careful planning and configuration to ensure optimal performance and resource allocation
- Limited documentation and community support compared to more established Kubernetes tools
Getting Started
To get started with Liqo, follow these steps:
- Install Liqo on your Kubernetes cluster using Helm:
helm repo add liqo https://helm.liqo.io/
helm repo update
helm install liqo liqo/liqo --create-namespace --namespace liqo
- Configure peering between clusters:
liqoctl add cluster <cluster-name> --auth-url <auth-service-url>
- Deploy a sample application across multiple clusters:
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
spec:
replicas: 3
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: liqo.io/provider
operator: In
values:
- liqo
containers:
- name: nginx
image: nginx:1.14.2
ports:
- containerPort: 80
Apply this YAML file to deploy the application across Liqo-enabled clusters:
kubectl apply -f nginx-deployment.yaml
For more detailed instructions and advanced configurations, refer to the official Liqo documentation.
Competitor Comparisons
Kubernetes Cluster Federation
Pros of KubeFed
- More mature project with longer development history
- Wider adoption in production environments
- Better documentation and community support
Cons of KubeFed
- Limited to Kubernetes-only environments
- Less flexible for heterogeneous cloud environments
- Development has slowed down significantly
Code Comparison
KubeFed configuration example:
apiVersion: types.kubefed.io/v1beta1
kind: FederatedDeployment
metadata:
name: test-deployment
namespace: test-namespace
spec:
template:
metadata:
labels:
app: nginx
spec:
replicas: 3
Liqo configuration example:
apiVersion: discovery.liqo.io/v1alpha1
kind: ResourceRequest
metadata:
name: resource-request-sample
spec:
clusterIdentity:
clusterID: remote-cluster-id
clusterName: remote-cluster
resourceQuota:
hard:
cpu: "4"
memory: 8Gi
While KubeFed focuses on federation within Kubernetes clusters, Liqo provides a more flexible approach for resource sharing across different cloud environments. KubeFed's configuration is centered around Kubernetes-native resources, whereas Liqo's configuration allows for more granular control over resource requests and sharing between clusters.
Complete container management platform
Pros of Rancher
- More mature and widely adopted project with a larger community
- Comprehensive UI for managing multiple clusters and workloads
- Supports multiple Kubernetes distributions and cloud providers
Cons of Rancher
- Heavier resource footprint compared to Liqo
- More complex setup and configuration process
- May introduce additional overhead for single-cluster environments
Code Comparison
Rancher (Helm installation):
helm repo add rancher-stable https://releases.rancher.com/server-charts/stable
helm install rancher rancher-stable/rancher \
--namespace cattle-system \
--set hostname=rancher.my.org
Liqo (Helm installation):
helm repo add liqo https://helm.liqo.io/
helm install liqo liqo/liqo \
--namespace liqo \
--create-namespace
Both projects use Helm for installation, but Rancher requires more configuration parameters for initial setup. Liqo's installation is simpler and more straightforward, reflecting its focus on lightweight, peer-to-peer cluster federation.
Open, Multi-Cloud, Multi-Cluster Kubernetes Orchestration
Pros of Karmada
- More mature project with a larger community and wider adoption
- Supports multiple scheduling policies and resource propagation strategies
- Offers built-in multi-cluster service discovery and load balancing
Cons of Karmada
- More complex architecture and setup process
- Requires additional components like etcd and karmada-apiserver
- Less focus on network-level integration between clusters
Code Comparison
Karmada resource propagation:
apiVersion: policy.karmada.io/v1alpha1
kind: PropagationPolicy
metadata:
name: example-policy
spec:
resourceSelectors:
- apiVersion: apps/v1
kind: Deployment
placement:
clusterAffinity:
clusterNames:
- cluster1
- cluster2
Liqo peering:
apiVersion: discovery.liqo.io/v1alpha1
kind: PeeringRequest
metadata:
name: example-peering
spec:
clusterIdentity:
clusterID: remote-cluster-id
clusterName: remote-cluster
outgoingPeeringEnabled: true
incomingPeeringEnabled: true
Both Liqo and Karmada aim to simplify multi-cluster Kubernetes management, but they take different approaches. Liqo focuses on seamless network integration and resource sharing between clusters, while Karmada provides a more comprehensive multi-cluster orchestration platform with advanced scheduling and resource propagation features.
OpenFaaS - Serverless Functions Made Simple
Pros of faas
- More mature project with a larger community and ecosystem
- Supports multiple languages and frameworks out-of-the-box
- Provides a user-friendly UI for function management and monitoring
Cons of faas
- Limited to serverless function deployment, not full application orchestration
- May require additional setup for complex networking scenarios
- Less flexible for multi-cluster deployments compared to Liqo
Code Comparison
faas (function deployment):
functions:
hello-world:
lang: python3
handler: ./hello-world
image: hello-world:latest
Liqo (virtual cluster creation):
apiVersion: virtualkubelet.liqo.io/v1alpha1
kind: VirtualCluster
metadata:
name: my-virtual-cluster
spec:
clusterIdentity:
clusterID: cluster-123
clusterName: remote-cluster
While faas focuses on deploying and managing serverless functions, Liqo enables resource sharing and multi-cluster orchestration. faas provides a more straightforward approach for function-based workloads, while Liqo offers greater flexibility for complex, distributed Kubernetes environments.
Kubernetes Native Edge Computing Framework (project under CNCF)
Pros of KubeEdge
- More mature project with a larger community and wider adoption
- Focuses on edge computing scenarios, providing better support for IoT and edge devices
- Offers lightweight edge nodes that can operate with limited resources and intermittent connectivity
Cons of KubeEdge
- More complex architecture and setup compared to Liqo
- Less flexible for general multi-cluster scenarios that don't involve edge computing
- May have higher resource requirements for full functionality
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
Liqo configuration example:
apiVersion: discovery.liqo.io/v1alpha1
kind: SearchDomain
metadata:
name: liqo-search-domain
spec:
autojoin: true
outgoingPeeringEnabled: true
incomingPeeringEnabled: true
Both projects aim to extend Kubernetes capabilities, but KubeEdge is more focused on edge computing scenarios, while Liqo provides a more general solution for multi-cluster environments. KubeEdge offers better support for resource-constrained devices and edge computing use cases, whereas Liqo excels in flexibility and ease of use for connecting multiple Kubernetes clusters.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Enable dynamic and seamless Kubernetes multi-cluster topologies
Explore the docs »
View Videos
·
Report Bug
·
Request Feature
What is Liqo?
Liqo is an open-source project that enables dynamic and seamless Kubernetes multi-cluster topologies, supporting heterogeneous on-premise, cloud and edge infrastructures.
What does it provide?
- Peering: automatic peer-to-peer establishment of resource and service consumption relationships between independent and heterogeneous clusters. No need to worry about complex VPN configurations and certification authorities: everything is transparently self-negotiated for you.
- Offloading: seamless workloads offloading to remote clusters, without requiring any modification to Kubernetes or the applications themselves. Multi-cluster is made native and transparent: collapse an entire remote cluster to a virtual node compliant with the standard Kubernetes approaches and tools.
- Network fabric: transparent multi-cluster pod-to-pod and pod-to-service connectivity, regardless of the underlying configurations and CNI plugins. Natively access the services exported by remote clusters, and spread interconnected application components across multiple infrastructures, with all cross-cluster traffic flowing through secured network tunnels.
- Storage fabric: support for remote execution of stateful workloads, according to the data gravity approach. Seamlessly extend standard (e.g., database) high availability deployment techniques to the multi-cluster scenarios, for increased guarantees. All without the complexity of managing multiple independent cluster and application replicas.
Quick start
Would you like to quickly join the fray and experiment with Liqo? Set up your playground and check out the getting started examples, which will guide you through a scenario-driven tour of the most notable features of Liqo:
- Quick Start: grasp a quick overview of what Liqo can do.
- Offloading with Policies: discover how to tune namespace offloading, and how to use policies to select which clusters may host each workload.
- Offloading a Service: learn how to create a multi-cluster service, and how to consume it from each connected cluster.
- Stateful Applications: find out how to deploy a database across a multi-cluster environment, leveraging the Liqo storage fabric.
- Global Ingress: discover how route external traffic to multi-cluster applications through a global ingress and automatic DNS configurations.
- Replicated Deployments: learn how to deploy an application by replicating it on multiple remote clusters.
- Provision with Terraform: explore Liqo Terraform provider capabilities.
Going Further
Got curious? Check out the documentation website for an in-depth overview of the Liqo features, to discover how to install Liqo on your clusters, as well as to find out about the different usage and configuration options.
Roadmap
Want to know about the features to come? Check out the project roadmap for more information.
Contributing
All contributors are warmly welcome. If you want to become a new contributor, we are so happy! Just, before doing it, read the tips and guidelines presented in the dedicated documentation page.
Community
To get involved with the Liqo community, join the Slack workspace.
| :bell: Community Meeting |
|---|
| Liqo holds weekly community meetings on Monday, 5.30pm UTC (6.30pm CET, 9.30am PST). To join the community meeting, follow this link. Convert to your timezone here. You can see and add the Liqo Calendar following this link. |
License
This project includes code from the Virtual Kubelet project, licensed under the Apache 2.0 license.
Liqo is distributed under the Apache-2.0 License. See License for more information.
Liqo is a project kicked off at Polytechnic of Turin (Italy) and actively maintained with :heart: by all the Liqoers.
Top Related Projects
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot