Exposing APIs with Kong Ingress Controller on Kubernetes

Question

Pulumi · Accepted Answer

To expose APIs with Kong Ingress Controller on Kubernetes using Pulumi, you'll be defining Kubernetes resources as well as custom resources provided by the Kong Ingress gateway. We'll be creating a setup that includes the following:

1. A Kubernetes `Deployment` that runs our API service within pods.
2. A Kubernetes `Service` which exposes the pods through a stable endpoint.
3. The Kong `Ingress` resource, which will define the rules to forward requests coming into the Kubernetes cluster to our service.

Each of these resources will be defined in TypeScript using Pulumi, which allows us to declare our infrastructure as code.

Before diving into the code, make sure you have the following requirements met:

- Pulumi CLI installed and configured with the desired Kubernetes context.
- Access to a Kubernetes cluster where you can deploy resources.

Below is the Pulumi program written in TypeScript that will create the necessary resources to expose APIs with Kong Ingress Controller on Kubernetes.

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

// Create a Kubernetes Deployment for our API app.
const appLabels = { app: "api-service" };
const deployment = new k8s.apps.v1.Deployment("api-service-deployment", {
    spec: {
        selector: { matchLabels: appLabels },
        replicas: 1,
        template: {
            metadata: { labels: appLabels },
            spec: {
                containers: [{
                    name: "api-container",
                    image: "my-api-image", // Replace with your API server image
                    ports: [{ containerPort: 8080 }],
                }],
            },
        },
    },
});

// Expose the deployment as a Kubernetes Service.
const service = new k8s.core.v1.Service("api-service", {
    metadata: { labels: deployment.metadata.labels },
    spec: {
        type: "ClusterIP",
        ports: [{ port: 80, targetPort: 8080 }],
        selector: appLabels,
    },
});

// Create a Kong Ingress resource to expose the API service to the internet.
const ingress = new k8s.networking.v1.Ingress("api-ingress", {
    metadata: {
        annotations: {
            "kubernetes.io/ingress.class": "kong",
        },
    },
    spec: {
        rules: [{
            http: {
                paths: [{
                    path: "/api",
                    pathType: "Prefix",
                    backend: {
                        service: {
                            name: service.metadata.name,
                            port: {
                                number: 80,
                            },
                        },
                    },
                }],
            },
        }],
    },
});

// Export the ingress endpoint to access the API.
export const ingressUrl = ingress.status.loadBalancer.ingress[0].hostname;
```

Here's how the code works:

- We import the necessary Pulumi and Kubernetes packages.
- We define a Kubernetes `Deployment` for our API service. The `image` property should be replaced with the Docker image of your API server.
- We create a Kubernetes `Service` to provide a stable endpoint for the pods created by the `Deployment`. The service will forward traffic to port 8080 on the containers because that's where we've configured our API server to listen.
- We create a Kubernetes `Ingress` resource that specifies a rule for routing traffic with the path "/api" to our API service. Note the annotation `"kubernetes.io/ingress.class": "kong"`. This tells the Kubernetes cluster to use the Kong Ingress Controller to handle this Ingress resource.
- We export the URL of the Ingress so that we can easily access our API from outside the Kubernetes cluster.

After running this Pulumi program, you will apply the resources to your Kubernetes cluster, and Kong will handle routing external requests to your API service based on the ingress rules defined.

Remember, this is a basic example to get you started. Depending on your actual API and the details of your cluster, you might need to adjust aspects of this configuration, such as annotations, image names, resource requirements, and more.