Deploy the argo-cr helm chart on Linode Kubernetes Engine

Question

Pulumi · Accepted Answer

To deploy the `argo-cd` Helm chart on the Linode Kubernetes Engine (LKE), you will need to do a few things:

1. Set up your Linode Kubernetes cluster.
2. Install the `argo-cd` Helm chart on your LKE cluster.

Since your cluster is already set up in this scenario, our focus will be on the second part, which involves writing a Pulumi program in TypeScript to deploy the `argo-cd` Helm chart to your cluster.

Here's the step-by-step process you will follow in the Pulumi program:

1. Define the necessary imports, including the `@pulumi/kubernetes` module which gives you the ability to interact with Kubernetes resources, including Helm charts, using Pulumi.

2. Instantiate a new Kubernetes provider that points to your LKE cluster. This requires you to have the `kubeconfig` file for your LKE cluster ready, which provides the necessary details to authenticate and communicate with your Kubernetes cluster.

3. Use the `Chart` resource from the Kubernetes provider to deploy `argo-cd` from its Helm chart. You may include configuration details such as values that override the defaults set in the Helm chart, the namespace in which to install it, and so on.

Below is the TypeScript Pulumi program that demonstrates the above process:

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

// Assumption: The Kubeconfig file for your Linode Kubernetes cluster is already set up
// and the KUBECONFIG environment variable points to the correct path.

// Define the Helm chart's repository and version.
const argoCdChart = "argo-cd";
const argoCdRepo = "https://argoproj.github.io/argo-helm";
const argoCdVersion = "3.2.3";  // Ensure to use the version compatible with your requirements.

// Create a Kubernetes provider using Kubeconfig credentials.
// This will use the 'kubeconfig' file specified by the KUBECONFIG environment variable.
const provider = new k8s.Provider("lke-provider", {
    kubeconfig: pulumi.getEnv("KUBECONFIG") || "", // Replace with actual kubeconfig content if needed
});

// Deploy the argo-cd Helm chart using the `Chart` resource provided by Pulumi's Kubernetes provider
const argoCdHelmChart = new k8s.helm.v3.Chart("argo-cd", {
    chart: argoCdChart,
    version: argoCdVersion,
    fetchOpts: {
        repo: argoCdRepo,
    },
    // Include any custom values to override Chart defaults here
    values: {
        // Example value override
        server: {
            service: {
                type: "LoadBalancer",
            },
        },
        // ... Additional override values ...
    },
}, { provider: provider });

// Export the Argo CD server's load balancer IP to access the Argo CD instance
export const argoCdServerIp = argoCdHelmChart.getResourceProperty("v1/Service", "argo-cd/argo-cd-server", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In the code above:
- The program first imports the necessary Pulumi libraries.
- It assumes that the `KUBECONFIG` environment variable is set, pointing to your kubeconfig file for the LKE cluster.
- The URL for the argo-cd Helm repository is provided along with the version of the Helm chart you wish to deploy.
- A new instance of the Kubernetes provider is created with the kubeconfig data.
- The argo-cd Helm chart is then deployed to the LKE cluster using the specified settings, with an optional values override if necessary.
- The IP address of the Argo CD server load balancer is exported so that you can access the Argo CD dashboard after deployment.

After writing the program, you would run the following Pulumi CLI commands to deploy the `argo-cd` Helm chart:

```sh
pulumi up
```

This command will preview and perform the deployment based on the Pulumi program you wrote.

You should replace any placeholders, such as specifying the actual kubeconfig content if the `KUBECONFIG` environment variable is not set, and adding any additional values you wish to override in the Helm chart.

Remember to ensure that your Pulumi version supports the Kubernetes provider used, and the Helm chart version you're deploying is compatible with your LKE cluster's Kubernetes version.