Deploy the wordpress-helm-chart helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the `wordpress-helm-chart` on AWS EKS using Pulumi, you will follow these steps:

1. **Define the EKS Cluster**: You need to create an Amazon EKS cluster. EKS is a managed service that makes it easier for you to run Kubernetes on AWS without needing to install and operate your own Kubernetes clusters.

2. **Create an EKS Role**: Define an IAM role that EKS will assume to create AWS resources for Kubernetes.

3. **Deploy the Helm Chart**: Once the cluster is up and running, you can deploy applications to it using Helm charts. Helm is a package manager for Kubernetes that allows you to define, install, and upgrade complex Kubernetes applications.

Here’s a Pulumi program in TypeScript that accomplishes this. Remember to have `@pulumi/aws`, `@pulumi/awsx`, `@pulumi/eks`, `@pulumi/kubernetes`, and `typescript` installed in your Pulumi project.

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

// Create an EKS cluster with the default configuration.
const cluster = new eks.Cluster("wp-cluster", {
    // Request smaller instances for cost savings.
    instanceType: "t2.medium",
    desiredCapacity: 2, // Specify the desired number of cluster nodes.
    minSize: 1, // Specify the minimum number of nodes in the cluster.
    maxSize: 3, // Specify the maximum number of nodes the cluster can scale to.
});

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

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("wp-k8s", {
    kubeconfig: cluster.kubeconfig,
});

// Deploy the WordPress Helm chart using the Kubernetes provider we created.
const wordpress = new k8s.helm.v3.Chart("wp-helm", {
    namespace: "default",
    chart: "wordpress",
    version: "9.0.3", // Depending on the chart, you may want to lock the version you deploy.
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider: k8sProvider });

// Export the WordPress URL by querying the load balancer service that the WordPress Helm chart would have created.
export const wordpressUrl = wordpress
    .getResourceProperty("v1/Service", "wp-helm-wordpress", "status")
    .apply(status => `http://${status.loadBalancer.ingress[0].hostname}/`);

// Additional information:
// - EKS Cluster documentation: https://www.pulumi.com/docs/reference/pkg/aws/eks/cluster/
// - Helm Chart documentation: https://www.pulumi.com/docs/reference/pkg/kubernetes/helm/v3/chart/
```

Here's what each part does:

- **EKS Cluster**: We create an EKS cluster named `wp-cluster` using the `eks.Cluster` resource.

- **Kubernetes Provider**: This tells Pulumi how to communicate with the EKS cluster, using the `kubeconfig` output from the EKS Cluster resource.

- **Helm Chart**: We use the `k8s.helm.v3.Chart` resource to deploy the `wordpress` chart. We specify the namespace as `default`, but it can be any namespace you want to deploy into on the EKS cluster.

- **Load Balancer URL**: We export a URL that will be the entry point to the WordPress site. The Helm chart should create a Kubernetes service of type LoadBalancer for this purpose, and Pulumi allows you to capture and export the URL once it is live.

Please make sure the AWS credentials and region are properly configured for Pulumi CLI, and that you have Helm and the `wordpress` Helm chart available in your environment.