Deploy the xwiki helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying the XWiki Helm chart on Google Kubernetes Engine (GKE) involves setting up a Kubernetes cluster on GKE and using Helm to deploy XWiki onto this cluster. First, you'll need to create a GKE cluster. Once you have a cluster running, you can use the `kubernetes.helm.v3.Chart` resource from the Pulumi Kubernetes provider to deploy XWiki using the Official XWiki Helm chart.

Here's a step-by-step breakdown of what we are going to do:

1. Set up a new GKE cluster using `google-native.container.v1beta1.Cluster`.
2. Create a Kubernetes provider using the GKE cluster credentials.
3. Deploy the XWiki Helm chart to the cluster using the `kubernetes.helm.v3.Chart` resource.

Below you'll find the program written in TypeScript. Make sure you have Pulumi installed and configured to use your GCP credentials, as well as `kubectl`, `gcloud`, and Helm command line tools.

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

const projectName = pulumi.getProject();
const stackName = pulumi.getStack();

// Create a GKE cluster
const cluster = new gcp.container.Cluster("xwiki-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
        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"
        ],
    },
});

// Export the Cluster name
export const clusterName = cluster.name;

// Export the Kubeconfig
export 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
`;
    });

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy XWiki using the official Helm chart.
const xwikiRelease = new k8s.helm.v3.Chart("xwiki", {
    chart: "xwiki",
    version: "x.y.z", // specify the version of the XWiki Helm chart to use
    fetchOpts:{repo: "https://maven.xwiki.org/releases"},
    values: {
        // Specify custom values for the chart
        // For instance, to use a persistent volume claim for storage:
        persistence: {
            storageClass: "standard",
            size: "8Gi"
        },
        service: {
            type: "LoadBalancer"
        }
    },
}, { provider: k8sProvider });

// Export the endpoint to access your XWiki instance
export const xwikiEndpoint = xwikiRelease.getResourceProperty("v1/Service", "xwiki-xwiki", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In this program, we create a new GKE cluster with a default node pool consisting of two `n1-standard-1` machines. We then export the `kubeconfig`, which is used to communicate with the cluster using `kubectl`.

We define a Pulumi Kubernetes provider that knows how to communicate with our GKE cluster using the exported `kubeconfig`.

Next, we deploy the XWiki Helm chart using the `k8s.helm.v3.Chart` resource. We specify the version of the chart we want to deploy and provide custom values according to our needs. Here, we're indicating that we want to create a persistent volume claim with 8Gi of storage and expose the XWiki service via a Load Balancer.

Finally, we export the IP address that will be assigned to the XWiki Service LoadBalancer. You can use this IP to browse to your XWiki instance once it's deployed.

To use this code:

1. Save it to a file named `index.ts`.
2. Run `pulumi stack init` followed by `pulumi up`.
3. Confirm the preview looks correct and select `yes` to deploy the resources.

When the deployment is successful, you'll see output variables displaying your cluster name and XWiki service endpoint. It might take a couple of minutes for the LoadBalancer to be provisioned and for XWiki to become available.

Remember to replace `"x.y.z"` with the actual version of the Helm chart you want to deploy. Also, you might need to adjust the volume size and other configuration options to match your desired setup.