Deploy the trino-exporter helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `trino-exporter` Helm chart on Google Kubernetes Engine (GKE), we will follow these steps:

1. **Set up a GKE Cluster**: We will start by creating a GKE cluster, which will serve as the environment to run our Helm chart. In Pulumi, we use the `google-native.container.v1.Cluster` resource for this purpose.
   
2. **Install the Helm Chart**: After setting up the GKE cluster, we use the `kubernetes.helm.sh/v3.Release` resource from the Kubernetes provider to deploy the `trino-exporter` Helm chart to the cluster.

3. **Configure Kubeconfig**: To interact with the Kubernetes cluster, we need to set up kubeconfig. Pulumi provides a way to retrieve the kubeconfig from the created GKE cluster.

Let's start by creating the GKE cluster:

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

// Configure Google Cloud provider
const project = "your-gcp-project"; // replace with your GCP project ID
const zone = "us-west1-a"; // replace with your desired GCP Zone

const cluster = new gcp.container.Cluster("trino-cluster", {
    initialNodeCount: 1,
    minMasterVersion: "latest", // specify the master version or set to "latest"
    nodeVersion: "latest",
    location: zone,
    nodeConfig: {
        machineType: "e2-medium", // adjust the machine type according to your needs
        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"
        ],
    },
    project: project,
});

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

// Obtain the kubeconfig from 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
`;
    });

// Export kubeconfig for kubectl
export const kubeConfig = kubeconfig;

// Initialize Kubernetes provider
const k8sProvider = new k8s.Provider("k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the trino-exporter Helm chart
const trinoExporterChart = new k8s.helm.v3.Chart("trino-exporter", {
    chart: "trino-exporter",
    version: "0.1.0", // replace with the desired chart version
    fetchOpts:{
        repo: "https://helm-repository/trino", // replace with the trino Helm chart's repository URL
    },
}, { provider: k8sProvider });

// Export the trino-exporter service endpoint
export const trinoExporterEndpoint = trinoExporterChart.getResourceProperty("v1/Service", "trino-exporter", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In this program, you first set up a new GKE cluster with the desired node count and machine types that suit your requirements.

The `kubeconfig` is generated to allow `kubectl` and other Kubernetes tooling to interact with your new cluster. We then initialize the Kubernetes provider (`k8sProvider`) with this `kubeconfig`.

We next deploy the `trino-exporter` Helm chart using the `Chart` resource from the Pulumi Kubernetes (`@pulumi/kubernetes`) package. The `fetchOpts` option is used to specify the location of the Helm chart repository.

Finally, we're outputting the endpoint of the `trino-exporter` service which can be used to interact with the Trino exporter once it is up and running.

To use this code, replace placeholders like `"your-gcp-project"`, `"us-west1-a"` and the Helm repository URL (`"https://helm-repository/trino"`) with values that are appropriate for your use case. You may also need to adjust the Kubernetes master and node versions to those supported by your GKE environment.

Make sure you have Pulumi installed and configured to use your GCP account. Then, run the following commands to deploy the Helm chart:

```bash
# Login to Pulumi. This will require a Pulumi account.
pulumi login

# Create a new Pulumi stack, which is an isolated environment for your project.
pulumi stack init trino-exporter-stack

# Deploy the Pulumi stack which will create the GKE cluster and deploy the chart
pulumi up
```

Pulumi will show you a preview of the resources that will be created and prompt you for confirmation before proceeding with the deployment. Once the deployment is complete, you can use the exported `trinoExporterEndpoint` to connect to your Trino exporter service.