Deploy the logdna-agent helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `logdna-agent` Helm chart on Google Kubernetes Engine (GKE), you will need to perform several steps which involve:

1. Setting up a GKE cluster.
2. Installing the Helm chart on the cluster.

Below are descriptions of the main resources we'll use:

- `google-native.container/v1beta1.Cluster`: This resource is used to provision a GKE cluster. You can specify various properties of the cluster, such as its location, node pools, and networking settings.

- `kubernetes.helm.sh/v3.Release`: This resource represents a Helm chart release within the Kubernetes cluster. Helm is a package manager for Kubernetes that allows you to define, install, and upgrade complex Kubernetes applications. The `Release` resource defines the Helm chart to deploy (`logdna-agent` in our case), as well as configuration settings that might be required for the chart.

Let's go through the code. You'll need to have Pulumi installed and configured to interact with your Google Cloud account. The following code example is written in TypeScript and will:

1. Create a GKE cluster.
2. Configure Kubeconfig to interact with the new cluster.
3. Deploy the `logdna-agent` Helm chart to the created GKE cluster.

Make sure you have installed the necessary Pulumi providers by running `npm install @pulumi/gcp @pulumi/kubernetes` in the directory where you're working.

Here is the Pulumi program:

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

// Step 1: Create the GKE cluster.
const cluster = new gcp.container.Cluster("logdna-cluster", {
    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",
        ],
    },
});

// Step 2: Configure the Kubernetes provider to use the created 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
`;
    });

const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy the logdna-agent Helm chart.
const logdnaAgentChart = new k8s.helm.v3.Chart("logdna-agent", {
    chart: "logdna-agent",
    version: "2.1.7",   // specify the chart version you want to deploy
    fetchOpts: {
        repo: "https://assets.logdna.com/charts",  // the Helm chart repository
    },
}, { provider: k8sProvider });

// Export the Kubeconfig to a file.
export const kubeconfigFile = kubeconfig;
```

In the code above:

- We create a GKE cluster using the `gcp.container.Cluster` resource. This cluster is configured with two nodes of `n1-standard-1` machine types. More properties can be configured as per your requirements.

- The Kubeconfig is built using the properties of the created cluster to interact with it via the kubectl command-line tool or any Kubernetes SDK.
  
- We instantiate the `kubernetes.helm.sh/v3.Release` with `logdna-agent`, providing the chart's location in the `repo` URL, and using the GKE cluster we created as the target for deployment specified by the `provider` option.

Lastly, the program exports `kubeconfigFile`, which can be used to interact with your cluster using kubectl command-line tool.

Before running this code, ensure you have the right permissions set up in Google Cloud IAM and your Pulumi account is configured with the correct credentials and default settings for the project and zone.
  
After placing this code in a file (e.g., `index.ts`), run `pulumi up` to execute the program, which will provision these resources in your GCP account.

Please replace the `version` with the desired version of the `logdna-agent` Helm chart if different from the one specified in the code. Also, ensure the chart version is compatible with your GKE cluster version.