Deploy the wordpress-helm-chart helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `wordpress-helm-chart` on Google Kubernetes Engine (GKE) using Pulumi, we will follow these steps:

1. Create a new GKE cluster.
2. Install and configure the Helm chart for WordPress on the newly created GKE cluster.

For step one, we will use the `google-native.container.v1beta1.Cluster` resource to create the GKE cluster. The `google-native` provider uses the Google Cloud API directly, allowing us to define a GKE cluster's detailed configuration.

For step two, we will use the `kubernetes.helm.sh/v3.Release` resource from the Kubernetes provider, which allows us to manage Helm chart releases. Helm is a package manager for Kubernetes, and we can use it to install and manage the WordPress Helm chart.

Here is a detailed Pulumi program written in TypeScript that demonstrates the required steps:

```typescript
import * as gcp from "@pulumi/gcp";
import * as k8s from "@pulumi/kubernetes";
import * as gcpNative from "@pulumi/google-native";

// Create a GKE cluster.
const cluster = new gcpNative.container.v1beta1.Cluster("gke-cluster", {
    project: gcp.config.project, // Uses the project from the GCP configuration.
    location: "us-central1", // Specify the region where GKE cluster will be created.
    // Define various properties of the cluster.
    initialClusterVersion: "latest", // Use the latest available GKE version.
    nodePools: [{
        name: "default-pool",
        initialNodeCount: 1, // Set the initial number of nodes.
        autoscaling: {
            enabled: true, // Enable autoscaling for the nodes.
            maxNodeCount: 3, // Set the maximum number of nodes for autoscaling.
            minNodeCount: 1, // Set the minimum number of nodes for autoscaling.
        },
        config: {
            machineType: "e2-medium", // Set the machine type used for the nodes.
        },
    }],
});

// Export the Kubeconfig to access the GKE cluster.
export const kubeconfig = cluster.name.apply(clusterName => {
    return gcp.container.getCluster({
        name: clusterName,
        location: "us-central1",
    }, { async: true }).then(gkeCluster => {
        const context = `${gcp.config.project}_${gkeCluster.location}_${gkeCluster.name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${gkeCluster.masterAuth.clusterCaCertificate}
    server: https://${gkeCluster.endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      config:
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
    });
});

// Instantiate a new Kubernetes provider. This will be used to install Helm charts into the GKE cluster.
const k8sProvider = new k8s.Provider("k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the WordPress Helm chart on the GKE cluster using the k8s.Provider.
const wordpressChart = new k8s.helm.v3.Chart("wp-chart", {
    chart: "wordpress", // The name of the chart in the repository.
    version: "9.0.3", // Specify the version of the chart you want to deploy.
    namespace: "default", // Specify the namespace where the chart will be installed.
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami", // The repository where the WordPress chart can be found.
    },
}, { provider: k8sProvider }); // Pass the k8sProvider to manage the resources on the GKE cluster.

// Export the public IP of the WordPress service. This assumes that WordPress has been set up with a LoadBalancer.
export const wordpressEndpoint = wordpressChart.getResourceProperty("v1/Service", "wp-chart-wordpress", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

- We create a cluster using the `google-native.container.v1beta1.Cluster` resource. We specify the location and initial setup details, like the version, number of nodes, and machine type.
- We then export the Kubeconfig from the cluster so that the Kubernetes provider can use it to interact with the cluster.
- We instantiate a Kubernetes provider, passing the Kubeconfig, which allows us to deploy resources onto the GKE cluster.
- We use this provider when setting up the WordPress Helm chart with `k8s.helm.v3.Chart`. This deploys WordPress to our GKE cluster.
- Lastly, we export the public IP of the WordPress service, which allows users to access the WordPress site once it's ready.

This program assumes you have already configured the Pulumi CLI with the appropriate access to your Google Cloud Platform account. Make sure that you have configured your Pulumi credentials for GCP access by running `pulumi config set gcp:project [PROJECT_NAME]`.

Note that depending on the LoadBalancer setup in the WordPress Helm chart, it might take a few minutes for the external IP to be provisioned and accessible. Once the deployment is complete, and the IP is available, you can use the exported `wordpressEndpoint` to visit your WordPress site.

Remember that you should review the settings such as region, machine types, and numbers of nodes to ensure they match your requirements and budget. The values specified above are for demonstration purposes and may not reflect the best options for a production environment.