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

Question

Pulumi · Accepted Answer

To deploy the Terracotta helm chart on Google Kubernetes Engine (GKE) using Pulumi, you'll perform several steps. I will guide you through each of them, providing explanations and code to achieve your goal.

1. **Set up a GKE cluster**: First, you need a running Kubernetes cluster on GKE. Pulumi allows you to create a GKE cluster by defining appropriate resources.

2. **Install the Helm chart**: After your cluster is up and running, you will need to use the Pulumi Kubernetes Provider to install the Terracotta helm chart.

### Step 1: Create a GKE Cluster

The `google-native.container/v1.Cluster` resource is used from the `google-native` Pulumi provider to create a GKE cluster. This resource allows you to define your cluster's properties like its location, node pools, network policies, etc.

### Step 2: Deploying the Helm Chart

Once the cluster is in place, you'll use the Pulumi Helm Release resource from the Kubernetes Provider to deploy the Terracotta helm chart onto your cluster. You need to set up a Kubernetes provider that points to the created GKE cluster to use the Kubernetes resources.

Now let's look at the full Pulumi TypeScript program that combines these steps:

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

// Step 1: Provision a GKE cluster
const cluster = new gcp.container.Cluster("terracotta-cluster", {
    // Specify the location for your cluster
    location: "us-central1",
    minMasterVersion: "latest", // Use the latest GKE version
    initialNodeCount: 2,
    // Define the node configuration
    nodeConfig: {
        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",
        ],
    },
});

// Expose the Kubeconfig for the GKE 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: Create a Kubernetes provider instance using the GKE cluster's kubeconfig
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy the Terracotta Helm chart using the Kubernetes provider
const terracottaChart = new k8s.helm.v3.Chart("terracotta", {
    chart: "terracotta",
    version: "x.y.z", // replace with the desired chart version
    fetchOpts: {
        repo: "http://path.to/your/helm/repo",
    },
}, { provider: k8sProvider });

// Export the Terracotta Helm deployment's status
export const terracottaStatus = terracottaChart.status;
```

### Explanation
- **GKE Cluster**: We create a GKE cluster with a specified name, location, GKE version, and node configuration, including machine type and OAuth scopes.
- **Kubeconfig Output**: We create a Kubeconfig file that will be used to interact with our GKE cluster outside of Pulumi, for instance using `kubectl`.
- **Kubernetes Provider**: We instantiate a Kubernetes provider that uses the created Kubeconfig to interact with our GKE cluster.
- **Helm Chart Deployment**: We deploy the Terracotta helm chart to the GKE cluster using the Kubernetes provider.

This program creates a GKE cluster and deploys the Terracotta helm chart to it. Replace `x.y.z` with the chart version you wish to deploy and `http://path.to/your/helm/repo` with the Terracotta Helm repository URL.

You'll need to run this code using the Pulumi CLI. Make sure you have Pulumi installed and configured to access your GCP account. If you don't have a helm repo for Terracotta, you'll need to locate one or create your helm chart.

To proceed, save this code to a file (e.g., `index.ts`), run `pulumi up` via the terminal in the directory containing your new Pulumi project, and follow the prompts to deploy your infrastructure.