Using kubernetes operator.knative.dev with traefik

Question

Pulumi · Accepted Answer

To use the `operator.knative.dev` Kubernetes operator with Traefik, you will need to perform the following high-level steps:

1. Install the Knative operator in your Kubernetes cluster.
2. Install and configure Traefik as an ingress solution that will handle the HTTP routing.

Knative Serving provides a set of Kubernetes Custom Resource Definitions (CRDs) that allows you to deploy and manage serverless applications. It abstracts away much of the boilerplate needed to run a serverless service on Kubernetes.

Traefik is a modern HTTP reverse proxy and load balancer that makes deploying microservices easy. It can act as an ingress controller in a Kubernetes environment and provides features like automated SSL certificate management using Let's Encrypt.

Below is a sample Pulumi TypeScript program that illustrates how you may accomplish the integration:

1. Declare the necessary imports.
2. Create a Knative Serving component.
3. Deploy Traefik as an ingress controller.
4. Configure an `IngressRoute` for Traefik that will route the traffic to your Knative service.

Here's the Pulumi program that includes the above steps:

```typescript
import * as k8s from "@pulumi/kubernetes";

// Assumed that your Kubernetes cluster is already configured in Pulumi.
// Make sure to have the necessary configuration set for the provider.

// Create a new Kubernetes Namespace for Knative
const knativeNamespace = new k8s.core.v1.Namespace("knative", {
    metadata: { name: "knative-serving" },
});

// Deploy the Knative Serving operator
const knativeServingOperator = new k8s.yaml.ConfigFile("knative-serving-operator", {
    file: "https://github.com/knative/operator/releases/download/v0.25.0/operator.yaml",
}, { dependsOn: knativeNamespace });

// Deploy Traefik Ingress Controller using a Helm chart
const traefikIngress = new k8s.helm.v3.Chart("traefik-ingress", {
    chart: "traefik",
    version: "10.3.0",
    namespace: knativeNamespace.metadata.name,
    fetchOpts: { repo: "https://helm.traefik.io/traefik" },
});

// Deploy a Knative Service (Replace this example with the service details)
const knativeService = new k8s.apiextensions.CustomResource("knative-service", {
    apiVersion: "serving.knative.dev/v1",
    kind: "Service",
    metadata: {
        name: "hello-world",
        namespace: knativeNamespace.metadata.name,
    },
    spec: {
        template: {
            spec: {
                containers: [{
                    image: "gcr.io/knative-samples/helloworld-go",
                    ports: [{ containerPort: 80 }],
                }],
            },
        },
    },
}, { dependsOn: [knativeServingOperator, traefikIngress] });

// Define an IngressRoute for Traefik that will direct traffic to the Knative service
const ingressRoute = new k8s.apiextensions.CustomResource("knative-ingress-route", {
    apiVersion: "traefik.containo.us/v1alpha1",
    kind: "IngressRoute",
    metadata: {
        name: "hello-world-route",
        namespace: knativeNamespace.metadata.name,
    },
    spec: {
        entryPoints: ["web"],
        routes: [{
            match: `Host("hello-world.example.com") && PathPrefix("/")`,
            kind: "Rule",
            services: [{
                name: "hello-world",
                port: 80,
            }],
        }],
    },
}, { dependsOn: knativeService });

// Export the URL for the Knative service
export const url = `http://hello-world.example.com`;

```

In this program:

- We first create the namespace `knative-serving` where all Knative resources will reside.
- We then use `k8s.yaml.ConfigFile` to apply the Knative Serving operator directly from the Knative repository, which will set up all required CRDs and resources.
- We deploy Traefik using its Helm chart with `k8s.helm.v3.Chart`, which simplifies the deployment process.
- A `CustomResource` is defined for our Knative service, which specifies the application we want to run, along with its configurations.
- We create a `CustomResource` for Traefik's `IngressRoute`, which will define how incoming requests are routed to our Knative service.
- Finally, you would replace `hello-world.example.com` with your actual domain and set up DNS to point to the Traefik ingress service's IP address or hostname.

Please note, the specific versions, domain names, and image references are for illustrative purposes, and you will need to adjust them according to your requirements and environment setup. Make sure to check for the latest versions of the software components used.