Deploy the kubeservice-namespace-node-affinity helm chart on Kubernetes

Question

Pulumi · Accepted Answer

Deploying a Helm chart on a Kubernetes cluster with Pulumi involves several steps:

1. **Setting up the Pulumi Kubernetes provider**: This allows us to interact with the Kubernetes cluster where the Helm chart will be deployed.

2. **Creating a Kubernetes `Namespace`**: Although optional, it's a best practice to deploy services in their own namespaces to help organize resources within Kubernetes.

3. **Using `Chart` resource from Pulumi's Kubernetes provider**: The `Chart` resource represents a Helm Chart that can be applied to your cluster. You need to pass the name of the chart and configuration settings like `values` for customizing the deployment.

4. **Applying Node Affinity**: Node Affinity is a set of rules used by the scheduler to determine where a pod can be placed. The rules are defined in the `values` object of the Helm chart which allows you to specify which nodes your application's pods are scheduled on.

Below is a TypeScript program that performs these steps:

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

// Create a Kubernetes Namespace where the Helm chart will be deployed.
const ns = new kubernetes.core.v1.Namespace("app-namespace", {
    metadata: { name: "node-affinity-ns" }
});

// Define the Helm chart release. You need to specify the chart and repository.
// You can also configure chart values in the `values` property.
const helmChart = new kubernetes.helm.v3.Chart("my-kube-service", {
    namespace: ns.metadata.name,
    chart: "kubeservice-namespace-node-affinity",
    // Imagine this chart is available in a Helm repo; replace with actual chart repo
    fetchOpts: { 
        repo: "http://your-helm-chart-repository.com/",
    },
    // Custom values for the Helm chart, including node affinity rules
    values: {
        // Example values. You'll need to replace these with your actual node affinity values
        nodeSelector: {
            "disktype": "ssd"
        },
        affinity: {
            nodeAffinity: {
                requiredDuringSchedulingIgnoredDuringExecution: {
                    nodeSelectorTerms: [{
                        matchExpressions: [{
                            key: "kubernetes.io/e2e-az-name",
                            operator: "In",
                            values: ["e2e-az1", "e2e-az2"]
                        }]
                    }]
                }
            }
        }
    },
}, { dependsOn: [ns] });

// Export the Namespace name and the Helm chart status
export const namespaceName = ns.metadata.name;
export const helmChartStatus = helmChart.status;
```

In the above program:

- We import the Pulumi Kubernetes package.
- We create a new Kubernetes namespace named `node-affinity-ns` that will contain our service.
- We set up a new Helm chart with a given chart name `kubeservice-namespace-node-affinity` assuming that it exists in the specified repository.
- The `values` property within the `Chart` resource is used to provide custom configuration to the chart. This snippet shows how you might configure node affinity, but you should customize it with actual values applicable to your environment.
- Finally, we export the namespace name and Helm chart status so that you can easily retrieve them after deployment using the Pulumi CLI.

To run this Pulumi program:

- Install Pulumi CLI and set up the Kubernetes provider.
- Write the above code into a file named `index.ts` in a new Pulumi project directory.
- Install the required NPM packages by running `npm install`.
- Deploy the application by running `pulumi up` from your command line within the project directory.

Make sure your Kubernetes cluster is configured correctly in your environment, and you have the necessary access rights to deploy resources to the cluster. The Pulumi Kubernetes provider will use your current context as configured in your kubeconfig file.