Deploy the route53-kubernetes helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Google Kubernetes Engine (GKE) involves several steps. We'll go through them systematically to ensure you have a clear understanding.

1. **Set up a GKE cluster**: You need a Kubernetes cluster on GKE to deploy any applications using Helm. We will create a GKE cluster using the `google-native.container/v1beta1.Cluster` resource.

2. **Install Helm in your environment**: Helm must be installed in your environment to manage the deployments.

3. **Deploy the Helm chart**: Once Helm is installed, and the GKE cluster is ready, we can use the Helm chart to deploy `route53-kubernetes`. We will use the `kubernetes.helm.sh/v3.Release` resource to perform the deployment.

Let's break down the Pulumi program. Here is a TypeScript example showing how to set up a GKE cluster and deploy a Helm chart:

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

// Create a GKE cluster for our Helm chart deployment.
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    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"
        ],
    },
});

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

// Export the Kubeconfig to access 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
`;
    });

// Use the GKE cluster's kubeconfig to create a Provider which we will use to deploy the Helm chart.
const provider = new k8s.Provider("my-gke-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the Helm chart for route53-kubernetes.
const route53Chart = new k8s.helm.v3.Chart("route53-kubernetes", {
    chart: "route53-kubernetes",
    version: "0.1.0", // replace with the desired chart version
    fetchOpts: {
        repo: "https://charts.example.com/", // replace with the Helm chart repository
    },
}, { provider: provider });

// Export the Helm chart deployment status
export const helmChartStatus = route53Chart.status;
```

In the code above:

- We're importing the necessary Pulumi packages.
- We create a GKE cluster with the `gcp.container.Cluster` resource.
- We then export the `kubeconfig` needed for Kubernetes tooling to interact with the GKE cluster.
- A `k8s.Provider` resource is used to specify the cluster where we will deploy the Helm chart.
- We deploy the `route53-kubernetes` Helm chart using the `k8s.helm.v3.Chart` resource, which represents a Helm chart deployment.

**Important:** Replace `chart`, `version`, and `repo` attributes with the correct information for the `route53-kubernetes` Helm chart you wish to deploy. The repository URL provided (`https://charts.example.com/`) is for illustration purposes and must be substituted with the actual URL of the Helm repository that hosts your desired chart.

After setting up your Pulumi program with the code above, you can run the following commands:

```bash
# Login to Pulumi (this example uses the Pulumi service backend)
pulumi login

# Create a new Pulumi stack, which is an isolated environment for your project
pulumi stack init dev

# Preview the deployment changes. Pulumi will show you the expected changes before they are applied
pulumi up --yes
```

This series of commands will prompt Pulumi to start provisioning the resources on GCP. The `pulumi up --yes` command actually applies changes: creating the GKE cluster and deploying the Helm chart. Remember to authenticate with GCP and configure gcloud CLI on your local machine beforehand.

Once the deployment is completed, Pulumi will output the exported variables, such as `clusterName` and `kubeconfig`. You can use these outputs to interact with your GKE cluster using kubectl or other Kubernetes tools.