Deploy the nginx-test helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy the nginx-test Helm chart on Kubernetes using Pulumi, you will use the `Chart` resource from Pulumi's Kubernetes provider. This resource represents a collection of Kubernetes resources as specified by a Helm chart.

The `Chart` resource will manage the deployment by interfacing with Helm and Kubernetes to install, update, or delete the chart based on the defined configuration. By using the `Chart` resource, you can take advantage of Helm's chart management features while writing your infrastructure as code using Pulumi.

Below is a Pulumi program written in TypeScript that will deploy the `nginx-test` chart to a Kubernetes cluster. The program assumes that you already have a working Kubernetes cluster and that your `kubeconfig` file is set up correctly to communicate with the cluster.

The necessary steps are outlined in the code comments. Please make sure you have Pulumi CLI installed and setup with your Kubernetes cluster.

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

// Create a new instance of the Kubernetes Chart class.
const nginxTestChart = new k8s.helm.v3.Chart('nginx-test', {
    // Specify the chart to deploy and repository details if it's not a stable chart.
    // Since the nginx-test chart is not a well-known chart, you would need to provide the URL 
    // to its repository. If it was a chart in the stable repository or another well-known repository, you could
    // simply use the `repo` and `chart` properties.
    chart: 'nginx-test',
    // To specify a chart from a custom repository, replace 'YOUR_REPO_URL' with the actual URL of the repo.
    // repo: 'YOUR_REPO_URL'

// You can pass custom values to the chart using the `values` property. For instance, if you need to
    // modify the service type for the NGINX service to LoadBalancer, you would add here the custom values.
    // values: {
    //     service: {
    //         type: 'LoadBalancer'
    //     }
    // }

// Specify the namespace where the chart will be deployed. If not specified, it will be deployed
    // to the default namespace. Change 'default' to the desired namespace if needed.
    namespace: 'default',

// Optionally, you can specify the version of the chart you want to deploy.
    // version: '1.2.3',

// Additional options can be set if required such as fetchOpts.
    // fetchOpts: {
    //     repo: 'https://charts.bitnami.com/bitnami',
    // },
});

// Export the base URL for the NGINX service. The exact details of how you obtain the URL will depend on how NGINX is set up in the chart.
// Here is a general approach, assuming it creates a Service with type LoadBalancer.
// If your setup is different, you might need to modify this export statement accordingly.
export const nginxServiceUrl = nginxTestChart.getResourceProperty('v1/Service', 'nginx-test-nginx', 'status').apply(status => {
    return (status.loadBalancer.ingress[0].hostname || status.loadBalancer.ingress[0].ip);
});
```

To deploy your chart, save this Pulumi program in a TypeScript file (for example `index.ts`). Run `pulumi up` in the command line, while in the same directory as your TypeScript file, and Pulumi will execute the deployment to your Kubernetes cluster.

Note: The `getResourceProperty` method is used to retrieve a property of a resource created by the Helm chart. This is a dynamic operation since Pulumi doesn't know the exact structure of all Helm charts. The `apply()` function is part of Pulumi's programming model for dealing with Outputs, allowing you to interact with the properties of resources that aren't known until the time of deployment (such as the IP address assigned to a LoadBalancer service by your cloud provider).

Remember to customize the `chart`, `repo`, `namespace`, and `values` sections according to your specific Helm chart details and Kubernetes setup. If the NGINX Helm chart exposes certain customizable values, you can configure them within the `values` property of the `Chart` resource.

After successfully running `pulumi up`, you should see the outputs printed in your terminal. If the service type used in your Helm chart is indeed LoadBalancer, then there should be an external endpoint (hostname or IP) for you to access your NGINX server.