Deploy the old-joomla helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the `old-joomla` Helm chart on the DigitalOcean Kubernetes Service, you'll first need to provision a DigitalOcean Kubernetes (DOKS) cluster and then use the Helm chart to deploy Joomla onto it. This can be done using Pulumi's `@pulumi/digitalocean` and `@pulumi/kubernetes` packages.

In this Pulumi TypeScript program, I will guide you through the steps necessary to accomplish the following:

1. Provision a new DOKS cluster using the `digitalocean.KubernetesCluster` class.
2. Deploy the `old-joomla` Helm chart to your DOKS cluster using the `kubernetes.helm.v3.Chart` class.

Before running the provided Pulumi code, make sure you have installed Pulumi CLI and configured it to use your DigitalOcean account. You should have Pulumi's TypeScript SDK installed in your project, and you've installed the required Pulumi packages and their dependencies.

Here is the complete TypeScript program that does the above:

```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("my-doks", {
    region: "nyc1",
    version: "latest",
    nodePool: {
        size: "s-1vcpu-2gb",
        name: "worker-pool",
        nodeCount: 2,
    },
});

// The kubeconfig generated is used to interact with the cluster
const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// A Kubernetes provider is created using the DOKS kubeconfig
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy `old-joomla` using the Helm chart
const joomlaChart = new k8s.helm.v3.Chart("old-joomla", {
    // Assuming old-joomla is in a repository accessible by the deployment environment,
    // you may need to specify `repo` if it's in a custom Helm repo.
    chart: "old-joomla",
    // Using the cluster's namespace and kubeconfig details.
    namespace: "default",
    values: {
        // Chart values go here
        // E.g., setting service type to LoadBalancer for external access (if supported by values)
        // service: {
        //     type: "LoadBalancer",
        // },
    },
}, { provider: k8sProvider });

// Export the DOKS cluster name and cluster endpoint URL
export const clusterName = cluster.name;
export const clusterEndpoint = cluster.endpoint;

// You can also export the service's LoadBalancer IP if you want to access Joomla
// Wait for the loadBalancer to be assigned and export the IP (This part may be optional depending on your use case and the chart configuration).
// joomlaChart.getResourceProperty("v1/Service", "old-joomla", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

This Pulumi program creates a DOKS cluster with one node pool consisting of two nodes with `s-1vcpu-2gb` size. It sets the region to `nyc1`, but you can adjust this to your preferred region that supports DOKS.

Once the cluster is up and running, we use Pulumi to deploy the Helm chart for `old-joomla`. In this step, make sure to specify any values you need for customizing the Joomla installation to fit your needs, such as persistent volume configuration, administrator credentials, and more. This is done in the `values` field which currently has a placeholder for demonstration purposes.

After the deployment, the program sets up a `k8s.Provider` with the kubeconfig of the newly created cluster. This is necessary because Pulumi needs to know how to communicate with your Kubernetes cluster.

Finally, the program exports the cluster name `clusterName` and the cluster endpoint `clusterEndpoint`, which are useful details to connect to your cluster later on. Optionally, if your service is exposed via a LoadBalancer, Pulumi can also be used to export the public IP address of Joomla once it's available. However, note that due to the asynchronous nature of Kubernetes, this IP might not be available immediately and may require polling the Kubernetes API to retrieve.

Remember to replace `old-joomla` with the accurate chart name and provide the necessary Helm chart values as per the chart's requirements. If `old-joomla` is not available in the default Helm repositories, you'll need to specify the repository URL in the `repo` field within the `Chart` arguments.

Run this program using the Pulumi CLI tools where Pulumi will execute the code and create the resources in DigitalOcean as described. To view the Joomla site, go to the service's LoadBalancer IP after its deployment is complete, if that's how the service is configured to be accessed.