Deploy the bitwarden-rs helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `bitwarden-rs` Helm chart on AWS Elastic Kubernetes Service (EKS), we need to accomplish a few key tasks:

1. **Create an EKS Cluster**: This will be the Kubernetes environment where the Bitwarden application will run.
2. **Deploy the Helm Chart**: Once the cluster is set up, we'll use the Helm package manager to deploy `bitwarden-rs`.

Let's start by creating the EKS cluster. We'll be using the `eks.Cluster` resource which is a high-level component that simplifies the creation and configuration of an EKS cluster.

After setting up the EKS cluster, we will install the `bitwarden-rs` Helm chart using the `kubernetes.helm.v3.Chart` resource.

Here is the Pulumi TypeScript program that accomplishes these tasks:

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

// Create an EKS cluster with the default configuration.
const cluster = new eks.Cluster("my-cluster", {});

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

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

// Define the Helm chart for bitwarden-rs.
const bitwardenChart = new k8s.helm.v3.Chart("bitwarden-rs", {
    repo: "some-repo", // Specify the correct Helm chart repository here.
    chart: "bitwarden-rs",
    version: "some-version", // Specify the chart version here.
    // Set custom values for the Helm chart as required.
    values: {
        /* Provide any specific configuration if needed, e.g.,
         service: { type: "LoadBalancer" },
         ingress: { enabled: true, hosts: ["bitwarden.mydomain.com"] },
         etc...
        */
    },
}, { provider: k8sProvider });

// Export the endpoint to access bitwarden-rs.
export const bitwardenEndpoint = bitwardenChart.getResourceProperty("v1/Service", "bitwarden-rs", "status").apply(status => status.loadBalancer.ingress[0].hostname);

```

### Explanation
1. We import the necessary packages: `pulumi`, `@pulumi/eks` for the EKS cluster, and `@pulumi/kubernetes` for Kubernetes resources.
2. We create an instance of an EKS cluster with default settings through `eks.Cluster`.
3. We export the `kubeconfig`, which will contain the configuration needed to connect to our Kubernetes cluster.
4. We instantiate a Kubernetes provider by passing our `kubeconfig`. This provider will handle deploying resources to our EKS cluster.
5. We define a `kubernetes.helm.v3.Chart` representing the `bitwarden-rs` Helm chart deployment.
   - We need to specify the correct Helm chart repository and version.
   - Additionally, we can set any required custom values.
6. We export `bitwardenEndpoint`, which is the host or IP address where we can access the `bitwarden-rs` service once deployed.

Please make sure to replace the Helm chart repository (`repo`), chart (`chart`), and version (`version`) placeholders with the actual values specific to `bitwarden-rs`.

Make sure you have configured the Pulumi CLI with AWS credentials and have Helm and kubectl installed locally. Once you have this program ready, you can create a new Pulumi stack and deploy it with `pulumi up`.

### Stack Exports
- `kubeconfig`: This output will give you the configuration required to connect to your Kubernetes cluster using tools like `kubectl`.
- `bitwardenEndpoint`: This will provide you with the address to access the Bitwarden service once it's running.