Deploy the sentry-kubernetes helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `sentry-kubernetes` Helm chart on AWS EKS using Pulumi, you need to do the following:

1. Create an EKS cluster: This involves setting up the necessary IAM roles and VPC configuration, then creating an EKS cluster with those settings.
2. Install the Helm chart on the EKS cluster: After the cluster is up and running, you will use the Pulumi Kubernetes provider to deploy the `sentry-kubernetes` Helm chart to the cluster.

Below is a detailed program written in TypeScript that demonstrates these steps.

First, make sure you have installed the necessary Pulumi packages by running:

```shell
pulumi plugin install resource kubernetes v4.4.0
pulumi plugin install resource aws v6.13.3
```

You also need to have `kubectl`, `helm`, and `aws-iam-authenticator` installed in your system, as they are prerequisites for interacting with EKS.

Now, let's start with the Pulumi program:

```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 an EKS cluster.
const cluster = new eks.Cluster("my-cluster", {
    // Specify the desired version for the EKS cluster.
    version: "1.21",
    // Define the VPC configuration for the EKS cluster.
    vpcConfig: {
        // It's recommended to define the VPC and subnets manually or use existing ones to have more control.
        // For simplicity, we let EKS create its own VPC with defaults.
    }
});

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

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

// Deploy the sentry-kubernetes Helm chart using the Kubernetes provider.
const sentryChart = new k8s.helm.v3.Chart("sentry-kubernetes", {
    chart: "sentry-kubernetes",
    // You can specify the chart version to use.
    version: "11.4.0", // Using an example version, please replace with your specific chart version.
    // Define values to override the chart's default configuration.
    // For example, this includes the necessary configuration settings.
    values: {
        // Add your configuration here.
    },
    // Set this to the namespace where you want to install the chart.
    namespace: "default",
}, { provider: k8sProvider });

// When the program is deployed, you will be able to use `pulumi up` to create the resources.
// After deployment, the EKS cluster will be accessible using the outputted kubeconfig.
// You can use `kubectl` to interact with your cluster using this kubeconfig file.
// The Sentry Kubernetes Helm chart will be deployed into the default namespace (or the one you specify).
```

### Explanation:

- `eks.Cluster`: This creates a new Amazon EKS cluster. We define the desired Kubernetes version and VPC configuration here. To keep things simple, we let EKS create its own VPC with default settings, but in a production environment, you'll likely want to specify existing VPC and subnet IDs.
  
- `export const kubeconfig = cluster.kubeconfig`: This line exports the kubeconfig that will be generated for our EKS cluster. This kubeconfig will allow us to interact with our Kubernetes cluster using `kubectl`.

- `new k8s.Provider`: This is a Pulumi Kubernetes provider that is configured to manage resources in the EKS cluster we just created using the kubeconfig from the EKS cluster.

- `k8s.helm.v3.Chart`: This deploys a Helm chart into your Kubernetes cluster. The chart of interest is `sentry-kubernetes`. You'd need to provide any custom values to configure `sentry-kubernetes` as per your needs. It's also important to specify the chart version to ensure you're deploying the version you have tested with.

After writing this code, you can run the Pulumi CLI to deploy it:

```shell
pulumi up
```

This command will provision the EKS cluster and deploy the `sentry-kubernetes` Helm chart. The exact configuration would need to be adjusted based on your specific requirements for `sentry-kubernetes`, such as setting up persistent storage, ingress controllers, etc.