Using kubernetes gateway.networking.k8s.io with kubernetes.crossplane.io

Question

Pulumi · Accepted Answer

When working with Kubernetes in Pulumi, you would typically use the `kubernetes` package to create and manage your Kubernetes resources through code. The Kubernetes Gateway API is a set of resources to configure a gateway at the edge of a service mesh. It is a more expressive, role-oriented way to route traffic than with traditional Ingress resources. Crossplane is an open-source Kubernetes add-on widely adopted for declaratively managing the entire lifecycle of infrastructure and services in your organizations using the control plane of Kubernetes.

To use these APIs with Pulumi, you must have a Kubernetes cluster running and be able to connect to it using `kubectl`. Additionally, you need to install the Gateway API CRDs (Custom Resource Definitions) and the Crossplane CRDs to your cluster if they aren't already installed.

In this Pulumi program, we'll set up a simple Gateway using the Kubernetes Gateway API that is managed by Crossplane. We will define a `Gateway` resource that can be used to route traffic to a service. We assume that your cluster already has Crossplane installed and configured to manage resources.

Let's start with a high-level explanation before diving into the TypeScript code:

1. **Installing CRDs**: Ensure that your Kubernetes cluster has the required CRDs installed. This can be done through Crossplane packages or manually applying the CRD manifests.

2. **Defining the GatewayClass**: Before creating a `Gateway`, you must have a `GatewayClass`. It's a template for creating Gateways of a specific type and is often installed by a cluster operator.

3. **Creating the Gateway**: Define a `Gateway` resource specifying the `GatewayClass` and the listeners (which defines ports, protocols, etc.).

4. **Defining Routes**: To actually direct traffic to services, you define `HTTPRoute` or other route types. These specify match conditions and backend refs where the traffic should be sent.

5. **Deploying Services**: Backend services referenced by routes need to exist. In this program, we'll assume you have a service ready to receive traffic.

Below is a Pulumi TypeScript program that sets up a simple Gateway using the Gateway API.

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

// This GatewayClass resource is often installed by the cluster operator.
// We're including it here for completeness, but you should check if it's needed in your case.
const gatewayClass = new k8s.networking.v1beta1.GatewayClass('my-gateway-class', {
    metadata: {
        name: 'my-gateway-class',
    },
    spec: {
        controller: 'example.com/gateway-controller',
    },
});

// Define a Gateway resource using the GatewayClass we've defined (or one that already exists).
const gateway = new k8s.gateway.networking.v1alpha1.Gateway('my-gateway', {
    metadata: {
        name: 'my-gateway',
    },
    spec: {
        gatewayClassName: gatewayClass.metadata.name,
        listeners: [
            {
                name: 'http',
                protocol: 'HTTP',
                port: 80,
            },
        ],
    },
});

// Define an HTTPRoute resource that matches all traffic and forwards it to a named service.
const httpRoute = new k8s.gateway.networking.v1alpha1.HTTPRoute('my-http-route', {
    metadata: {
        name: 'my-http-route',
    },
    spec: {
        gatewayRefs: [
            {
                name: gateway.metadata.name,
                namespace: 'default', // replace with the actual namespace if different
            },
        ],
        hostnames: ['example.com'],
        rules: [
            {
                matches: [
                    {
                        path: {
                            type: 'PathPrefix',
                            value: '/',
                        },
                    },
                ],
                forwardTo: [
                    {
                        serviceName: 'my-service', // should match the name of your service
                        port: 80,
                    },
                ],
            },
        ],
    },
});

// Export the public IP to access the gateway
export const gatewayAddress = gateway.status.addresses.apply(
    addresses => addresses ? addresses[0].value : undefined
);
```

This Pulumi program creates a `GatewayClass`, a `Gateway` that refers to this class, and an `HTTPRoute` that uses this Gateway to route traffic to a service named "my-service". The `gatewayAddress` export will provide the address you use to access the gateway once it receives a public IP.

Please ensure that all prerequisite services and configurations are in place before running this program, such as having `kubectl` configured, access rights to the cluster, and necessary CRDs installed.