Knative
Knative adds serverless workload abstractions to Kubernetes. It runs stateless HTTP containers, routes events, manages immutable revisions, and can adjust serving capacity as demand changes.
itCloud native tools and technologies | OpenSkills.info
Intro
Knative
Knative adds serverless application capabilities to Kubernetes. It gives developers higher-level resources for deploying stateless HTTP containers, routing events, and packaging functions. Kubernetes still schedules and runs the underlying pods.
This division matters. Kubernetes supplies the cluster, workload, networking, security, and storage foundations. Knative adds application-oriented control loops for request-driven scaling, revision-aware traffic, and event delivery. You gain a platform layer, not a replacement for Kubernetes operations.
By the end of this course, you will be able to explain Knative's components, trace a request or event through them, and decide where the platform fits.
The problem Knative addresses
A Kubernetes Deployment can run an HTTP application, but it does not provide a complete serverless experience. A platform team must still combine scaling, ingress, rollout, revision, and event-routing systems. Application teams then need conventions for using those systems consistently.
Knative packages these concerns into Kubernetes custom resources and controllers. A developer declares an intended service or event route. Knative reconciles that declaration into lower-level Kubernetes and networking resources.
This approach creates two important outcomes:
- Developers work with application concepts such as Services, Revisions, Brokers, and Triggers.
- Platform teams retain Kubernetes as the common control plane and choose supported networking or messaging implementations.
Knative does not remove operational responsibility. The platform team still installs, upgrades, secures, and observes the cluster and Knative components. It also chooses networking, DNS, TLS, and messaging integrations.
Continue the course
This section is part of the paid course.
See pricing to subscribe, or log in if you already have access.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://knative.dev/docs/
Supports
- Knative as a Kubernetes-based serverless platform
- Serving, Eventing, and Functions component boundaries
- Component interoperability and independent adoption
- Use cases, prerequisites, and platform evaluation
- Quiz answers about the platform boundary and component selection
- https://knative.dev/docs/install/
Supports
- Serving and Eventing as independently installable cluster components
- Functions as a client tool rather than an installed cluster component
- Quickstart and production installation paths
- Kubernetes administration and networking prerequisites
- Installation link rationale
- https://knative.dev/docs/serving/
Supports
- Service, Route, Configuration, and Revision responsibilities
- Immutable Revisions created by configuration changes
- Fractional traffic and named routes
- Stateless HTTP serving and scale-to-zero use cases
- Serving quiz answers and reference rationale
- https://knative.dev/docs/serving/architecture/
Supports
- Activator responsibility during scale from zero
- Autoscaler responsibility
- Networking layer and ingress boundary
- Serving request-path explanations
- https://knative.dev/docs/serving/autoscaling/
Supports
- Knative Pod Autoscaler as the default autoscaler
- Scale to zero and minimum replica behavior
- Concurrency, metric, target, and scale-bound configuration areas
- Startup tradeoff and autoscaling quiz answer
- https://knative.dev/docs/serving/traffic-management/
Supports
- Traffic routing among Revisions
- Percentage-based traffic and revision tags
- Canary, staged release, and rollback mental models
- Route quiz answer and link rationale
- https://knative.dev/docs/eventing/
Supports
- Producer, source, sink, and loosely coupled event relationships
- CloudEvents over HTTP delivery
- Broker and Trigger event flow
- Eventing quiz answers and link rationale
- https://knative.dev/docs/eventing/brokers/
Supports
- Broker as shared event ingress
- Broker relationship with Triggers and subscribers
- Broker-based decoupling quiz answer
- https://knative.dev/docs/eventing/triggers/
Supports
- Trigger association with a Broker, filter, and subscriber
- Filtered event delivery
- Trigger quiz answers
- https://knative.dev/docs/eventing/channels/
Supports
- Channel and Subscription event-delivery relationship
- Contrast between explicit Channel routing and Broker routing
- https://knative.dev/docs/eventing/event-delivery/
Supports
- Retry configuration and delay policies
- Dead-letter sinks
- Consumer responsibility for repeated delivery
- Delivery-failure quiz answer and link rationale
- https://knative.dev/docs/functions/
Supports
- Function templates and func CLI workflow
- OCI image creation
- Deployment of functions as Knative Services
- Local development without Kubernetes
- Functions quiz answer and link rationale
- https://github.com/sindresorhus/awesome
Supports
- Discovery path to curated Kubernetes and serverless lists
- https://github.com/anaibol/awesome-serverless
Supports
- Discovery of Knative, OpenFaaS, Fission, and Serverless Framework
- Selection of non-duplicate serverless ecosystem comparisons
- https://docs.openfaas.com/
Supports
- OpenFaaS as a Kubernetes-oriented function and microservice platform
- Container packaging, autoscaling, metrics, and event integrations
- OpenFaaS Awesome Link rationale
- https://fission.io/docs/
Supports
- Fission as a Kubernetes serverless framework
- Functions, environments, packages, triggers, and architecture
- Fission Awesome Link rationale
- https://www.serverless.com/framework/docs
Supports
- Command-line and YAML workflow
- Deployment of code and provider infrastructure
- Serverless Framework Awesome Link rationale