Need advice about which tool to choose?Ask the StackShare community!

Knative

82
336
+ 1
21
Kubernetes

58.7K
50.8K
+ 1
677
Add tool

Knative vs Kubernetes: What are the differences?

Key Differences between Knative and Kubernetes

Knative and Kubernetes are both popular open-source platforms used for managing containerized applications and services. While they share some similarities, there are key differences between the two platforms that set them apart.

  1. Abstraction Level: Kubernetes is a container orchestration platform that provides a robust infrastructure for managing and scaling containerized applications. It focuses on providing a scalable and reliable infrastructure layer for containers, allowing developers to deploy, manage, and scale applications. On the other hand, Knative is built on top of Kubernetes and adds a higher-level abstraction specifically for serverless workloads. Knative abstracts away the infrastructure concerns and provides developers with a serverless experience, enabling them to focus solely on writing code without worrying about the underlying infrastructure.

  2. Serverless Support: One of the key differences between Knative and Kubernetes is their support for serverless computing. While Kubernetes can run serverless workloads using custom configurations or external tools like Kubeless or OpenFaaS, Knative is specifically designed for serverless applications. Knative provides a set of building blocks for event-driven, auto-scaling, and managed container workloads, making it easier to develop, deploy, and manage serverless applications.

  3. Auto-scaling and Event-driven Scaling: Knative offers built-in auto-scaling capabilities for serverless workloads. It can automatically scale up or down based on the incoming traffic or events. This makes Knative well-suited for handling variable workloads and bursty traffic patterns. In contrast, while Kubernetes also has auto-scaling capabilities, it requires additional setup and configuration to achieve the same level of auto-scaling and event-driven scaling as offered by Knative.

  4. Workload Abstraction and Portability: Kubernetes provides a generic platform for managing containerized workloads and has a highly flexible and extensible architecture. It allows running various types of workloads, including stateful and stateless applications and provides a wide range of options for customization and portability. Knative, on the other hand, focuses specifically on serverless workloads and provides a higher-level abstraction for building serverless applications. While Knative uses Kubernetes under the hood, its abstraction is more tailored towards serverless use cases and provides additional abstractions and APIs specifically for serverless development.

  5. Ease of Use and Developer Experience: Kubernetes can have a steep learning curve, especially for developers new to container orchestration. It requires understanding various concepts, such as pods, services, deployments, and networking, to effectively deploy and manage applications. Knative, being a higher-level abstraction built on top of Kubernetes, provides a simpler and more intuitive developer experience for serverless workloads. It offers a higher-level API and abstracts away most of the infrastructure concerns, allowing developers to focus more on writing code and less on managing infrastructure.

  6. Community and Maturity: Kubernetes has been around for a longer time and has a larger community and ecosystem compared to Knative. It has become the de facto standard for container orchestration and has widespread adoption in the industry. Knative, being a relatively newer project, has a smaller but growing community. While it is gaining popularity, it may not have the same breadth of community-contributed tools and integrations as Kubernetes.

In summary, Knative provides a higher-level abstraction for serverless workloads on top of Kubernetes, offering built-in serverless support, auto-scaling capabilities, simplified developer experience, and tailored abstractions for serverless development. Kubernetes, on the other hand, provides a more generic platform for managing containerized workloads with a larger community and ecosystem.

Decisions about Knative and Kubernetes
Simon Reymann
Senior Fullstack Developer at QUANTUSflow Software GmbH · | 30 upvotes · 9M views

