Deploy the splunk-operator helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the splunk-operator Helm chart on AWS EKS using Pulumi, you'll need to accomplish a few steps:

1. **Create an EKS Cluster**: Use the Pulumi EKS package to create an Amazon EKS cluster. This will be the Kubernetes cluster where your applications will run.
2. **Deploy the Helm Chart**: Once the cluster is up and running, you'll use the Pulumi Kubernetes provider to deploy the splunk-operator Helm chart onto your EKS cluster.

Let's walk through the code to perform these steps.

### Creating an EKS Cluster

First, you need to create an EKS cluster. For this, you can use the `eks.Cluster` class from the `@pulumi/eks` package, which provides a high-level abstractive way to set up an EKS cluster. The cluster will be created with some default managed node groups where your Kubernetes workloads will run.

Here's how you set up the cluster:

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

// Create a new EKS cluster.
const cluster = new eks.Cluster("splunk-operator-cluster", {
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
    instanceType: "t2.medium", // Change to a larger type if required by the workload
});

// Export the cluster's kubeconfig.
export const kubeconfig = cluster.kubeconfig;
```

The `desiredCapacity`, `minSize`, and `maxSize` parameters configure the autoscaling properties of the cluster's default node group. `instanceType` defines the type of EC2 instance to use for the node group. Adjust these according to your requirements.

### Deploying the Helm Chart

Next, you'll deploy the splunk-operator Helm chart. The Pulumi Kubernetes provider gives you a class `Chart` from the `@pulumi/kubernetes/helm/v3` module that enables Helm chart deployments.

To deploy the chart, we need to ensure that the EKS cluster is up and running and that the Kubernetes provider knows which cluster to interact with. This is achieved by passing the EKS cluster's kubeconfig to the Kubernetes provider.

Here's how you deploy the Helm chart:

```typescript
// Create a Kubernetes provider instance that uses our EKS cluster from above.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig,
});

// Deploy the splunk-operator Helm chart.
const splunkOperatorChart = new k8s.helm.v3.Chart("splunk-operator", {
    chart: "splunk-operator",
    version: "0.2.1", // Specify the version of the Helm chart you want to deploy
    fetchOpts: {
        repo: "https://splunk.github.io/splunk-connect-for-kubernetes/", // The repository containing the splunk-operator chart
    }
}, { provider: k8sProvider });

// Export the Helm chart's resources
export const splunkOperatorResources = splunkOperatorChart.resources;
```

In the above code:

- `chart`: Refers to the name of the chart in the Helm repository.
- `version`: Specifies the chart version you wish to deploy.
- `fetchOpts.repo`: Contains the URL where the Helm chart can be found.

To complete these operations with Pulumi, you need to install the required Pulumi packages:

```bash
$ pulumi new typescript # If starting from scratch
$ npm install @pulumi/pulumi @pulumi/aws @pulumi/eks @pulumi/kubernetes
```

After installing the packages, execute the following commands to log in to Pulumi and deploy the stack:

```bash
$ pulumi up
```

This will create the EKS cluster and deploy the splunk-operator Helm chart in it. When completed successfully, Pulumi will give you an output with the kubeconfig and any other exported resources.

Remember that Helm charts can have custom values. If you need to override any default values provided by the splunk-operator chart, include a `values` object in the `Chart` constructor.

With Pulumi, you've written infrastructure code in TypeScript, which provides strong typing and first-class functions. This gives you the ability to write highly reusable and modular infrastructure as code.