Getting Started with Knative

What is Knative ?

Knative is an open-source enterprise-level solution to build serverless and event driven applications. It is platform agnostic solution .

Serverless model is an application development and execution model that enables developers to build and run application code without provisioning or managing servers or backend infrastructure. In a serverless architecture, developers can focus on writing the best front-end application code and business logic without worrying about server management.

Benefits of using Serverless ?

• No Server Management
• Event-Driven Execution: Serverless Function (FaaS)
• Pay-as-You-Go
• Invisible Servers

What are Knative Components ?

Knative, consists of mainly two main components: Serving and Eventing. Serving and
Eventing work together to automate and manage tasks and applications.

Knative Serving

It basically helps you to run serverless containers in Kubernetes very easily . It takes care of the harder task like networking autoscaling , request routing , traffic splitting etc . and leaves you with the task of core logic so that team can focus on the main task of writing core logics in programming languages .

The primary Knative Serving resources are Services, Routes, Configurations, and Revisions:

1. Services

   • The service.serving.knative.dev resource is a fundamental building block in Knative Serving.
   • Purpose: It automates the entire lifecycle management of your workload (application or microservice).
   • Key Responsibilities:
     • Creates other related objects (such as routes, configurations, and revisions) to ensure your app is fully functional.
     • Ensures that each update to the service results in a new revision.
     • Allows you to define whether traffic should always route to the latest revision or a specific pinned revision.

2. Routes

   • The route.serving.knative.dev resource maps a network endpoint (URL) to one or more revisions of your service.
   • Traffic Management:
     • You can control traffic using fractional distribution (e.g., 80% to one revision, 20% to another).
     • Named routes allow you to direct traffic based on specific criteria (e.g., version labels).
   • Use Cases:
     • Ideal for gradual rollouts, A/B testing, and canary deployments.

3. Configurations

   • The configuration.serving.knative.dev resource maintains the desired state for your deployment.
   • Separation of Code and Configuration:
     • Follows the Twelve-Factor App methodology by cleanly separating code from configuration.
     • Modifying a configuration creates a new revision of your service.
   • Settings:
     • Includes environment variables, scaling parameters, and container image details.

4. Revisions

   • The revision.serving.knative.dev resource represents a point-in-time snapshot of your code and configuration.
   • Immutability:
     • Revisions are immutable objects, meaning they cannot be modified once created.
     • Retain revisions for as long as they are useful.
   • Autoscaling:
     • Knative Serving automatically scales revisions up or down based on incoming traffic.

Knative Serving’s CRDs (Custom Resource Definitions) allow you to define and control how your serverless workloads behave on the Kubernetes cluster. These resources simplify deployment, scaling, and traffic management, making it easier to build efficient and responsive applications.

Knative Eventing

Knative Eventing is a standalone platform that provides support for various types of workloads, including standard Kubernetes Services and Knative Serving Services. It is generally a collection of APIs that enables you to use evenet driven architecture. Knative Eventing components are loosely coupled, and can be developed and deployed independently of each other. Knative Eventing uses standard HTTP POST requests to send and receive events between event producers and sinks.

Conclusion

Knative Serving handles the deployment and scaling of serverless applications, while Knative Eventing enables event-driven communication between services. Together, they empower teams to build efficient, automated, and responsive applications on Kubernetes.

For more such blogs visit nashtech blogs .

References

• Knative official Documents  https://knative.dev/docs/