Deploy the cronjob-backup-jenkins helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `cronjob-backup-jenkins` Helm chart on an AWS EKS (Elastic Kubernetes Service) cluster, you would follow the steps below. This process involves setting up an EKS cluster, configuring the Helm Chart, and deploying it to the cluster.

### 1. **Set Up The EKS Cluster**: 
First, you need an EKS cluster where your Helm chart will be deployed. You'll use the `eks.Cluster` resource from the `eks` package which is a high-level component anticipating common requirements.

### 2. **Define The ECR Repository**:
Although not directly required for deploying a Helm chart, you may want an Elastic Container Registry (ECR) repository ready if your chart includes images that need to be stored. Use `aws.ecr.Repository` from the `aws` provider.

### 3. **Deploy The Helm Chart**: 
After the EKS cluster is ready, you can deploy your Helm chart using the `Chart` resource from the `kubernetes` provider.

Here is the Pulumi program written in TypeScript that accomplishes this:

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

// Define the required EKS cluster role
const role = new aws.iam.Role("eksRole", {
    assumeRolePolicy: aws.iam.assumeRolePolicyForPrincipal({
        Service: "eks.amazonaws.com",
    }),
});

// Attach the AmazonEKSWorkerNodePolicy to the role
const rolePolicyAttachment = new aws.iam.RolePolicyAttachment("eksRolePolicyAttachment", {
    role: role.name,
    policyArn: "arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy",
});

// Create an EKS cluster
const cluster = new eks.Cluster("eksCluster", {
    roleArn: role.arn,
    vpcId: /* VPC ID where you want your cluster */, // Specify your VPC ID
    subnetIds: /* Subnet IDs where you want your cluster */, // Specify your subnet IDs
    // Defaults are applied; you can specify additional parameters if required.
});

// Define an ECR repository (Optional –– useful if you have custom images for your Helm chart)
const repo = new aws.ecr.Repository("appRepo", {
    imageScanningConfiguration: {
        scanOnPush: true,
    },
    tags: {
        Name: "appRepo",
    },
});

// Instantiate the Kubernetes provider using the EKS cluster credentials
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy cronjob-backup-jenkins Helm chart
const jenkinsBackup = new k8s.helm.v3.Chart("jenkinsBackupChart", {
    chart: "cronjob-backup-jenkins",
    version: "1.0.0",  // Use the correct version of the chart
    namespace: "default",  // Replace with the namespace where you want to deploy the chart
    // Define any custom values for your helm chart
    values: {
        persistence: {
            size: "10Gi",
        },
        // Add additional configuration per the chart's requirements
    },
}, { provider: k8sProvider });

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

// Export the ECR repository URL
export const repositoryUrl = repo.repositoryUrl;
```

In the code above, you've defined an EKS cluster with the necessary IAM role and attached the `AmazonEKSWorkerNodePolicy` to the role so that the worker nodes have the permissions they need. The Helm chart for 'cronjob-backup-jenkins' is then deployed through the Kubernetes provider which references the created EKS cluster's kubeconfig. The ECR repository has also been set up to store container images and is set to scan on push for vulnerabilities.

Please make sure you specify the VPC ID and subnet IDs where you want the cluster to be created, and replace `'1.0.0'` placeholder for the chart version with the actual version you're intending to deploy.

You can run this Pulumi program by saving it to a file (e.g., `index.ts`) and then using Pulumi CLI commands in your terminal (`pulumi up` to deploy, `pulumi destroy` to cleanup).

*Note*: Ensure the Helm chart version and values suit your needs and that you've set up AWS credentials on your machine or CI/CD environment where you'll run Pulumi.

The `kubeconfig` and `repositoryUrl` are exported, so after deploying the Pulumi stack, you'll receive outputs that you can use to interact with your EKS cluster and ECR repository, such as `kubectl` commands with kubeconfig and pushing images to the ECR repository URL.

Deploy the cronjob-backup-jenkins helm chart on AWS EKS

1. Set Up The EKS Cluster:

2. Define The ECR Repository:

3. Deploy The Helm Chart: