Deploy the basic-git-server helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE) using Pulumi, you need to follow these steps:

1. Create a GKE cluster using Pulumi's `gcp.container.Cluster` resource. This will provision a Kubernetes cluster on Google Cloud Platform.
2. Use Pulumi's `kubernetes.helm.sh/v3.Release` resource to deploy a Helm chart to the GKE cluster you've created.

Below is a Pulumi program in TypeScript that demonstrates how to perform these steps.

First, ensure you have set up the Pulumi CLI and configured your Google Cloud credentials. You should also have Helm installed if you need to fetch or manage Helm chart values locally.

Now, let's go through the program:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Choose the machine type based on your needs
    },
});

// Export the Kubeconfig
export 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 cluster from above.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy a Helm chart for a basic git server
const gitServerChart = new k8s.helm.v3.Release("basic-git-server", {
    chart: "basic-git-server",
    version: "1.0.0", // Replace with the desired chart version
    repositoryOpts: {
        repo: "http://charts.example.com/", // Replace with the repository where the chart is hosted
    },
}, { provider: k8sProvider });

// Export the Git server endpoint so that we can easily access it.
export const gitServerEndpoint = pulumi.interpolate`http://${cluster.endpoint}`;

```

This program completes the following actions:

- It imports the required modules and sets up the configuration needed to communicate with your cloud provider and Kubernetes.
- It provisions a new GKE cluster with a specified number of nodes and machine types appropriate for your workloads.
- It generates a kubeconfig file that allows kubectl and Pulumi to communicate with your Kubernetes cluster.
- It creates a Kubernetes provider configured to connect to the newly created GKE cluster.
- It deploys the "basic-git-server" Helm chart to your GKE cluster using the Kubernetes provider.
- It exports the endpoint of the Git server so you can access the service hosted on the GKE cluster.

Make sure to replace placeholders like `http://charts.example.com/` with the actual values appropriate for the Helm chart you wish to deploy.

Once you've set up the Pulumi program correctly, you can run it using the following Pulumi CLI commands:

```sh
pulumi up   # To preview and deploy the changes
```

After the deployment is successful, Pulumi will output the Git server endpoint that you can use to interact with your Git server hosted on GKE.