Deploy the google-tag-manager helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the Google Tag Manager Helm chart on Google Kubernetes Engine (GKE), we need to follow a few steps:

1. Set up a GKE cluster: We require a Kubernetes cluster where the Helm chart will be deployed. This will involve creating a GKE cluster resource in Pulumi.
2. Install Helm and Tiller: Helm is the package manager for Kubernetes, and Tiller is the server-side component that Helm communicates with. Starting with Helm 3, Tiller is no longer required.
3. Deploy the Helm chart: Once Helm is set up and the cluster is ready, we can deploy the Helm chart to the cluster.

Below is a program written in TypeScript using Pulumi that will create a GKE cluster and deploy the Google Tag Manager Helm chart to it. I'll guide you through the steps with appropriately commented code explaining each segment.

Firstly, ensure that you have installed the Pulumi CLI, set up the Google Cloud SDK on your local machine, and configured Google Cloud authentication. Once that’s done, you can follow this Pulumi program:

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

// Step 1: Create a new GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest", // It's advisable to use a specific version.
    nodeVersion: "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 Kubeconfig for 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: Create a Kubernetes provider instance that uses our cluster's kubeconfig
const provider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy the Google Tag Manager Helm chart
// Replace `REPOSITORY_URI` with the actual repository URI and `CHART_VERSION` with the appropriate chart version
const googleTagManagerChart = new k8s.helm.v3.Chart("google-tag-manager", {
    chart: "google-tag-manager",
    version: "CHART_VERSION",
    fetchOpts: {
        repo: "REPOSITORY_URI",
    },
}, { provider: provider });

// Export the URL to access the deployed Google Tag Manager (this will likely require further configuration based on the specific chart values and setup)
// For example, if the chart exposes a service of type LoadBalancer, you may retrieve the external IP as follows:
export const googleTagManagerUrl = googleTagManagerChart.getResourceProperty("v1/Service", "google-tag-manager-service", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

Explanation:

1. **GKE Cluster Creation**: `gcp.container.Cluster` - This resource sets up a GKE cluster with the specified configuration. Adjust the `initialNodeCount`, `machineType`, and other properties based on your requirements and budget. Learn more about [GKE Clusters](https://www.pulumi.com/registry/packages/gcp/api-docs/container/cluster/).

2. **Kubernetes Provider**: `k8s.Provider` - This resource sets up the Kubernetes provider with the kubeconfig from the created GKE cluster, which will be used to communicate with our Kubernetes cluster for subsequent operations.

3. **Google Tag Manager Helm Chart**: `k8s.helm.v3.Chart` - This resource is responsible for deploying the Google Tag Manager Helm chart to your cluster. You'll need to replace `REPOSITORY_URI` and `CHART_VERSION` with appropriate values where the Helm chart is located and the version number, respectively. You can obtain this metadata from the harbor repository you are using or the Helm chart documentation.

Keep in mind that Helm charts may expose their services in various ways (LoadBalancer, NodePort, ClusterIP). The `googleTagManagerUrl` exported in the program assumes a LoadBalancer service is created by the chart, which may not be the case for Google Tag Manager, and thus, this export may need to be adjusted based on the actual service type and properties defined by the Helm chart you deploy.

Before running this program, you'll need to install the necessary Pulumi packages using npm or yarn, as well as have the appropriate IAM permissions to create resources in GKE. This code should be considered a starting point, and further configurations may be required to tailor it to your specific deployment scenario.