Deploy the ibm-websphere-liberty helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying an IBM WebSphere Liberty Helm chart on Google Kubernetes Engine (GKE) involves several steps. First, you'll create a GKE cluster, configure `kubectl` to connect to the cluster, and finally use Helm to deploy the chart. Below is a detailed walkthrough and a Pulumi program in TypeScript that accomplishes this.

### Creating a GKE Cluster

To get started, we need to create a GKE cluster where our Helm chart will be deployed. Using Pulumi's GCP provider, we can define a cluster with the necessary specifications. Once the cluster is provisioned, we will obtain its kubeconfig to interact with it using `kubectl`.

### Installing Helm and Deploying the Chart

With the cluster in place, we'll then install Helm. Helm is a package manager for Kubernetes that allows you to manage Kubernetes applications. Helm charts help you define, install, and upgrade even the most complex Kubernetes applications.

To deploy the IBM WebSphere Liberty Helm chart, we need to add the repository where the chart is located, update our Helm repository, and then install the chart into our GKE cluster.

### Pulumi Program for Deployment

Here's the complete Pulumi program that creates a GKE cluster and deploys the IBM WebSphere Liberty Helm chart:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("websphere-liberty-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest", // ensure that we are using the latest version
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // defines the machine type for the nodes
        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;

// Obtain the kubeconfig from the GKE cluster
const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint]).
    apply(([name, endpoint]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${cluster.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:
      name: gcp
`;
    });

// Export the kubeconfig
export const exportsKubeconfig = kubeconfig;

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

// Deploy IBM WebSphere Liberty Helm chart
const websphereLibertyChart = new k8s.helm.v3.Chart("websphere-liberty-chart", {
    chart: "ibm-websphere-liberty",
    fetchOpts:{
        repo: "https://repo-url-for-websphere-liberty", // replace with the actual Helm chart repo URL
    },
    version: "chart-version", // specify the version of the chart to deploy
    values: {
        // specify any custom values needed for the IBM WebSphere Liberty chart
    },
}, { provider: k8sProvider });

// Export the Helm chart deployment status
export const chartStatus = websphereLibertyChart.status;
```

### Explanation

1. We first import the required GCP, Kubernetes, and Pulumi packages.
2. We define a GKE cluster resource (`gcp.container.Cluster`) with an initial node count and specific configurations like the machine type and OAuth scopes.
3. We export the name of the cluster.
4. We generate a kubeconfig which will allow us to interact with the GKE cluster using `kubectl`.
5. We export the generated kubeconfig.
6. We create a Pulumi Kubernetes provider that uses the kubeconfig to interact with our GKE cluster.
7. We declare a Helm chart resource (`k8s.helm.v3.Chart`) that connects to the specified Helm chart repository and installs the desired version of the IBM WebSphere Liberty Helm chart.
8. We export the status of the Helm deployment.

To run this program:

1. Ensure you have Pulumi installed and set up with the correct GCP credentials.
2. Save this code to a file named `index.ts`.
3. Run `pulumi up` to preview and create the resources.

Please replace `"https://repo-url-for-websphere-liberty"` with the actual repository URL where the IBM WebSphere Liberty Helm chart is located and `"chart-version"` with the specific version of the chart you want to deploy. Additionally, in the `values` property of the Helm chart, you can customize the deployment by setting the necessary values that align with the chart's requirements.