Deploy the ceph-mon helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `ceph-mon` Helm chart on a Google Kubernetes Engine (GKE) cluster using Pulumi, you will need to perform the following steps:

1. **Create a GKE cluster**: This is where your Kubernetes workloads will run.
2. **Install the Helm chart**: Once the cluster is up and running, you will use Pulumi's Kubernetes provider to install the `ceph-mon` Helm chart onto the cluster.

The following TypeScript program uses Pulumi to accomplish these steps:

- It first creates a GKE cluster using the `gcp.container.Cluster` resource.
- Then it deploys the `ceph-mon` Helm chart using the `kubernetes.helm.sh/v3.Release` resource.

Here's a Pulumi program that defines these resources:

```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("ceph-mon-cluster", {
    initialNodeCount: 3,
    minMasterVersion: "latest", // Specify your desired version
    nodeConfig: {
        machineType: "n1-standard-2", // Adjust the machine type based on 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"
        ],
    },
});

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

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

// Create a Kubernetes Provider using the kubeconfig from the created cluster
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the ceph-mon Helm chart onto the cluster
const cephMonChart = new k8s.helm.v3.Release("ceph-mon", {
    chart: "ceph-mon",
    version: "1.0.0", // Please provide the version needed
    repositoryOpts: {
        repo: "https://ceph.github.io/charts", // Repo URL where the chart is located
    },
    namespace: "default",
}, { provider: k8sProvider });

// Export the Release name
export const cephMonReleaseName = cephMonChart.name;
```

Before running the above program, make sure you have Pulumi installed, the `gcloud` CLI configured for your Google Cloud account, and have the necessary permissions to create resources in your GCP project.

Here's a high-level overview of the code:

- **GKE Cluster**: The `gcp.container.Cluster` resource creates a new GKE cluster. The node count, Kubernetes version, and machine types are specified in the cluster definition. You may need to adjust these values according to your project requirements.
- **Kubeconfig**: The `kubeconfig` is generated from the cluster details. This configuration is necessary to allow Kubernetes-specific resources like Helm releases to interact with your cluster.
- **Kubernetes Provider**: The `k8s.Provider` resource uses the generated `kubeconfig` to establish a connection with the GKE cluster.
- **Helm Release**: The `ceph-mon` chart is installed on the GKE cluster using the `k8s.helm.v3.Release` resource. Be sure to specify the correct version of the chart and the URL of the Helm repository where the chart is located.

To run this program:

1. Save the code to a file named `index.ts`.
2. Run `pulumi up` to execute it. Pulumi will perform the deployment, showing you progress and outputs in the terminal.

This is a basic setup and typically, you would also specify other parameters for customization based on your application's requirements, such as storage classes, persistent volumes, and more configurations that are specific to the `ceph-mon