Deploy the shiny helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the Shiny Helm chart on Google Kubernetes Engine (GKE), we will undertake the following steps:

1. **Create a GKE cluster**: Using the `gcp.container.Cluster` resource, we will set up a new Kubernetes cluster on GKE.

2. **Deploy the Shiny Helm chart**: With the `kubernetes.helm.v3.Chart` resource, we will deploy the Shiny application using its Helm chart.

Before you begin, ensure you have the following prerequisites in place:
- **Pulumi**: You need to have the Pulumi CLI installed and configured with your GCP credentials.
- **GCP Project**: Ensure you have a Google Cloud Platform project set up with billing enabled.
- **Helm Chart**: The Helm chart for Shiny should be available in a Helm repository or locally.

Here's a TypeScript Pulumi program that accomplishes these steps:

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

// Create a GKE cluster.
const cluster = new gcp.container.Cluster("shiny-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest", // Use the latest available version for the master node
    nodeVersion: "latest", // Use the latest available version for the worker nodes
    nodeConfig: {
        // Specify the machine type based on your needs.
        machineType: "n1-standard-1",
        oauthScopes: [
            "https://www.googleapis.com/auth/cloud-platform",
        ],
    },
});

// Export the generated 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
`;
});

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy the Shiny Helm chart using our k8s provider.
const shinyChart = new k8s.helm.v3.Chart("shiny-helm-chart", {
    chart: "shiny", // Name of your Helm chart
    version: "1.0.0", // Version of your Helm chart
    // You should define the namespace if it's different from 'default'
    // namespace: "my-namespace", 
    // values: { /* Any custom Helm chart values would be specified here. */ },
}, { provider: k8sProvider });

// Export the Helm chart's status.
export const shinyHelmStatus = shinyChart.status;

```
Explanation:
- **gcp.container.Cluster**: This resource is used to create a new GKE cluster. The `initialNodeCount` parameter specifies the number of worker nodes.
- **kubeconfig**: After the cluster is created, we generate a kubeconfig file, which is necessary to communicate with the Kubernetes cluster. This kubeconfig is then exported as an output.
- **k8s.Provider**: We create a new Kubernetes provider instance using the kubeconfig. This provider is responsible for deploying resources to our GKE cluster.
- **k8s.helm.v3.Chart**: This resource stands for a Helm chart deployment. We deploy the Shiny Helm chart, specifying the chart name and version. If the chart requires custom values, they can be provided in the `values` field.

The above program sets up a Kubernetes cluster and deploys the Shiny application using Helm. The `kubeconfig` and `shinyHelmStatus` are exported so that you can interact with the cluster and inquire about the Helm release status.

Once you have this program ready, you can run it using the Pulumi CLI:

1. Run `pulumi up` to preview and deploy the changes.
2. After the deployment is complete and if you have Helm installed locally, you can check that the Shiny Helm chart is deployed by running `helm list` with the provided kubeconfig file.

Please note that in a real-world scenario, you should check the Shiny Helm chart documentation for any prerequisites and special configuration it might need. This program assumes the chart is available and ready to deploy without modifications.