Deploy the argocd-instance helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To accomplish the task of deploying the Argo CD instance helm chart on Google Kubernetes Engine (GKE), we will proceed with the following steps:

1. **Set up the GKE cluster**: We will write code to provision a GKE cluster using the `google-native.container/v1beta1.Cluster` resource. This will create a Kubernetes cluster on GCP.

2. **Install and Configure Helm for Kubernetes**: Helm is a package manager for Kubernetes that allows you to define, install, and upgrade even the most complex Kubernetes applications. We will use the `kubernetes.helm.sh/v3.Release` Pulumi resource to deploy the Argo CD helm chart.

3. **Deploy Argo CD helm chart**: After setting up Helm, we will describe the helm release for the Argo CD application, which includes specifying necessary configurations such as chart name, repository and values that are required for the Argo CD helm chart.

Let's get started with the Pulumi TypeScript program to create a GKE cluster and deploy the Argo CD helm chart:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("argocd-cluster", {
    initialNodeCount: 1,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // The type of machine to use for nodes
        oauthScopes: [ // Set of scopes to be made available on all of the node VMs.
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring"
        ],
    },
});

// Create a Kubernetes provider instance that uses our GKE cluster
const k8sProvider = new k8s.Provider("argocd-k8s", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy Argo CD helm chart using the Pulumi Kubernetes Provider
const argocdChart = new k8s.helm.v3.Chart("argocd", {
    repo: "argo", // The Helm repository name
    chart: "argo-cd", // The name of the chart
    version: "3.2.3", // The version of the chart
    fetchOpts:{
        repo: "https://argoproj.github.io/argo-helm", // The URL to the Helm repository
    },
}, { provider: k8sProvider });

// Export the cluster's name and kubeconfig
export const clusterName = cluster.name;
export const kubeconfig = cluster.kubeconfig;

```

### Explanation

- We import the necessary Pulumi packages: `@pulumi/gcp` for Google Cloud resources and `@pulumi/kubernetes` for interacting with Kubernetes.

- The `gcp.container.Cluster` resource creates a new GKE cluster with a specified number of nodes and machine type.

- We configure the Kubernetes nodes to have the appropriate OAuth scopes that allow the VM instances to interact with other Google Cloud services.

- After the cluster is created, we instantiate a Pulumi Kubernetes Provider, `k8s.Provider`, which allows us to interact with the created cluster. The provider needs the kubeconfig of the cluster to manage resources inside it.

- Using the Kubernetes provider, we create an instance of `k8s.helm.v3.Chart`, which represents the Argo CD helm chart deployment. Here, we must specify the chart name, version, and repository information.

- Finally, we export two stack outputs: the name of the created GKE cluster and its kubeconfig. These outputs can be used to interact with the cluster, for example, through the `kubectl` command-line tool.

Run this program with the Pulumi CLI to create your GKE cluster and deploy Argo CD using Helm:

```sh
$ pulumi up
```

Remember to replace placeholders such as the machine type and OAuth scopes with the actual values that are appropriate for your use case. The chart version should be the one compatible with your cluster and requirements.