Deploy the influxdb-srelay helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE), we first need to ensure that we have a GKE cluster up and running. Once we have the cluster, we can use Pulumi's `kubernetes` provider to deploy the Helm chart within that GKE cluster. For this process, we will be using two high-level components from Pulumi:

1. **GKE Cluster**: We will create a GKE cluster using the `google-native.container/v1.Cluster` resource. This will provision a managed Kubernetes cluster in GCP.
2. **Helm Release**: To deploy the influxdb-srelay Helm chart, we'll use the `kubernetes.helm.v3.Release` resource. This resource is a part of Pulumi’s Kubernetes provider, which is capable of deploying Helm charts into a Kubernetes cluster.

Below is a step-by-step TypeScript program that accomplishes these tasks. Note that the program assumes that you have Google Cloud credentials configured either via the Google Cloud SDK (`gcloud`) or by setting the appropriate environment variables (`GOOGLE_CREDENTIALS` or `GOOGLE_CLOUD_KEYFILE_JSON`).

### Detailed Program Explanation

- **`gcp.project.Project`**: This resource ensures we are operating within a specific GCP project. It’s a good practice to explicitly mention the project within Pulumi programs to avoid any confusion.
- **`google-native.container/v1.Cluster`**: This resource creates a GKE cluster. For simplicity, we create a small cluster, but in a production setting, you would adjust the properties like machine types, node counts, etc., according to your needs.
- **`kubernetes.helm.v3.Release`**: After the cluster is available, we deploy the influxdb-srelay Helm chart. We specify the chart name, version, and any chart values required for the configuration.

Remember to replace placeholders like `name`, `project`, and `location` with actual values for your GKE cluster.

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

// Set up a GCP project and GKE cluster configuration.
const name = 'influxdb-srelay-cluster';
const project = 'your-gcp-project'; // Replace with your GCP project ID
const location = 'us-central1'; // Replace with your desired GCP region

const cluster = new gcp.container.Cluster(name, {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    location,
    project,
});

// 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 = `${project}_${location}_${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
`;
    });

// Set up the Kubernetes provider to deploy the influxdb-srelay Helm chart.
const k8sProvider = new k8s.Provider('k8s-provider', {
    kubeconfig: kubeconfig,
});

// Deploy InfluxDB srelay Helm chart to the GKE cluster
const influxdbRelay = new k8s.helm.v3.Release("influxdb-srelay", {
    chart: "influxdb-srelay",
    version: "1.0.0", // set the chart version you wish to deploy
    // You can specify the repository if the Helm chart is not in the default Helm repo
    // repositoryOpts: {
    //     repo: "https://charts.your-repo.com",
    // },
    values: {
        // Custom values for your InfluxDB srelay deployment
        // e.g. configuration for the relay, InfluxDB connection details, etc.
        // This needs to be structured as per the chart's values.yaml file
    }
}, { provider: k8sProvider });

// Export the Helm release metadata
export const influxdbSrelayStatus = influxdbRelay.status;
```

This program defines the required resources and configuration to deploy an InfluxDB srelay on GKE using Pulumi. Once you've input your specific values, you can run this Pulumi program to provision your resources on GCP and deploy the Helm chart. This will give you an up-and-running instance of the InfluxDB srelay on Kubernetes, managed by GKE.

To apply this Pulumi program, save the code to a `index.ts` file and run `pulumi up` in the same directory. Pulumi CLI will perform the deployment according to the described plan.