Using kubernetes cilium.io with serving.knative.dev

Question

Pulumi · Accepted Answer

To integrate Cilium with Knative Serving on Kubernetes using Pulumi, you would need to perform the following high-level steps:

1. Deploy a Kubernetes cluster or use an existing one.
2. Install Cilium as the CNI (Container Network Interface) plugin for Kubernetes networking.
3. Deploy Knative Serving to manage and scale your serverless workloads.

Cilium is a CNI plugin for Kubernetes that provides advanced networking features such as API-aware network security, load balancing, and visibility for container-based workloads. Knative Serving builds on Kubernetes to support deploying and serving serverless applications and functions.

Below is a Pulumi TypeScript program that illustrates these steps. Note that the specific details, like how to configure Cilium or Knative, are beyond the scope of this simple example. Usually, you would use Helm charts to deploy such complex applications, but let's see how you can use Pulumi for orchestrating this setup.

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

// Pre-assumed: Kubernetes cluster is already provisioned and configured.
// In this program, we are going to install Cilium and Knative Serving.

// Step 1: Install Cilium CNI Plugin
// Replace this YAML content with the Cilium installation manifest as needed.
const ciliumManifestUrl = "https://raw.githubusercontent.com/cilium/cilium/v1.9/install/kubernetes/quick-install.yaml";

const ciliumCni = new k8s.yaml.ConfigGroup("cilium-cni", {
    files: [ciliumManifestUrl],
});

// Step 2: Deploy Knative Serving
// You would typically use the Knative Serving Helm chart to deploy Knative.
// Make sure to adjust the repository and version according to your needs.
const knativeServingChart = new k8s.helm.v3.Chart("knative-serving", {
    chart: "serving",
    version: "0.25.0", // Use the appropriate version
    fetchOpts: {
        repo: "https://knative.dev/charts",
    },
});

// Export the Knative ingress gateway URL for accessing deployed functions
export const knativeIngressGatewayUrl = knativeServingChart.getResource(
    "v1/Service",
    "knative-serving/ingress",
).status.loadBalancer.ingress[0].hostname;

// After running `pulumi up`, this program will install Cilium and Knative Serving into the cluster.
// You can then deploy serverless functions using Knative Serving CRDs.
```

This program does the following:

- It imports the necessary Pulumi Kubernetes SDK.
- It uses a config group to apply a manifest file. You should replace the `ciliumManifestUrl` with the actual Cilium install manifest URL specific to the version you wish to use.
- It deploys Knative Serving using a Helm chart. The `chart` and `version` properties should correspond to the Knative version you want to install.
- It exports the Knative ingress gateway's URL. This is the entry point for accessing your serverless functions after they have been deployed.

Please note that both Cilium and Knative Serving have multiple installation options and configurations, which may depend on your specific cluster setup (like cloud provider, Kubernetes version, etc.). You should adjust the installation manifests and Helm chart values according to your particular environment and needs.

Run the Pulumi program with the Pulumi CLI using the following commands:

```bash
pulumi up            # Review and confirm the changes
pulumi stack output  # To see the Knative ingress gateway URL after deployment
```

If you're operating in a production or a more complex development environment, you might need to consider aspects such as namespaces, RBAC policies, network policies, and more detailed monitoring and management of the deployed resources.