Our whole DevOps stack consists of the following tools:

  • GitHub (incl. GitHub Pages/Markdown for Documentation, GettingStarted and HowTo's) for collaborative review and code management tool
  • Respectively Git as revision control system
  • SourceTree as Git GUI
  • Visual Studio Code as IDE
  • CircleCI for continuous integration (automatize development process)
  • Prettier / TSLint / ESLint as code linter
  • SonarQube as quality gate
  • Docker as container management (incl. Docker Compose for multi-container application management)
  • VirtualBox for operating system simulation tests
  • Kubernetes as cluster management for docker containers
  • Heroku for deploying in test environments
  • nginx as web server (preferably used as facade server in production environment)
  • SSLMate (using OpenSSL) for certificate management
  • Amazon EC2 (incl. Amazon S3) for deploying in stage (production-like) and production environments
  • PostgreSQL as preferred database system
  • Redis as preferred in-memory database/store (great for caching)

The main reason we have chosen Kubernetes over Docker Swarm is related to the following artifacts:

  • Key features: Easy and flexible installation, Clear dashboard, Great scaling operations, Monitoring is an integral part, Great load balancing concepts, Monitors the condition and ensures compensation in the event of failure.
  • Applications: An application can be deployed using a combination of pods, deployments, and services (or micro-services).
  • Functionality: Kubernetes as a complex installation and setup process, but it not as limited as Docker Swarm.
  • Monitoring: It supports multiple versions of logging and monitoring when the services are deployed within the cluster (Elasticsearch/Kibana (ELK), Heapster/Grafana, Sysdig cloud integration).
  • Scalability: All-in-one framework for distributed systems.
  • Other Benefits: Kubernetes is backed by the Cloud Native Computing Foundation (CNCF), huge community among container orchestration tools, it is an open source and modular tool that works with any OS.
See more
Get Advice from developers at your company using StackShare Enterprise. Sign up for StackShare Enterprise.
Learn More
Pros of Knative
Pros of Kubernetes
  • 5
    Portability
  • 4
    Autoscaling
  • 3
    Open source
  • 3
    Eventing
  • 3
    Secure Eventing
  • 3
    On top of Kubernetes
  • 164
    Leading docker container management solution
  • 128
    Simple and powerful
  • 106
    Open source
  • 76
    Backed by google
  • 58
    The right abstractions
  • 25
    Scale services
  • 20
    Replication controller
  • 11
    Permission managment
  • 9
    Supports autoscaling
  • 8
    Cheap
  • 8
    Simple
  • 6
    Self-healing
  • 5
    No cloud platform lock-in
  • 5
    Promotes modern/good infrascture practice
  • 5
    Open, powerful, stable
  • 5
    Reliable
  • 4
    Scalable
  • 4
    Quick cloud setup
  • 3
    Cloud Agnostic
  • 3
    Captain of Container Ship
  • 3
    A self healing environment with rich metadata
  • 3
    Runs on azure
  • 3
    Backed by Red Hat
  • 3
    Custom and extensibility
  • 2
    Sfg
  • 2
    Gke
  • 2
    Everything of CaaS
  • 2
    Golang
  • 2
    Easy setup
  • 2
    Expandable

Sign up to add or upvote prosMake informed product decisions

Cons of Knative
Cons of Kubernetes
    Be the first to leave a con
    • 16
      Steep learning curve
    • 15
      Poor workflow for development
    • 8
      Orchestrates only infrastructure
    • 4
      High resource requirements for on-prem clusters
    • 2
      Too heavy for simple systems
    • 1
      Additional vendor lock-in (Docker)
    • 1
      More moving parts to secure
    • 1
      Additional Technology Overhead

    Sign up to add or upvote consMake informed product decisions

    - No public GitHub repository available -

    What is Knative?

    Knative provides a set of middleware components that are essential to build modern, source-centric, and container-based applications that can run anywhere: on premises, in the cloud, or even in a third-party data center

    What is Kubernetes?

    Kubernetes is an open source orchestration system for Docker containers. It handles scheduling onto nodes in a compute cluster and actively manages workloads to ensure that their state matches the users declared intentions.

    Need advice about which tool to choose?Ask the StackShare community!

    What companies use Knative?
    What companies use Kubernetes?
    See which teams inside your own company are using Knative or Kubernetes.
    Sign up for StackShare EnterpriseLearn More

    Sign up to get full access to all the companiesMake informed product decisions

    What tools integrate with Knative?
    What tools integrate with Kubernetes?

    Sign up to get full access to all the tool integrationsMake informed product decisions

    Blog Posts

    Kubernetesetcd+2
    2
    1166
    Dec 8 2020 at 5:50PM

    DigitalOcean

    GitHubMySQLPostgreSQL+11
    2
    2365
    PythonDockerKubernetes+7
    3
    1107
    May 21 2020 at 12:02AM

    Rancher Labs

    KubernetesAmazon EC2Grafana+12
    5
    1499
    Apr 16 2020 at 5:34AM

    Rancher Labs

    KubernetesRancher+2
    2
    944
    What are some alternatives to Knative and Kubernetes?
    Kubeless
    Kubeless is a Kubernetes native serverless Framework. Kubeless supports both HTTP and event based functions triggers. It has a serverless plugin, a graphical user interface and multiple runtimes, including Python and Node.js.
    OpenFaaS
    Serverless Functions Made Simple for Docker and Kubernetes
    Fission
    Write short-lived functions in any language, and map them to HTTP requests (or other event triggers). Deploy functions instantly with one command. There are no containers to build, and no Docker registries to manage.
    Google Cloud Functions
    Construct applications from bite-sized business logic billed to the nearest 100 milliseconds, only while your code is running
    Istio
    Istio is an open platform for providing a uniform way to integrate microservices, manage traffic flow across microservices, enforce policies and aggregate telemetry data. Istio's control plane provides an abstraction layer over the underlying cluster management platform, such as Kubernetes, Mesos, etc.
    See all alternatives