Deploy the Wordress helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the WordPress Helm chart on AWS EKS, we’ll go through the following steps:

1. Set up an AWS EKS cluster, which will host our Kubernetes workloads.
2. Once the cluster is ready, we will configure Pulumi to communicate with the cluster.
3. We will then deploy the WordPress Helm chart on the EKS cluster.

I'll guide you through the process, step by step, with a Pulumi program in TypeScript.

### Step 1: Setting Up an EKS Cluster
First, we need to create an EKS cluster using Pulumi's EKS package. We prefer using the `eks` package as it provides high-level abstractions that make it easier to manage an EKS cluster.

This is the outline of the resources we'll create in this step:
- **EKS Cluster**: The Kubernetes cluster managed by AWS EKS.
- **Node Group**: A group of EC2 instances registered as nodes in the EKS cluster.

For complete documentation on `eks.Cluster`, refer to: 
[EKS Cluster Documentation](https://www.pulumi.com/registry/packages/eks/api-docs/cluster/).

### Step 2: Deploying the WordPress Helm Chart
Once the EKS cluster is up and running, we can deploy Helm charts onto it. Pulumi provides an interface to Helm charts through the `kubernetes.helm.v3.Chart` resource. We will use this resource to deploy WordPress.

We'll specify the `chart` as `wordpress`, which is available in the public Helm chart repositories.

For more details on deploying a Helm chart using Pulumi, check out the:
[Helm Chart Documentation](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm.sh/v3/chart/).

Now, let's start writing our Pulumi program:

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

// Create an EKS cluster with the default configuration.
const cluster = new eks.Cluster('wp-cluster', {});

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

// Once the cluster is created, we can create a Kubernetes provider instance
// that uses the cluster's kubeconfig.
const provider = new kubernetes.Provider('k8s-provider', {
  kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Use the Helm chart `wordpress` from the repository `bitnami`.
const wordpress = new kubernetes.helm.v3.Chart('wp-wordpress', {
  chart: 'wordpress',
  version: '9.0.3', // You would pick a version of the WordPress chart that you want to deploy.
  fetchOpts: {
    repo: 'https://charts.bitnami.com/bitnami',
  },
}, { provider });

// Export the WordPress Service endpoint to access your site.
export const wordpressEndpoint = wordpress.getResourceProperty('v1/Service', 'wp-wordpress', 'status').apply(status => status.loadBalancer.ingress[0].hostname);

```

This program does the following:
- Imports necessary Pulumi libraries for AWS EKS, k8s, and AWSX networking.
- Creates a new EKS cluster named 'wp-cluster' with default configurations using the `eks` package. This includes creating an underlying VPC, subnets, and security groups.
- Exports the `kubeconfig` which will be used to interact with the cluster.
- Sets up a Kubernetes provider to use the kubeconfig from the EKS cluster we created.
- Deploys the WordPress Helm chart from the Bitnami repository onto the cluster using the Kubernetes provider.

It's important to note that the endpoint exposed by the WordPress service can be used to access your WordPress site. The endpoint URL is exported at the end of the script, so you'll know where to navigate to in your web browser once deployment is complete.

Once this program is run using the Pulumi CLI, it will automatically provision the resources as specified, and you'll be able to access your new WordPress instance. You can run this Pulumi program by using the command `pulumi up`.