Using kubernetes traefik.containo.us with configuration.konghq.com

Question

Pulumi · Accepted Answer

To use Traefik with Kong on Kubernetes, you would typically set up Traefik as the Ingress controller and Kong as the API gateway serving your applications. Traefik will be responsible for routing external HTTP(S) traffic to your services, while Kong can handle more fine-grained API management tasks like authentication, rate-limiting, and transformations.

Here is how you can set up both using Pulumi with TypeScript:

1. **Traefik**: You will install Traefik as an Ingress controller that listens for incoming requests and routes them based on your configuration.
2. **Kong**: You will then deploy Kong as a Kubernetes service and set up routing for internal service traffic, potentially adding Kong-specific configurations for managing the APIs.

Let's create a Pulumi program in TypeScript to install Traefik as an Ingress controller and then set up Kong.

Before we start with the code, make sure you have the following prerequisites in place:
- A Kubernetes cluster
- `kubectl` configured to interact with your cluster
- Pulumi CLI installed
- `@pulumi/kubernetes` package installed for your Pulumi project

Now, let's construct the Pulumi program.

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

// Initialize a Pulumi Kubernetes Provider using the current context of kubectl.
const provider = new k8s.Provider('k8s-provider', { kubeconfig: process.env.KUBECONFIG });

// Deploy Traefik as an Ingress Controller using its Helm chart.
const traefikIngress = new k8s.helm.v3.Chart(
    'traefik-ingress',
    {
        chart: 'traefik',
        repo: 'traefik',
        version: '9.18.2', // Use an appropriate version for Traefik.
        namespace: 'kube-system', // You can deploy it to an appropriate namespace.
    },
    { provider }
);

// Deploy Kong API Gateway using its Helm chart.
const kongApiGateway = new k8s.helm.v3.Chart(
    'kong-api-gateway',
    {
        chart: 'kong',
        repo: 'kong',
        version: '2.3.0', // Use the appropriate version for Kong.
        namespace: 'kong', // Deploy Kong in its separate namespace.
        values: {
            // You might have to set additional configurations depending on your needs.
            // Refer to the Kong Helm chart documentation for configuration options.
        },
    },
    { provider }
);

// Export the external IP address of the Traefik Ingress once it is ready.
export const traefikExternalIP = traefikIngress.getResourceProperty(
    'v1/Service',
    'kube-system/traefik-ingress',
    'status'
).apply(status => status.loadBalancer.ingress[0].ip);

// Similarly, export the external IP for the Kong API Gateway.
export const kongExternalIP = kongApiGateway.getResourceProperty(
    'v1/Service',
    'kong/kong-api-gateway',
    'status'
).apply(status => status.loadBalancer.ingress[0].ip);
```

The above program does the following:
- It initializes a Pulumi provider for Kubernetes which uses the current context from `kubectl`.
- It then uses the Pulumi Kubernetes Helm Chart resources to deploy both Traefik and Kong from their respective Helm charts.
- Finally, it exports the external IP addresses for both Traefik and Kong, which you can use to access the services externally.

Remember to replace the chart versions with the correct versions that you want to use and apply any additional chart values that are specific to your use case for Traefik and Kong. The Helm charts for these projects expose a variety of configuration options that allow you to customize the setup as needed. You can find more details in the documentation for the Traefik Helm chart [here](https://doc.traefik.io/traefik/providers/kubernetes-ingress/) and the Kong Helm chart [here](https://github.com/Kong/charts).

Once you run this Pulumi program, it will deploy the desired state to your Kubernetes cluster, and if everything is set up correctly, you should be able to see both Traefik and Kong running in your cluster by checking the resources in their respective namespaces.