Deploy the sumologic-fluentd helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the Sumo Logic Fluentd Helm chart on Google Kubernetes Engine (GKE), you'll need to perform a few key tasks:

1. **Create a GKE cluster**: Start by provisioning a Google Kubernetes Engine (GKE) cluster where your applications will run.
   
2. **Setup Helm and Tiller**: Ensure Helm and its server-side component, Tiller, are installed and properly configured in your GKE cluster.

3. **Deploy the Helm chart**: Once Helm is set up, you can deploy the Sumo Logic Fluentd Helm chart to your GKE cluster.

Below is a Pulumi program in TypeScript that handles these tasks:

1. **`google-native.container/v1beta1.Cluster`**: This resource is used to create a GKE cluster.

2. **`kubernetes.helm.v3.Chart`**: This Pulumi resource represents a Helm chart which we'll use to deploy the Sumo Logic Fluentd Helm chart.

The Sumo Logic Fluentd Helm chart collects logs from Kubernetes clusters and delivers them to Sumo Logic for monitoring and analysis.

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

// Specify the required GCP project and zone where the GKE cluster will be deployed
const gcpConfig = new pulumi.Config("gcp");
const project = gcpConfig.require("project");
const zone = gcpConfig.require("zone");

// Create a GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    location: zone,
    project: project,
});

// Export the clusters' kubeconfig
export const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const context = `${gcpConfig.require("project")}_${gcpConfig.require("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:
    client-certificate-data: ${masterAuth.clientCertificate}
    client-key-data: ${masterAuth.clientKey}
`;
    });

// Initialize a new Kubernetes provider instance by using the kubeconfig from the created cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Deploy the Sumo Logic Fluentd Helm chart using the 'helm.v3.Chart' resource
const sumologicFluentdChart = new k8s.helm.v3.Chart("sumologic-fluentd", {
    chart: "sumologic-fluentd",
    version: "1.0.0", // use the desired version of the chart
    fetchOpts:{
        repo: "https://sumologic.github.io/sumologic-kubernetes-collection", // official Sumo Logic Helm repo
    },
}, { provider: k8sProvider }); // specify the provider created above

// Export the Helm chart name and namespace once it is deployed
export const chartName = sumologicFluentdChart.metadata.apply(metadata => metadata.name);
export const chartNamespace = sumologicFluentdChart.metadata.apply(metadata => metadata.namespace);
```

### Explanation:

1. **GKE Cluster**: We begin by creating a GKE cluster with two nodes using the `gcp.container.Cluster` class. We provide the zone and project details, specifying that the cluster should use the latest versions available for the nodes and the master.

2. **Kubeconfig**: After the cluster is created, we generate a kubeconfig file using the output properties of the cluster (like its endpoint and master authentication data). This kubeconfig allows us to communicate with the cluster.

3. **Kubernetes Provider**: With the kubeconfig, we initialize a Pulumi Kubernetes provider which we'll use for deploying resources to the cluster.

4. **Helm Chart Deployment**: Finally, we deploy the Sumo Logic Fluentd Helm chart by defining a `helm.v3.Chart` resource. The `chart` property specifies which Helm chart to deploy, and the `fetchOpts.repo` property specifies the repository where the chart is hosted.

5. **Exports**: The `chartName` and `chartNamespace` provide output of where the Helm chart was deployed for easy reference.

To run this Pulumi program:

1. Ensure you've [installed Pulumi](https://www.pulumi.com/docs/get-started/install/) and set up the [GCP command-line tools](https://cloud.google.com/sdk/gcloud).
   
2. Ensure you're authenticated with GCP and have set the appropriate configuration for Pulumi to use:

```
   gcloud auth login
   gcloud config set project your-gcp-project
   pulumi config set gcp:project your-gcp-project
   pulumi config set gcp:zone your-gcp-zone
   ```

3. Save the code in a file with a `.ts` extension, ensure you have `package.json` configured with the required packages, and run `pulumi up` to execute the program. This will provision the GKE cluster and deploy the Sumo Logic Fluentd Helm chart on it.