Deploy the fastly-exporter helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `fastly-exporter` Helm chart on Google Kubernetes Engine (GKE), you need to perform several steps. Firstly, you need to create a GKE cluster if you don't have one already. Once the cluster is set up, you need to configure `kubectl` and Helm to interact with the cluster and install the `fastly-exporter` Helm chart.

Using Pulumi to perform these steps involves creating Infrastructure as Code (IaC) which grants us the ability to define our cloud resources in a programmatic way using TypeScript. Pulumi will manage and provision the GKE cluster and deploy the Helm chart on it.

In this program, we'll use the `@pulumi/gcp` and `@pulumi/kubernetes` packages. The `@pulumi/gcp` package allows us to create and manage GCP resources including GKE clusters, while `@pulumi/kubernetes` provides the ability to manage Kubernetes resources, including deploying Helm charts.

### Detailed Steps:

1. **Create a GKE Cluster**: Define a GKE cluster resource.
2. **Get Kubeconfig**: Once the GKE cluster is provisioned, we obtain the kubeconfig file to access the cluster with `kubectl`.
3. **Deploy Helm Chart**: We use the Pulumi Kubernetes Provider to deploy the `fastly-exporter` Helm chart.

Assuming you've already installed the Pulumi CLI and set up the GCP provider, below is the TypeScript program that follows these steps:

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

// STEP 1: Create a GKE cluster

// Define the GKE cluster configuration
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        preemptible: true,
        machineType: "n1-standard-1",
    },
});

// STEP 2: Get the kubeconfig to interact with the cluster

// Generate the kubeconfig
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
`;
    });

// Invoke the k8s.Provider and give it the kubeconfig generated.
const provider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// STEP 3: Deploy the fastly-exporter Helm chart

const chart = new k8s.helm.sh.v3.Chart("fastly-exporter", {
    chart: "fastly-exporter",
    version: "0.4.2", // specify the chart version
    fetchOpts: {
        repo: "https://helm.your-repository.com", // specify the Helm repository URL
    },
    values: {
        // specify any values required for your chart
    },
}, { provider: provider });

// Export the public IP of the service to access the fastly-exporter
export const fastlyExporterServiceIp = chart.getResourceProperty("v1/Service", "fastly-exporter", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In the above program, replace `"https://helm.your-repository.com"` with the actual repository URL where the `fastly-exporter` Helm chart is located or remove it if it's available on the default Helm repository. Also, make sure to specify any values that are specific to the `fastly-exporter` chart under the `values` property.

After defining the cluster and Helm release, the program will export the IP address that can be used to access the `fastly-exporter` service after it is deployed and exposed via a load balancer.

This program should be placed into a file named `Pulumi.yaml`, the main entry point for Pulumi programs. To deploy this infrastructure, you will then navigate to the directory containing the `Pulumi.yaml` and run `pulumi up`, which will provision the resources as per the program written. If you need further information or wish to understand the extensive capabilities and resources available with Pulumi, you can refer to the [Pulumi documentation](https://www.pulumi.com/docs/).