Deploy the aws-container-insight-fluent-bit helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `aws-container-insight-fluent-bit` Helm chart on a Google Kubernetes Engine (GKE) cluster with Pulumi, you first need to set up a GKE cluster. Then you can use Pulumi to instantiate a Helm chart resource targeting that cluster.

In the following walkthrough, we will:

1. Create a GKE cluster.
2. Configure Pulumi to use our new GKE cluster as the Kubernetes provider.
3. Deploy the `aws-container-insight-fluent-bit` Helm chart to the GKE cluster.

Here is the TypeScript program that accomplishes these steps:

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

// Step 1: Create a GKE cluster
const name = "aws-insights-cluster";

const cluster = new gcp.container.Cluster(name, {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        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
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: Set up the Kubernetes provider
const k8sProvider = new k8s.Provider(name, {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy the aws-container-insight-fluent-bit Helm chart
const chart = new k8s.helm.v3.Chart("aws-container-insight", {
    repo: "amazon-cloudwatch",
    chart: "aws-container-insight-fluent-bit",
    version: "0.1.7",
    // You may need to include additional configuration here to suit your needs.
}, { provider: k8sProvider });

```

### Explanation:

- We're using the `@pulumi/gcp` package to create a new GKE cluster with a specified number of nodes and machine type.
- We then generate a kubeconfig file. This file is necessary for the Pulumi Kubernetes provider to communicate with our GKE cluster.
- The `@pulumi/kubernetes` package is used to create a new Kubernetes provider that's configured to deploy resources to our created GKE cluster.
- Finally, we declare our Helm chart, `aws-container-insight`, using the Pulumi Kubernetes provider. We specify the chart name along with the version and repository where it's located. The repository URL (`amazon-cloudwatch`) assumes that you have added the AWS CloudWatch repository to your Helm configuration.

Keep in mind, the specifics of the Helm chart configuration and the precise resource options for the GKE cluster are not detailed here and would depend on your exact requirements (such as network and security configurations, node pool specifics, etc.).

Remember to replace `"0.1.7"` in the Helm chart version with the actual version you are planning to deploy.

To run this Pulumi program, you will need to install Pulumi and configure your Google Cloud SDK and AWS CLI (if you are going to interact with AWS resources or if your Helm chart requires it).

Save the code in a file called `index.ts`, ensure you have the necessary Pulumi stacks and configurations set, and then run it using the Pulumi CLI:

```shell
pulumi up
```

Pulumi will perform a preview and display the resources that will be created. If everything looks correct, confirm the deployment to proceed. After the deployment, the Kubernetes resources defined in the chart will be running in your GKE cluster.