Deploy the eolo-planner helm chart on Kubernetes

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Kubernetes using Pulumi involves several steps. First, we need to set up Pulumi with the Kubernetes provider. This allows Pulumi to interact with our Kubernetes cluster to manage resources. When using Helm with Kubernetes, you typically have to include the `Chart` resource from the `@pulumi/kubernetes` package. This package allows us to work with Kubernetes resources in a declarative way using Pulumi.

Here is a step-by-step guide to deploying the `eolo-planner` Helm chart:

1. Initialize a new Pulumi project in TypeScript, if you haven't already.
2. Install the necessary Pulumi Kubernetes package using npm or yarn.
3. Create a new TypeScript file for defining the resources you're going to deploy.

In this example, we will:
- Use the `Chart` resource to deploy the `eolo-planner` Helm chart.
- Assume that you have already configured your Pulumi to work with the desired Kubernetes cluster through the `kubeconfig` file.
- Specify any necessary chart values upon instantiation or rely on the chart's default values.

Let's walk through the TypeScript Pulumi code to accomplish this:

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

// The following code assumes that your Pulumi configuration is set up
// to point to the appropriate Kubernetes cluster.

const eoloPlannerChart = new k8s.helm.v3.Chart("eolo-planner", {
    // Specify the Helm chart repository and chart name.
    chart: "eolo-planner",
    // If the Helm chart is from a custom repository, specify it here.
    // For instance:
    // repo: "http://my-helm-chart-repo.com/",
    
    // Omit `version` to use the latest chart version or
    // specify a version string to pin to a specific chart version.
    // version: "1.2.3",

// You can provide custom values for the Helm chart here
    // Below is an example of custom values. The actual values would depend
    // on the 'eolo-planner' chart in question.
    // values: {
    //     service: {
    //         type: "LoadBalancer",
    //     },
    //     replicaCount: 2,
    // },

// Namespace where the Helm chart should be deployed.
    // Omit to use the default namespace or specify if needed.
    // namespace: "eolo-planner-ns",
}, { provider: /* Provide a specific K8s Provider if necessary */ });

// To interact with a resource created by the Helm chart, you can query it like so:
// This could be a Kubernetes Service, Deployment, StatefulSet, etc., depending on what the Helm chart provides.
const service = eoloPlannerChart.getResource("v1/Service", "eolo-planner-svc");
```

### Understanding the Components of the Code:

- We import the Kubernetes package from Pulumi which allows us to write Kubernetes resources using TypeScript.
- We instantiate a new Helm chart resource with the `Chart` class, specifying various options:
  - `chart` is the name of the Helm chart we want to deploy.
  - `repo` is the repository URL where the Helm chart is located (commented out here since it's for a custom repository).
  - `version` is the specific chart version to deploy (also commented out).
  - `values` is an optional set of overrides to the default chart values.
  - `namespace` is the namespace to which the chart should be deployed (commented out to use the default namespace).
- Optionally, we pass a provider instance to support scenarios where you might be managing resources in more than one cluster.
- `getResource` is used to retrieve a resource created by the Helm chart, if you need to reference it or interact with it outside of the chart.

Pulumi will use the information from the provided Kubernetes config (typically located at `~/.kube/config` or specified via the `KUBECONFIG` environment variable) to communicate with your Kubernetes cluster and deploy the Helm chart when you run `pulumi up`.

Next steps would involve running this TypeScript code with Pulumi:

```sh
pulumi up
```

This command will start the deployment. Pulumi will query your Kubernetes cluster, compare the desired state defined in your code (the Helm chart) with the actual state of your cluster, and execute the necessary steps to make your cluster match the desired state.

After the deployment, `eolo-planner` services and other resources can be interacted with using `kubectl` or Pulumi's query interfaces, letting you list, describe, or manage those resources as needed.