Deploy the aspecto-io-opentelemetry-collector helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `aspecto-io-opentelemetry-collector` Helm chart on a Google Kubernetes Engine (GKE) cluster using Pulumi, you will need to follow these steps:

1. **Create a GKE Cluster**: First, we will set up the GKE cluster where you want to install your Helm chart.
2. **Install Helm Chart**: Once the cluster is ready, we will use Pulumi's Helm support to deploy the `aspecto-io-opentelemetry-collector` Helm chart onto the GKE cluster.

We will be using the `@pulumi/gcp` package to create the GKE cluster, and the `@pulumi/kubernetes` package to operate Helm charts. You need to make sure you have these packages installed in your working environment.

Let's get to the code. This Pulumi TypeScript code will accomplish your goal:

```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
const cluster = new gcp.container.Cluster("gke-cluster", {
    // Basic cluster configuration: adjust as necessary
    initialNodeCount: 2,
    minMasterVersion: "latest", // It's recommended to set a specific version
    nodeVersion: "latest",
    nodeConfig: {
        // Specify the required machine type
        machineType: "n1-standard-1",
        // Enable OAuth scopes below as required by your environment
        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"
        ],
    },
});

// Obtain the kubeconfig from the GKE cluster
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: Deploy the Helm Chart onto the GKE cluster
const chart = new k8s.helm.v3.Chart("aspecto-io-opentelemetry-collector", {
    chart: "opentelemetry-collector",
    version: "0.7.0", // specify the desired chart version
    fetchOpts: {
        repo: "https://aspecto-io.github.io/opentelemetry-helm-charts",
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig }) });

// Export the Kubeconfig and GKE cluster name to access them later easily
export const kubeconfigOutput = kubeconfig;
export const clusterName = cluster.name;
```

Here is what we have done in the above program:

- We created a GKE cluster with the specified node count and machine type using the `gcp.container.Cluster` class. You will want to adjust these settings accordingly for production use.
- We generated a kubeconfig file that can be used to access the cluster with `kubectl` or from within any Kubernetes management tool that requires it.
- We created a new Helm chart deployment using the `k8s.helm.v3.Chart` class. The Helm Chart `opentelemetry-collector` is fetched from the specified Aspecto repository, with a version you can adjust to suit your needs.
- Finally, we exported the kubeconfig and the cluster name for later access.

You can adjust the Helm chart settings such as `version` and other configurations in the `Chart` resource based on the specific version and customizations you would like to deploy.

This code will deploy the `aspecto-io-opentelemetry-collector` chart with default settings. If you need to set custom values for your deployment, you can pass a `values` argument with an appropriate JSON object to the `Chart` resource.

After running this Pulumi program, the new GKE cluster will be created, and the OpenTelemetry Collector will be deployed within it. You can then check the status of Helm releases by using `kubectl` in conjunction with the generated kubeconfig file.