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

Question

Pulumi · Accepted Answer

To deploy a Node.js application using Helm on Google Kubernetes Engine (GKE), we must perform the following steps:

1. Set up a GKE cluster.
2. Deploy the Helm chart for our Node.js application to the GKE cluster.

In Pulumi, we define our infrastructure as code using classes and functions from specific Pulumi packages. For this task, we'll use the `@pulumi/gcp` package to create the GKE cluster and the `@pulumi/kubernetes` package to deploy the Node.js application using Helm.

Below is a Pulumi TypeScript program that outlines these steps. To understand the flow of the program, follow the inline comments which explain each part of the process.

Firstly, make sure you have Pulumi and the GCP SDK installed and your GCP credentials configured. You can install the required Pulumi packages using npm or yarn:

```bash
npm install @pulumi/gcp @pulumi/kubernetes
```

or

```bash
yarn add @pulumi/gcp @pulumi/kubernetes
```

Now, let's define our infrastructure.

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

// Export the Cluster name and Kubeconfig
export const clusterName = cluster.name;
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:
    client-certificate-data: ${masterAuth.clientCertificate}
    client-key-data: ${masterAuth.clientKey}
`;
    });

// Instantiate the Kubernetes provider using the generated kubeconfig from the GKE cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Deploy the Helm chart for the Node.js application
const nodeAppChart = new k8s.helm.v3.Chart("node-app", {
    chart: "node",
    version: "1.0.0", // specify the version of the chart if necessary
    fetchOpts: {
        repo: "http://charts.example.com/", // replace with the URL of the Helm chart repository containing the Node.js chart
    },
}, { provider: k8sProvider });

// Export the status of the deployed Helm chart
export const nodeAppStatus = nodeAppChart.status;
```

This program will do the following:

- Import the necessary Pulumi modules.
- Create a new GKE cluster with a specified machine type and node count.
- Generate a kubeconfig file to interact with the GKE cluster using Kubernetes-based tools.
- Instantiate an instance of the Kubernetes provider using the kubeconfig of the GKE cluster.
- Use the Kubernetes provider to deploy a Helm chart for the Node.js application.

Remember to replace `http://charts.example.com/` with the URL of the Helm chart repository containing the Node.js chart you want to deploy.

After writing down this code in a TypeScript file (e.g., `index.ts`), you can run it with Pulumi by executing the following command in your terminal:

```bash
pulumi up
```

This will prompt Pulumi to provision the resources defined in the code. Make sure you have selected the appropriate Pulumi stack and configured it with your GCP project and zone settings.

Once the deployment is completed, you will have your Node.js application running on a GKE cluster managed by Pulumi.