Deploy the myfirstdockerkuber helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE) using Pulumi, you'll need to complete a few steps:

1. **Set up a GKE cluster:** You need a Kubernetes cluster on GKE where you can deploy your Helm chart. This step involves creating a GKE cluster and configuring it appropriately.

2. **Deploy the Helm chart:** Once your cluster is set up, you'll use Pulumi's Kubernetes provider to deploy a Helm chart to your GKE cluster.

Here's how you can do this with Pulumi in TypeScript. The following program outlines the necessary components required to create a GKE cluster and deploy a Helm chart to that cluster.

### Detailed Steps:

1. **Initialize your Pulumi project:** This is typically done using `pulumi new` and selecting the appropriate template.

2. **Install the required Pulumi packages:** For GKE, you will need the `@pulumi/gcp` package, and for deploying a Helm chart, you will use the `@pulumi/kubernetes` package.

3. **Create a GKE cluster:** Define a GKE cluster resource using the `@pulumi/gcp` package.

4. **Create a Kubernetes provider:** Once the GKE cluster is created, use the cluster's credentials to configure a Pulumi Kubernetes provider.

5. **Deploy the Helm chart:** Use the `@pulumi/kubernetes` package to deploy the Helm chart with the Kubernetes provider configured in the previous step.

Below is the complete Pulumi program for deploying your Helm chart on a GKE cluster:

```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-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        machineType: "n1-standard-1",
    },
});

// Export the Cluster name
export const clusterName = cluster.name;

// Allocate a static IP for the cluster
const clusterIp = new gcp.compute.Address("cluster-ip");

// Export the static IP
export const clusterStaticIp = clusterIp.address;

// Obtain the Kubeconfig for the newly created GKE cluster.
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:
        access-token: ${masterAuth.accessToken}
        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("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy a Helm chart to the GKE cluster.
const chart = new k8s.helm.v3.Release("my-helm-chart", {
    chart: "myfirstdockerkuber",
    version: "0.1.0", // Replace with the version of your chart
    // Use namespace: <namespace-name> if you would like to deploy the chart in a specific namespace
}, { provider: k8sProvider });

// Export the Helm chart name
export const helmChartName = chart.name;
```

In the provided code:

- We created a GKE cluster with two nodes using the `gcp.container.Cluster` resource.

- We created a Kubernetes Provider that allows Pulumi to manage Kubernetes resources on the created cluster. The provider uses the kubeconfig from the created GKE cluster.

- We deployed the `myfirstdockerkuber` Helm chart using the `k8s.helm.v3.Release` resource. Please note that you need to replace the `version` field with the version number of your `myfirstdockerkuber` Helm chart if it's different.

- The `exports` are used to output important information when the Pulumi program is run, including the cluster name, cluster IP, and the Helm chart name.

To run the program:

1. Save the code in a file named `index.ts`.
2. Ensure you've installed Pulumi CLI and configured Google Cloud credentials.
3. Execute `pulumi up` to create the resources. This command will also output the cluster name, cluster IP, and the Helm chart name upon successful completion.

Please adjust the `machineType`, `initialNodeCount`, and Helm chart `version` based on your specific needs. If your Helm chart needs specific values, you can provide them in the `values` field of the `k8s.helm.v3.Release` args.