Deploy the sneakers helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Kubernetes using Pulumi, we will use the `kubernetes.helm.sh/v3.Chart` resource. This resource represents a Helm chart, a prepackaged set of Kubernetes resources that can be deployed as a unit. To use this resource, we need a Kubernetes cluster where the chart will be deployed. The Helm chart can be found in a public or private Helm repository, or it can be loaded from a local path.

Below is a Pulumi TypeScript program that demonstrates how to deploy the "sneakers" Helm chart on Kubernetes. We will make some assumptions for this example, such as:

1. There is an existing Kubernetes cluster where the application will be deployed.
2. The "sneakers" Helm chart is available in a public Helm repository.
3. You are using default settings for the Helm chart without custom values.

Please ensure you have `@pulumi/kubernetes` library installed in your project to execute this program.

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

// Create a Helm Chart resource using `kubernetes.helm.sh/v3.Chart`.
const sneakersChart = new k8s.helm.v3.Chart("sneakers", {
    // Specify the chart name to be deployed.
    chart: "sneakers",
    // You can specify the Helm repository where the chart is located.
    // For instance, if the chart is in the Bitnami repository, configure as follows:
    // If the chart is in a private repository or requires authentication, specify additional
    // configuration options in `fetchOpts`.
    // If the chart requires specific configuration values, provide them in the `values` object.
});

// Export the base URL of the deployed sneakers service, if applicable.
// To do this, you may need to define a service in your chart with a valid selector,
// and ensure that the service is of the type NodePort or LoadBalancer. 
// After deployment, the URL can be retrieved from the Kubernetes service resource 
// corresponding to the sneakers application.
```

In this program, we're creating a `Chart` resource called `sneakersChart`. We specify the name of the Helm chart (`"sneakers"`) we want to deploy. We assume that the Helm chart is available in a public repository. If you need to specify the chart's repository, you will need to add an additional `repo` key within the parameters passed to the `Chart` object.

Note that since we have not specified a namespace, the chart will be installed in the default namespace. If you wish to deploy it in a different namespace, you can provide the `namespace` property in the ChartArgs object.

Also, if your Helm chart requires specific configuration parameters (provided in the `values` file for Helm), you can supply them in the `values` key as a JavaScript object where the property name corresponds to the configuration key and the property value corresponds to the configuration value.

Once the Helm chart is deployed, you might want to access the services it provides. You can export details like service URLs or other relevant information using Pulumi stack exports. However, that requires some additional code to query Kubernetes resources created by the chart to extract endpoints, which are not included in this example. If you need such functionality, you will have to customize the Pulumi code further.

Before running this program, please ensure that you've selected the appropriate Kubernetes context that points to your cluster where you want to deploy the Helm chart. You can do this by configuring the kubeconfig file or setting the `KUBECONFIG` environment variable.

Run the program using the Pulumi CLI to preview and deploy your Helm chart on your Kubernetes cluster:

```sh
pulumi up
```

This command will show you a preview of what will happen. Confirm the changes to apply them to your cluster. After successful deployment, Pulumi will print the outputs defined in the stack, such as the base URL of the sneakers service—if you add code to export that information.