Deploy the Wordress helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

Deploying a WordPress Helm chart on DigitalOcean Kubernetes Service involves several steps. We will start by setting up a DigitalOcean Kubernetes (DOKS) cluster, and then we'll proceed to deploy WordPress onto this cluster using Pulumi's integration with Helm charts.

Here's a high-level overview of what we'll do:
1. **Create a DOKS cluster**: Provision a Kubernetes cluster on DigitalOcean.
2. **Deploy WordPress using Helm**: Install the WordPress Helm chart on the DOKS cluster.

### Step 1: Create a DigitalOcean Kubernetes Cluster
First, we need to create a DigitalOcean Kubernetes cluster. We will use the `digitalocean.KubernetesCluster` resource for this purpose. This resource allows us to define the configuration of the DOKS cluster, such as region, version, and node pool details.

### Step 2: Deploy WordPress using Helm
Once the cluster is ready, we'll deploy WordPress using the `kubernetes.helm.v3.Chart` resource. This resource represents a Helm chart, which is a pre-packaged set of Kubernetes resources. The WordPress chart includes all the necessary components for running WordPress, such as Deployments, Services, and Persistent Volume Claims.

Let's start writing the Pulumi TypeScript program that accomplishes these goals:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
import * as k8s from "@pulumi/kubernetes";

// Create a DigitalOcean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster("do-k8s-cluster", {
    // Specify the region for your cluster
    region: "nyc1",
    
    // Specify the Kubernetes version
    // Check DigitalOcean for the latest version: https://www.digitalocean.com/docs/kubernetes/
    version: "1.21.5-do.0",
    
    // Define the node pool for the cluster
    nodePool: {
        name: "default-pool",
        size: "s-2vcpu-2gb",
        nodeCount: 2, // You can adjust the count based on your needs
    },
});

// Once the cluster is created, we need to configure the Kubernetes provider to use the cluster credentials
const k8sProvider = new k8s.Provider("do-k8s-provider", {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

// Deploy WordPress using the Helm chart
const wordpressChart = new k8s.helm.v3.Chart("wordpress-helm-chart", {
    chart: "wordpress",
    version: "12.1.26", // Use the version that is compatible with your Kubernetes version
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider: k8sProvider });

// Export the cluster name and the WordPress service endpoint
export const clusterName = cluster.name;
export const wordpressEndpoint = wordpressChart.getResourceProperty(
    "v1/Service", "default", "wordpress-helm-chart-wordpress", "status"
).apply(status => status.loadBalancer.ingress[0].ip);
```

In order to run this program, please ensure you have the following prerequisites met:

1. Pulumi CLI installed.
2. DigitalOcean token configured with Pulumi using `pulumi config set digitalocean:token YOUR_TOKEN_HERE`.
3. An active DigitalOcean account.

### Explanation of the Program:
- We import the necessary Pulumi packages for DigitalOcean and Kubernetes.
- We declare a DigitalOcean Kubernetes cluster with a specific region, version, and a node pool that defines the size and number of nodes.
- Next, we create a Kubernetes provider configured with the kubeconfig from the created cluster so that Pulumi can interact with it.
- We then declare a Helm chart that represents our WordPress installation, specifying the name, version, and repository of the chart.
- Finally, we export the cluster name and the WordPress service endpoint so we can access them after deployment.

After deployment, you can access the WordPress application using the IP address from the `wordpressEndpoint` output.