Deploy the minio-standalone helm chart on AWS EKS

Question

Pulumi · Accepted Answer

In this guide, we're going to deploy a MinIO standalone instance using the MinIO Helm chart on Amazon EKS (Elastic Kubernetes Service). MinIO is a high-performance, distributed object storage system, designed for large-scale private cloud storage.

We will accomplish this in a few steps:

1. **Set up an EKS Cluster:** We will create an AWS EKS cluster using Pulumi's `eks` package. This will give us a managed Kubernetes cluster in AWS that we can use to deploy our applications.

2. **Deploy MinIO using Helm Chart:** After setting up the EKS cluster, we will use the `kubernetes` package to deploy MinIO using its official Helm chart.

### Prerequisites

Before you start, make sure that you have the following tools installed:

- `pulumi-cli`: The command-line tool for Pulumi
- `aws-cli`: The command-line tool for AWS
- `kubectl`: The command-line tool for Kubernetes

Also, ensure you have set up your AWS credentials and have the necessary permissions to create resources in your AWS account.

### Program for Deployment

Below is the Pulumi TypeScript program that sets up an EKS cluster and deploys MinIO onto it.

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

// Create an EKS cluster
const cluster = new eks.Cluster("my-cluster", {
    desiredCapacity: 2, // Define the number of worker nodes
    minSize: 1,
    maxSize: 3,
    storageClasses: "gp2", // Setting up the storage class
    deployDashboard: false, // EKS cluster dashboard is not required for this setup
});

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

// Set up a provider to use the created cluster's kubeconfig so that we can deploy resources to it
const provider = new k8s.Provider("provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Now, let's deploy MinIO using the Helm chart.
const minioChart = new k8s.helm.v3.Chart("minio", {
    chart: "minio",
    version: "8.0.10", // Specify the chart version you wish to deploy 
    namespace: "default", // Deploying in the 'default' namespace, but you can create and specify your own
    fetchOpts: {
        repo: "https://helm.min.io/", // MinIO Helm chart repository
    },
    values: {
        accessKey: "minio", // Specify your own access key
        secretKey: "minio123", // Specify your own secret key
        service: {
            type: "LoadBalancer",
        },
        // Add any additional configurations you need here
    },
}, { provider });

// Print out the LoadBalancer endpoint once it's available
export const minioEndpoint = minioChart.getResourceProperty("v1/Service", "minio", "status").apply(status => status.loadBalancer.ingress[0].hostname);

```

This program does the following:

- It creates an EKS cluster with the desired configuration using `eks.Cluster`.
- We set up a provider that uses the created cluster's kubeconfig.
- We deploy the MinIO Helm chart available from MinIO's Helm repository into the `default` namespace. In production, you should create a dedicated namespace.
- We then export the MinIO LoadBalancer's endpoint for you to access your MinIO instance.

To run this program:

1. Save the above code to a file named `index.ts`.
2. Run `pulumi up` from the command line in the same directory as the file. This will start the deployment process.
3. After deployment, Pulumi will output the MinIO endpoint URL.

Now you have a running MinIO instance on AWS EKS!

Please note that the access key and secret key included here are for demonstration purposes; you should generate your own secure keys. Additionally, you might want to customize other configurations like storage sizes and Helm chart version according to your needs.