Deploy the zipkin-gcp helm chart on Google Kubernetes Engine (GKE)

To deploy the Zipkin GCP Helm chart on Google Kubernetes Engine (GKE), you will need to perform two main steps:

1. Create a GKE cluster where the Helm chart will be deployed.
2. Install the Helm chart onto the GKE cluster.

Below, you will find the program written in TypeScript which uses Pulumi to set up a GKE cluster and then deploy the Zipkin GCP Helm chart.

Firstly, we'll create a GKE cluster by using the gcp.container.Cluster resource from Pulumi's GCP provider. When setting up the GKE cluster, you need to define certain properties, such as the name of the cluster, the desired number of nodes, machine types, etc.

After the cluster is created, the next step will be to deploy Helm charts. Pulumi's Helm support enables you to declaratively install, manage, and use Helm charts within your Pulumi program. In this case, we will use the pulumi/kubernetes/helm/v3 module's Chart resource to deploy the Zipkin GCP chart. You will need to specify the repository URL or a local path where the chart can be found, along with any values that need to be configured.

Here is the complete TypeScript program:

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("zipkin-cluster", {
    initialNodeCount: 1,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Default machine type
        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;

// Once the cluster is created, we can connect to the Kubernetes cluster using the provided kubeconfig
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Deploying the Zipkin GCP Helm chart on the GKE cluster
const zipkinChart = new k8s.helm.v3.Chart("zipkin-chart", {
    chart: "zipkin",
    version: "2.3.4", // Make sure to use the version you need
    fetchOpts: {
        repo: "https://kubernetes-charts.storage.googleapis.com/", // Replace with the repository that contains the chart
    },
    values: {
        // Specify any values that are necessary for the chart here
        // For example:
        // storage: {
        //     type: "persistent",
        //     size: "10Gi",
        // },
    }, 
}, { provider: k8sProvider });

// Export the status of the Helm deployment
export const helmStatus = zipkinChart.status;

Before you run your Pulumi program, make sure you have configured the Pulumi CLI with your GCP credentials and configured the Kubernetes provider to point to the correct context if necessary.

This program defines a GKE cluster and deploys the Zipkin chart to it. The cluster setup is minimal for illustration, but in a production environment, you'd likely want to specify additional configurations such as node pool configuration, more extensive OAuth scopes, and network policies. The chart deployment assumes the chart's default values suffice, but typically you'd customize the chart values to your needs.

To run this Pulumi program:

1. Save the code in a file with a .ts extension (e.g., index.ts).
2. Run pulumi up in the CLI from the directory where the file is saved.
3. Pulumi will preview the changes and prompt you to proceed with the deployment.
4. Once you confirm, it will set up the GKE cluster and deploy the Zipkin chart to it.

Please make sure to change any placeholders in this code to their actual values that are specific to your use case, like chart version, repository url, or custom values for the Helm chart.