Deploy the nfs-provisioner helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `nfs-provisioner` Helm chart on an AWS Elastic Kubernetes Service (EKS) cluster using Pulumi, we will perform the following tasks:

1. Set up an AWS EKS cluster.
2. Install the `nfs-provisioner` Helm chart on the cluster.

The `nfs-provisioner` Helm chart provides a means to create an NFS server in your EKS cluster which can dynamically provision persistent volume claims.

We will use the Pulumi EKS package (`eks`) to create the cluster and the Pulumi Kubernetes package (`kubernetes`) to install the Helm chart.

Firstly, we need to create an EKS cluster. The `eks.Cluster` resource will create all the necessary AWS resources, such as an EKS cluster, necessary Security Groups, IAM Roles, etc. We need to define the desired number of nodes, instance type, and Kubernetes version.

After creating an EKS cluster, we will use the `kubernetes.helm.v3.Chart` resource from the Kubernetes package to deploy `nfs-provisioner`. We need to set the chart name and, if necessary, configure specific values to pass to the Helm chart. For example, you might want to adjust storage size or access modes.

Below is a Pulumi TypeScript program that demonstrates these steps:

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

// Step 1: Create an EKS cluster.
const cluster = new eks.Cluster('my-cluster', {
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
    instanceType: 't2.medium',
    // Kubernetes version is optional; it will use the latest if not specified
    version: '1.21',
});

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

// Step 2: Install nfs-provisioner Helm chart on the EKS cluster.
const nfsProvisionerChart = new k8s.helm.v3.Chart('nfs-provisioner', {
    chart: 'nfs-server-provisioner',
    version: '1.0.0', // Specify the chart version you wish to deploy
    fetchOpts: {
        repo: 'https://kubernetes-sigs.github.io/nfs-ganesha-server-and-external-provisioner/',
    },
    // You can define additional configuration options here if needed.
}, { provider: cluster.provider });

// Outputs
export const clusterName = cluster.eksCluster.name;
export const nfsProvisionerChartName = nfsProvisionerChart.name;
```

Here's what this program does:
- It sets up an AWS EKS cluster named 'my-cluster' with a default node pool that has a minimum size of 1, a desired capacity of 2, and a maximum size of 3. Each node is a 't2.medium' EC2 instance.
- The Kubernetes version is specified to ensure compatibility with the Helm chart.
- Then it defines a Helm chart resource with Pulumi for the nfs-provisioner using its corresponding repository and chart name. It assumes that there's a version '1.0.0' available; this might need to be updated based on the chart you want to deploy.
- The `kubeconfig` output is the EKS cluster's configuration needed to interact with the cluster using `kubectl` or other Kubernetes tools.
- The `clusterName` and `nfsProvisionerChartName` outputs provide the names of the created resources.

To apply this Pulumi program:
- Save it in a file named `index.ts`.
- Install the required packages by running `npm install @pulumi/pulumi @pulumi/eks @pulumi/kubernetes`.
- Use Pulumi CLI commands to create a new stack with `pulumi stack init` (if you don't have one already).
- Run `pulumi up` to create the resources in your AWS account.
- After the deployment, you can use the outputted `kubeconfig` to manage your cluster with `kubectl`.

Please ensure you have AWS credentials configured on your system. The AWS provider will use your default credentials to create resources. You can set up AWS credentials using the AWS CLI or by setting environment variables.

Remember, costs will be incurred on AWS when you run this program since it provisions real cloud resources.