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

Question

Pulumi · Accepted Answer

To deploy the `wordpress-nginx` helm chart on Google Kubernetes Engine (GKE), you will need to complete a few steps:

1. **Create a GKE Cluster**: This is the Kubernetes cluster where your workloads will reside.
2. **Configure Kubectl**: Setup `kubectl` to interact with your GKE cluster.
3. **Install and Configure Helm**: Helm is a package manager for Kubernetes that allows you to deploy applications from charts.
4. **Deploy the `wordpress-nginx` chart using Helm**: Once you have Helm set up, you can use it to deploy WordPress with Nginx.

Below is a TypeScript program using Pulumi to automate these steps.

### Pulumi Program

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

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster("wordpress-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Pick a machine type based on your needs
        oauthScopes: [
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring"
        ],
    },
});

// Step 2: Export the Cluster name and Kubeconfig
const clusterName = cluster.name;
const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${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
`;
    });

// Step 3: Create a Provider to use the exported kubeconfig
const provider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Step 4: Deploy wordpress-nginx Helm chart
const wordpressChart = new k8s.helm.v3.Chart("wordpress-nginx", {
    chart: "wordpress",
    version: "9.0.3", // Specify the version you wish to use
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    values: {
        service: {
            type: "LoadBalancer",
        },
        //Additional values can be defined here
    },
}, { provider: provider });

// Export the Kubeconfig and WordPress Service IP
export const kubeConfigOutput = kubeconfig;
export const wordpressServiceIP = wordpressChart.getResourceProperty("v1/Service", "wordpress-nginx-wordpress", "status").apply(s => s.loadBalancer.ingress[0].ip);
```

### Explanation

- **GKE Cluster Creation**: We create a GKE cluster with two nodes using `gcp.container.Cluster`. This step involves setting up the machines that will run our Kubernetes pods.

- **Kubeconfig Exporting**: Once the cluster is created, we generate a kubeconfig file. This file allows `kubectl` and other Kubernetes tooling to communicate with your cluster.

- **Kubernetes Provider Configuration**: With Pulumi's `k8s.Provider`, we use the generated kubeconfig to create a provider that lets us interact with the cluster.

- **Helm Chart Deployment**: We then create an instance of `k8s.helm.v3.Chart` to deploy the WordPress helm chart. Helm charts are a way to package Kubernetes applications, and in this case, we use the chart provided by Bitnami for WordPress with Nginx.

- **Access Information**: Finally, we export the kubeconfig and the IP address of the WordPress service.

Once you run this Pulumi program, it will automatically handle all these steps and output the kubeconfig and WordPress service IP which you can use to access your WordPress site. Remember that after you deploy with Pulumi, you'll see the outputs when you run `pulumi up`, which will show you the success of the deployment along with the exported values.