Deploy the longhorn-monitoring helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `longhorn-monitoring` Helm chart on a Google Kubernetes Engine (GKE) cluster using Pulumi, you'll need to perform the following steps:

1. **Set up a GKE cluster**: Before you can deploy any applications via Helm, you need to have a Kubernetes cluster running. Google Kubernetes Engine offers managed Kubernetes clusters that are easy to scale and operate.

2. **Install the Helm chart**: A Helm chart is a collection of pre-configured Kubernetes resources that can be deployed as a single unit. You will install the `longhorn-monitoring` chart to your GKE cluster, which will set up monitoring for Longhorn, a cloud-native distributed storage system built on Kubernetes.

Here's a Pulumi program in TypeScript that demonstrates these steps:

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

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        preemptible: true,
        machineType: "n1-standard-1",
        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",
        ],
    },
});

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

// Export the Kubeconfig to access the 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:
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
});

// Step 2: Set up the Helm Chart for Longhorn Monitoring
const longhornMonitoringChart = new k8s.helm.v3.Chart("longhorn-monitoring", {
    chart: "longhorn",
    version: "1.1.0", // Replace with the actual chart version you want to deploy
    fetchOpts: {
        repo: "https://charts.longhorn.io",
    },
    values: {
        monitoring: {
            // Provide configuration for monitoring according to your needs
            // This is just an example value structure; you'll need to consult the Longhorn monitoring chart's values for actual configuration options
            enabled: true,
            serviceMonitor: {
                interval: "30s",
                scrapeTimeout: "30s",
            },
        },
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: kubeconfig }) });

// Export the name of the Helm release
export const helmReleaseName = longhornMonitoringChart.releaseName;
```

### Explanation of the Code:

1. **GKE Cluster Setup**:
    - Using the `@pulumi/gcp` package, we create a GKE cluster with 2 nodes (`initialNodeCount: 2`).
    - The `nodeConfig` section is where we specify the type of machine (`machineType: "n1-standard-1"`) and the access scopes needed for the nodes.
    - We've also enabled pre-emptible instances to save cost, which are cheaper but may be terminated by GCP at any time.

2. **Exporting Cluster Name and Kubeconfig**:
    - We export the name of the cluster using `export const clusterName`.
    - The kubeconfig needed to interact with the cluster programmatically is generated and exported as `kubeconfig`. It's constructed using information such as the cluster endpoint and the master's auth credentials.

3. **Helm Chart for Longhorn Monitoring**:
    - Using the `@pulumi/kubernetes` package, we deploy a Helm chart with a specified version and values.
    - In the `values` section of the Helm chart, monitoring is enabled and configured. The configuration provided in `values` is just for illustration; you should use the appropriate values that match the Longhorn monitoring chart's settings and your requirements.
    - We specify the Kubernetes provider with the kubeconfig we exported earlier to ensure proper authentication and authorization against the GKE cluster when deploying the Helm chart.

**To use this program:**

- Install Pulumi and set up the GCP CLI with credentials.
- Save this code in a file, for example `index.ts`.
- Run `pulumi up` to preview and deploy the resources.
- After the deployment, use the exported kubeconfig to manage your cluster with `kubectl` or other Kubernetes tools.