Deploy the tensorflow helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the TensorFlow Helm chart on AWS EKS using Pulumi, we'll perform the following steps:

1. Set up an EKS cluster using the `eks.Cluster` resource.
2. Deploy the TensorFlow Helm chart onto the EKS cluster using the `kubernetes.helm.sh/v3.Chart` resource.

Here's an overview of what each step accomplishes:

- **EKS Cluster**: This resource will create a managed Kubernetes cluster in AWS EKS. We'll configure this with some basics such as name and desired capabilities.
- **TensorFlow Helm Chart**: After setting up the Kubernetes cluster, we'll use a Helm chart to deploy TensorFlow. Helm charts are pre-packaged applications for Kubernetes, which include all necessary definitions for deployment.

Below is the TypeScript program that performs these actions:

```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', {
  desiredCapacity: 2,
  minSize: 1,
  maxSize: 2,
  storageClasses: 'gp2',
  deployDashboard: false,
});

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

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

// Deploy the TensorFlow Helm chart using the Kubernetes provider.
const tensorflowChart = new k8s.helm.v3.Chart('tensorflow', {
  chart: 'tensorflow',
  version: '2.1.0', // specify the version you desire here
  fetchOpts:{
    repo: 'https://hub.helm.sh/charts/your_repo', // replace with the correct Helm chart repository
  },
}, { provider: provider });

// Export the Kubernetes ingress endpoint to access the TensorFlow service
export const tensorflowIngress = tensorflowChart.getResource('v1/Service', 'tensorflow(tensorflow-chart)');
```

### Explanation of the Pulumi TypeScript Program:

The above program defines two major resources:

- `eks.Cluster`: Sets up a new AWS EKS cluster. The `desiredCapacity`, `minSize`, and `maxSize` parameters are set to configure the scaling of the cluster. `deployDashboard: false` is specified because the Kubernetes dashboard is often not recommended due to security considerations. The cluster's `kubeconfig` is exported to be used by kubectl and other Kubernetes tools.

- `k8s.helm.v3.Chart`: This resource represents the TensorFlow Helm chart. We specify the name of the chart and an optional version. Also, we provide `fetchOpts` with a repository URL. This URL should be replaced with the actual Helm repository that hosts the TensorFlow chart you want to use.

Additionally, we use `k8s.Provider` which specifically uses the `kubeconfig` of our newly created EKS cluster to ensure operations are targeted to this cluster.

Please note that you need to replace `https://hub.helm.sh/charts/your_repo` with the actual Helm repository that holds the TensorFlow chart. Furthermore, you should replace `2.1.0` with the desired version of TensorFlow Helm chart you want to deploy.

Finally, we export `tensorflowIngress`, which assumes that the TensorFlow Helm chart creates a Kubernetes `Service` that can be accessed via an Ingress. This would need to be adjusted based on the actual content of the Helm chart you use.

Remember to install the necessary Pulumi plugins for AWS, EKS, and Kubernetes if you haven't, and configure your AWS credentials for Pulumi to use. After the code is set up, you can deploy it using the `pulumi up` command in your terminal. This will provision the resources in AWS as defined in the code.

Keep in mind that this code is for illustrative purposes and may require adjustments depending on the specific version of the TensorFlow Helm chart and any custom requirements you have for your EKS cluster configuration.