Deploy the wordpress-nginx helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy the `wordpress-nginx` Helm chart on a Kubernetes cluster, you would typically use the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes provider. This resource lets you deploy Helm charts from any Helm chart repository. Helm is a package manager for Kubernetes, which allows you to define, install, and upgrade even the most complex Kubernetes applications.

In this example, you'll see how to deploy the `wordpress-nginx` Helm chart. We'll assume that you have a Kubernetes cluster already running and `kubectl` configured to communicate with your cluster. Pulumi interacts with your Kubernetes cluster configuration in the same way `kubectl` does, through a file named `kubeconfig`.

Here's how you can use Pulumi to deploy the `wordpress-nginx` Helm chart:

1. First, you would import the necessary Pulumi and Kubernetes libraries.

2. You would then create a new `kubernetes.helm.v3.Chart`, specifying the repository and chart name. You must provide a chart name, and optionally, you can include the repository URL if you're using a chart from a custom repository. For widely-known charts, you can generally just use the chart name; Pulumi knows how to fetch these from the default repositories.

3. Optionally, you can specify additional configuration values that you want to pass to the Helm chart, which allows you to customize your deployment. These values are passed in an object to the `values` field.

Now let's see what the code would look like:

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

// Create a Kubernetes Namespace
const ns = new kubernetes.core.v1.Namespace("wp-namespace", {
    metadata: {
        name: "wordpress",
    },
});

// Deploy the wordpress-nginx Helm chart into the namespace created above.
const wordpress = new kubernetes.helm.v3.Chart("wp-nginx", {
    namespace: ns.metadata.name,
    chart: "bitnami/wordpress",
    // You can specify the version of the chart here like this:
    // version: "9.0.3",
    // Values from the default chart's values.yml may be provided like this.
    values: {
        service: {
            type: "LoadBalancer",
        },
        mariadb: {
            enabled: true,
        },
    },
});

// Export the public LoadBalancer endpoint
export const frontendIp = wordpress.getResourceProperty("v1/Service", "wp-nginx-wordpress", "status").apply(s => s.loadBalancer.ingress[0].ip);

```

In the code above, we have:

1. Imported the `@pulumi/pulumi` and `@pulumi/kubernetes` modules which are the core Pulumi module and the Pulumi Kubernetes module respectively.

2. Created a `Namespace` where our application is going to be deployed. Namespaces are a way to divide cluster resources between multiple users.

3. Defined a Helm chart resource by creating an instance of `kubernetes.helm.v3.Chart`. The `wp-nginx` identifier is just a Pulumi name for the resource; it doesn't affect the chart deployment.

- Specified that we want to deploy the chart from the Bitnami repository by setting the `chart` field to `bitnami/wordpress`. Bitnami is a popular provider of packaged applications for Kubernetes.
   
   - Set the `values` field with the details specific to the chart. This can include things like service types or any customization specific to the WordPress Helm chart. You can find all customizable values by looking at the corresponding `values.yaml` file from the Helm chart's repository.

4. Exported the IP address of the LoadBalancer created by the `wordpress` chart. The `.apply()` method is used to retrieve the LoadBalancer IP once it's available. This IP can be used to access your WordPress instance running on Kubernetes.

You can run the above program with Pulumi CLI commands similar to the following steps:

1. `pulumi new kubernetes-typescript` - this creates a new Pulumi project using TypeScript.
2. Replace the code in the `index.ts` file with the TypeScript code provided above.
3. Run `pulumi up` to preview and deploy the changes. You'll see a detailed preview of all the resources Pulumi plans to create. Confirm the deployment to proceed.

Once the deployment is successful, you'll receive an output of the LoadBalancer IP address, which you can use to visit your new WordPress website.

Remember that Helm charts can have many configurable options, so you might need to customize values depending on your requirements and the specific configuration parameters available in the `wordpress-nginx` chart. You will need to refer to the chart's documentation for all configurable options.