Deploy the openshift-logforwarding-splunk helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `openshift-logforwarding-splunk` Helm chart on a Google Kubernetes Engine (GKE) cluster, you need to perform several steps:

1. Create a GKE cluster.
2. Configure `kubectl` to connect to the GKE cluster.
3. Use Helm to deploy the `openshift-logforwarding-splunk` chart.

We will use Pulumi to programmatically accomplish these steps. Pulumi allows us to define our infrastructure as code using programming languages such as TypeScript.

Below, I will provide a Pulumi program written in TypeScript. This program will define the necessary infrastructure using GKE to host the Helm chart, and then proceed to deploy the chart.

First, let's go through the code step by step:

- Define a GKE cluster using the `Cluster` resource from the `@pulumi/google-native/container/v1beta1` package. This package provides us with the native Google Cloud resources.
- Set up Kubeconfig so that we can interact with the GKE cluster using `kubectl`.
- Deploy the Helm chart using the `Release` resource from the `@pulumi/kubernetes/helm.sh/v3` package. This resource represents a Helm chart release.

Now let's look at the code:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    location: "us-central1",
});

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

// Retrieve the Kubeconfig for 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
`;
    });

// Use Pulumi's Kubernetes provider to interact with the GKE cluster using the provided kubeconfig
const provider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the openshift-logforwarding-splunk Helm chart using Pulumi's Helm Release resource
const logForwardingChart = new k8s.helm.v3.Chart("openshift-logforwarding-splunk", {
    chart: "openshift-logforwarding-splunk",
    version: "X.Y.Z", // Specify the chart version you want to deploy
    fetchOpts: {
        repo: "https://helm-repo-url/", // Specify the Helm repository URL where the chart can be found
    },
    // You might need to add additional configuration settings for the chart,
    // such as values or namespace depending on the chart requirements.
    values: {
        // Add required Helm chart values here
    },
}, { provider });

// Export the chart status
export const chartStatus = logForwardingChart.status;
```

Make sure to replace `X.Y.Z` with the chart version and `https://helm-repo-url/` with the actual Helm repository URL containing the `openshift-logforwarding-splunk` chart.

This program starts by declaring a new GKE cluster with two nodes. Once the cluster is available, it extracts the kubeconfig, which is used to set up a Kubernetes provider. Finally, it defines a Helm chart release for `openshift-logforwarding-splunk`.

**Important**: Before running this program, ensure you've properly configured Pulumi with your GCP credentials, and that you've installed the Pulumi CLI on your machine.

To run this Pulumi program, create a new directory, change into it, and run `pulumi new typescript` to create a new TypeScript Pulumi project. Replace the contents of `index.ts` with the code provided above. Afterward, you can run `pulumi up` to deploy the infrastructure.

Please ensure that you look up the Helm chart's specific values and version to customize your deployment according to `openshift-logforwarding-splunk` Helm chart requirements.