How to Deploy a Knative Function on Kubernetes

Are you ready to take your Kubernetes deployments to the next level? If so, it's time to learn about Knative – an open-source project that helps you run serverless workloads on Kubernetes. With Knative, you can deploy and manage your functions as if they were hosted in a serverless environment, without the overhead and limitations of a traditional PaaS.

In this guide, we'll walk you through the process of deploying a Knative function on Kubernetes, step by step. By the end, you'll have a full understanding of how Knative works, and how to use it to build scalable, responsive applications that can handle any workload.

What is Knative?

Knative is an open-source project that provides a set of building blocks for running serverless workloads on Kubernetes. It was created by Google, Red Hat, and other partners, and is based on the Kubernetes platform.

Knative consists of three main components: serving, eventing, and build. These components work together to provide a complete serverless platform that allows you to deploy and manage your functions as services on Kubernetes.

The serving component of Knative provides a layer of abstraction for your functions, allowing you to deploy them as serverless services without worrying about the underlying infrastructure. Knative automatically scales your services up and down based on demand, and provides features like traffic splitting and rollbacks to handle updates seamlessly.

The eventing component of Knative allows you to build event-driven architectures on top of Kubernetes. With eventing, you can trigger functions in response to events from external sources or other services running on Kubernetes.

The build component of Knative provides a framework for building container images from source code. You can use it to create and manage continuous delivery pipelines for your functions, ensuring that each new release is thoroughly tested and deployed automatically.

Prerequisites

Before we get started with the deployment process, there are a few prerequisites you'll need to meet.

• A Kubernetes cluster, version 1.16 or higher.
• The kubectl command-line tool installed and configured to connect to your cluster. You can find instructions for installing kubectl here.
• Basic knowledge of Kubernetes concepts and workflows. If you're new to Kubernetes, you may want to check out our Getting Started Guide.

Step 1: Install Knative

The first step to deploying a Knative function is to install the Knative serving component on your Kubernetes cluster. This can be done using the following kubectl command:

kubectl apply -f https://github.com/knative/serving/releases/download/v0.25.0/serving-crds.yaml
kubectl apply -f https://github.com/knative/serving/releases/download/v0.25.0/serving-core.yaml

These commands install the necessary Custom Resource Definitions (CRDs) and components required for Knative serving. After running these commands, you can verify that Knative serving is running correctly by running the following command:

kubectl get pods --namespace knative-serving

You should see a list of pods running in the knative-serving namespace, including the activator, autoscaler, and controller pods.

Step 2: Create a Knative Service

Now that you have Knative serving installed, it's time to create a service to run your function.

Knative services are defined using Kubernetes manifests, and can be created using the kubectl apply command.

Here's an example manifest for running a simple "Hello, World!" function:

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: hello
spec:
  template:
    spec:
      containers:
        - image: gcr.io/knative-samples/helloworld-go
          env:
            - name: TARGET
              value: "Knative"

This YAML defines a new Service resource called hello, which runs the gcr.io/knative-samples/helloworld-go image.

To create this service, save the YAML to a file called hello.yaml, and run the following command:

kubectl apply -f hello.yaml

After running this command, you can check the status of your service using the following command:

kubectl get ksvc hello

You should see output that looks something like this:

NAME   URL                                  LATESTCREATED   LATESTREADY   READY   REASON
hello  http://hello.default.192.168.99.100.nip.io   hello-w9anh     hello-w9anh   True

This output tells you that the hello service is running, and provides a URL for accessing it.

Step 3: Test Your Function

Now that your Knative service is up and running, it's time to test your function to make sure it's working as expected.

To test your function, visit the URL provided by the kubectl get ksvc command in your web browser. You should see a simple web page that displays the message "Hello, Knative!".

Congratulations, you've deployed and tested your first Knative function!

Conclusion

In conclusion, Knative provides an easy and efficient way to deploy serverless workloads on top of Kubernetes. By leveraging the power of Kubernetes, you can build robust and scalable applications that can handle any workload.

We hope this guide has been helpful in getting you started with Knative. If you're looking for more information on how to use Knative, check out the official documentation or the Knative GitHub repository.

Happy coding!

Editor Recommended Sites