Deploy the Wordpress helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy a WordPress Helm chart on the DigitalOcean Kubernetes Service using Pulumi, we would take the following steps:

1. Create a Kubernetes cluster on DigitalOcean.
2. Install the Helm chart for WordPress within that Kubernetes cluster.

### Pulumi Program Explanation

First, we need to create a new Kubernetes cluster in DigitalOcean. We will use the `digitalocean.KubernetesCluster` resource from the DigitalOcean Pulumi provider to create the cluster. Properties like `region`, `version`, and `nodePool` are specified to determine the location, Kubernetes version, and size/type of the worker nodes. You'll need to replace values like `your-cluster-name` and `your-node-pool-name` with appropriate values for your environment.

After the cluster has been created, we need to ensure that we can manage resources in the cluster. To do this, we set up a provider instance with the kubeconfig that was outputted by the `KubernetesCluster` resource.

Next, we'll deploy WordPress using the Helm chart. For that, we'll use the `kubernetes.helm.sh/v3.Chart` resource from the Kubernetes provider, which allows us to deploy a Helm chart into a Kubernetes cluster. We need to specify the `chart` name, which in this case is `wordpress`. Optionally, we might want to provide specific `values` to customize our WordPress installation.

Now let's look at how we can express this with Pulumi and TypeScript:

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

// Step 1: Create a new DigitalOcean Kubernetes Service (DOKS) cluster
const cluster = new digitalocean.KubernetesCluster("do-k8s-cluster", {
    region: "nyc3", // Replace with your desired region
    version: "1.21.5-do.0", // Replace with your desired Kubernetes version
    nodePool: {
        name: "default", // Replace with your desired node pool name
        size: "s-2vcpu-2gb", // Replace with your desired node size
        nodeCount: 2, // Number of nodes in the node pool
    },
});

// Step 2: Set up a Kubernetes provider instance using the kubeconfig from the newly created DOKS cluster
const k8sProvider = new kubernetes.Provider("do-k8s-provider", {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

// Step 3: Deploy WordPress using Helm Chart into the DOKS cluster
const wordpressChart = new kubernetes.helm.v3.Chart("wordpress-chart", {
    chart: "wordpress", // Helm chart name
    version: "9.0.3", // Specify the version of the Chart, if required
    // If you need to customize WordPress deployment, specify your custom values here
    values: {
        // For example, you can specify resources for the WordPress pod
        wordpress: {
            resources: {
                requests: {
                    memory: "512Mi",
                    cpu: "300m",
                },
            },
        },
    },
}, { provider: k8sProvider }); // Associate with our k8s provider to deploy into our DOKS cluster

// Export the cluster kubeconfig and WordPress service endpoint
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;
export const wordpressEndpoint = wordpressChart.getResourceProperty("v1/Service", "wordpress", "status").apply(status => status.loadBalancer.ingress[0].ip);

```
In the above program:

- We define a DigitalOcean Kubernetes cluster (`digitalocean.KubernetesCluster`) with the desired settings. After creation, the cluster will output a kubeconfig file, which can be used to interact with the cluster via the Kubernetes API.
- We then create a Kubernetes provider instance (`kubernetes.Provider`) using the kubeconfig from the DigitalOcean Kubernetes cluster. This provider is used to manage Kubernetes resources in the cluster.
- Finally, we deploy WordPress using a Helm Chart (`kubernetes.helm.v3.Chart`) with the help of the Kubernetes provider instance we just defined. The properties section under the `wordpressChart` declaration can be modified to provide custom configurations for the WordPress installation.
- The `kubeconfig` of the cluster and the external IP address of the WordPress service are exported. The `kubeconfig` allows you to interact with your Kubernetes cluster using tools like `kubectl`, and the WordPress endpoint is the external URL through which you can access your WordPress site.

Remember to replace placeholder values like `your-cluster-name` and `your-node-pool-name` with appropriate values for your setup. The version of the WordPress chart is specified, but you can leave that out to get the latest version, or replace it with any version you require.