Deploy the flaskapp helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Kubernetes using Pulumi, you will be using the `kubernetes.helm.v3.Chart` resource. This resource allows you to deploy a Helm chart from various sources such as a repository or a local path. It manages the installation of the chart similar to how `helm install` works but through Pulumi's infrastructure as code approach.

Below is a complete Pulumi program written in TypeScript that deploys the `flaskapp` Helm chart to a Kubernetes cluster. The project assumes that you have a Kubernetes cluster configured and accessible via `kubectl` from the machine where you run this Pulumi program. The cluster could be a local one like Minikube or a cloud-based one on providers like AWS, Azure, or GCP.

First, ensure that you have installed the necessary Pulumi packages by running the following commands:

```bash
pulumi plugin install resource kubernetes v4.4.0
npm install @pulumi/kubernetes
```

Now, here's the Pulumi TypeScript program that deploys the `flaskapp` Helm chart:

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

// Define the Helm Release using the Flaskapp Helm chart from a repository.
const flaskAppRelease = new kubernetes.helm.v3.Chart("flaskapp-helm-release", {
    chart: "flaskapp",
    // Specify the repository where the chart can be found.
    // You will need to replace this with the actual repository URL of your Flaskapp Helm chart.
    // For example, if your chart is stored in a Helm repo, then you can use `repo: "https://charts.myorg.com/"`.
    // Alternatively, if you have a chart stored locally, use the `path: "./path-to-your-chart"` property instead.
    repo: "https://helm-repository.org/charts",
    // The namespace where this chart will be installed in your cluster.
    namespace: "default",
    // Values allow you to provide configurations to override default values in the chart.
    // You should set these values according to your chart's values.yaml file.
    values: {
        service: {
            type: "ClusterIP",
        },
    },
}, {
    // Optionally, you can specify a provider if you are managing multiple Kubernetes clusters.
    // If omitted, Pulumi will use the default provider as configured by your kubeconfig.
});

// Export the name of the namespace that the chart was deployed into
export const namespace = flaskAppRelease.namespace;
// Export the services to access, for instance, the URL of the deployed Flask app.
export const appServiceName = flaskAppRelease.getResourceProperty("v1/Service", "flaskapp-helm-release-flaskapp", "metadata").name;
```

### Explanation:

1. We import the Pulumi Kubernetes package which allows us to interact with Kubernetes resources.

2. Using `kubernetes.helm.v3.Chart`, we define a Helm release. This resource is used to describe a Helm chart deployment, similar to how `helm install` would work on the command line.

3. The `chart` parameter specifies the Helm chart's name to deploy, which in our case is "flaskapp".

4. Through the `repo` parameter, you provide the Helm repository URL where the chart can be found. Replace the provided example URL with the actual URL to your Helm chart repository or provide a local path to your chart using the `path` parameter.

5. The `namespace` parameter specifies the Kubernetes namespace where the Helm chart should be installed. If this namespace doesn't exist, Helm will create it during deployment.

6. The `values` parameter allows you to override the default values in the chart's `values.yaml` file. Here it's used to set the `service.type` to "ClusterIP", but you could customize this to fit your chart's requirements.

7. The `getResourceProperty` function is used to retrieve specific data from the deployed resources. Here we're retrieving the name of the Service created by the Helm chart, which could be used to construct the access URL for the Flask application.

8. We also use the `export` statement which is a Pulumi feature that marks values to be displayed in the output after executing `pulumi up`. Here we export the namespace and the service name that can be useful for querying the cluster about the deployment.

To run this program:

1. Create a new directory for your Pulumi project.
2. Run `pulumi new typescript` in that directory and provide the required details.
3. Replace the contents of `index.ts` with the code above.
4. Modify the placeholders to suit your Flask Helm chart details.
5. Run `pulumi up` to deploy your Helm chart to the Kubernetes cluster.

After running `pulumi up`, you will see a summary of the resources Pulumi will create. Confirm the deployment to proceed, and Pulumi will deploy your `flaskapp` Helm chart to the Kubernetes cluster and output any exported values.