Deploy the k8s-cron helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy a Kubernetes cron job using a Helm chart on AWS Elastic Kubernetes Service (EKS), we will perform several tasks:

1. Create an EKS cluster using the `eks.Cluster` resource.
2. Deploy the Helm chart for the cron job onto the EKS cluster using the `kubernetes.helm.sh/v3.Chart` resource.

First, we'll need an EKS cluster. We'll define the cluster with minimal configuration, and then we'll use Pulumi to deploy a Helm chart corresponding to the cron job we're interested in. Note that in a real-world scenario, you'd have a more complex Helm chart and perhaps additional EKS configurations, including IAM roles or VPC configurations.

For this to work, make sure you have the AWS CLI configured and Kubernetes CLI (kubectl) installed so that Pulumi can interact with your AWS account and the Kubernetes cluster.

Here is the TypeScript program that accomplishes these tasks:

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

const name = 'k8s-cron-example';

// Create an AWS EKS Kubernetes cluster.
const cluster = new eks.Cluster(name, {
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
    // This is the default version supported by EKS, 
    // you can choose the one that suits your needs.
    version: "1.21",
});

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

// Create a Kubernetes provider for the EKS cluster.
// This uses the kubeconfig from the cluster we just created.
const provider = new k8s.Provider(name, { kubeconfig: cluster.kubeconfig });

// Define the Helm chart, this example uses the stable/k8s-cron chart which might 
// not exist, you will usually specify your own chart or one from a Helm repository.
const cronHelmChart = new k8s.helm.v3.Chart("k8s-cron", {
    chart: "stable/k8s-cron", // Replace with your Helm chart's repository and name
    version: "1.0.0",         // Set the version of the chart to deploy
    namespace: "default",     // Define the namespace where the chart will be installed
    values: {                 // Provide configuration for the Helm chart
        // ... insert your configurations here
    },
}, { provider: provider });

// Export any needed resources.
// For instance, if your Helm chart creates a Kubernetes service of type LoadBalancer,
// you might want to export the resulting endpoint:
//
// export const cronServiceEndpoint = cronHelmChart.getResourceProperty(
//     "v1/Service", "k8s-cron", "status").apply(status => status.loadBalancer.ingress[0].hostname);

// Make sure to replace "k8s-cron" with the actual release name of your Helm deployment.
```

In the above code, we create an EKS cluster with a default node group that consists of EC2 instances of type 't2.medium'. Adjust the `instanceType`, `desiredCapacity`, `minSize`, `maxSize`, and `version` according to your requirements.

The `kubeconfig` is exported so that you can interact with your cluster using `kubectl` outside of Pulumi.

With the Kubernetes provider, we're pointing to the newly created cluster, so any subsequent resources managed by Pulumi will be deployed to this cluster.

The `k8s.helm.v3.Chart` resource represents a Helm chart, which is a collection of pre-configured Kubernetes resources. In this template, we specify the Helm chart name and version. You will need to replace `"stable/k8s-cron"` with the actual name and repository of the Helm chart you're planning to deploy. The `values` section of the chart should be replaced with configuration values specific to your chart.

Finally, we have a commented out export statement. Once you deploy the Helm chart, if it creates Kubernetes resources like Services or Deployments and you want to export some of these resource properties (like an external IP address or hostname), you can use `getResourceProperty`.

To deploy this Pulumi program:

1. Save the code in a file named `index.ts`.
2. Run `pulumi up` to preview and deploy the changes.

This program doesn't deploy a real `k8s-cron` Helm chart, since that doesn't exist to my knowledge. Instead, you'll need to use a real Helm chart and possibly its repository and version. If you have a Helm chart already, just replace the placeholder values with your actual chart information.

Remember to abide by best practices for managing sensitive information when dealing with credentials and access configurations.