Deploy the konnectivity-agent helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the Konnectivity Agent helm chart on Google Kubernetes Engine (GKE), you will need to follow these steps:

1. **Set up a GKE cluster:** You'll need a GKE cluster where you can deploy the Konnectivity Agent. If you don't already have one, you can create it using Pulumi's GCP package.

2. **Install the Helm Chart:** Once you have your Kubernetes cluster, you can utilize the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes package to deploy the Konnectivity Agent helm chart.

Here is a TypeScript program that performs these tasks. I'll explain each part of the code below it.

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

// Create a GKE cluster.
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        machineType: "n1-standard-1",
        oauthScopes: [
            "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",
        ],
    },
});

// Export the Kubeconfig for the GKE cluster
const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      config:
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
    });

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

// Deploy the Konnectivity Agent helm chart using the Kubernetes provider.
const konnectivityAgent = new k8s.helm.v3.Chart("konnectivity-agent", {
    chart: "konnectivity-agent",
    version: "0.1.0", // Replace with the desired chart version
    fetchOpts: {
        repo: "https://kubernetes-sigs.github.io/konnectivity/" // Replace with the appropriate Helm repo URL if needed.
    },
}, { provider: k8sProvider });

// Export the necessary cluster details
export const clusterName = cluster.name;
export const kubeconfigFile = kubeconfig;
```

### Explanation:

1. **GKE Cluster Creation:** We start by creating an instance of `gcp.container.Cluster`. The provided parameters such as `initialNodeCount` and `nodeConfig` specify the size and the machine type for the cluster nodes. You can adjust these settings as needed.

2. **Export Kubeconfig:** This computes the kubeconfig file for the created GKE cluster. This file is necessary for configuring kubectl and the Pulumi Kubernetes Provider to communicate with your Kubernetes cluster.

3. **Kubernetes Provider:** An instance of `k8s.Provider` is created, which uses the outputted kubeconfig from the GKE cluster. This Kubernetes provider is used for deploying resources to the cluster.

4. **Deploy Helm Chart:** The `k8s.helm.v3.Chart` resource is used to deploy the Konnectivity Agent helm chart. Adjust the `chart` and `version` parameters to match the version you wish to deploy. Please note that you need the `repo` URL of the Helm Chart.

5. **Exports:** The program exports the `clusterName` and the `kubeconfigFile` so they can be accessed after deployment.

Remember to replace the placeholder `"0.1.0"` and `https://kubernetes-sigs.github.io/konnectivity/` with the actual version and the repository URL of the Konnectivity Agent helm chart.

Before you can run this Pulumi program, ensure you have set up the Pulumi CLI, authenticated it with your Pulumi account, and configured the GCP provider by logging in with gcloud and setting the appropriate config values for the project and zone.