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

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE), you'll need to set up a few things:

1. **Provision a GKE cluster**: We'll use the `google-native.container/v1beta1.Cluster` resource to create a new GKE cluster.

2. **Install Helm on the cluster**: We'll use the `kubernetes.helm.sh/v3.Release` resource from Pulumi's Kubernetes provider, which represents a Helm chart release.

Here's a step-by-step guide, followed by the TypeScript code that accomplishes these tasks:

### Step 1: Creating the GKE Cluster

We'll start by defining a GKE cluster using the `Cluster` resource. You need to specify details like the name, the location, and node configurations depending on your requirements.

### Step 2: Installing the Helm Chart

After the cluster is up and running, we can deploy the Helm chart onto it. For that, we need to create an instance of `Release` that points to the Maven Repository Helm chart.

In the Helm release, you'll need to:

- Specify the chart name—presumably `mavenrepo` if that's the name in the Helm repository.
- Provide the repository URL where the chart can be found if it's not in the default Helm chart repository.
- Set the namespace for the Helm release.
- Configure values for the chart using the `values` parameter if necessary.

Below is a comprehensive TypeScript program that you can use to deploy a Maven Repository Helm chart on GKE with Pulumi:

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

// Step 1. Provision a GKE cluster
const cluster = new gcp.container.Cluster("mavenrepo-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "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 to access the Cluster
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
`;
    });

// Step 2. Install the Maven Repository Helm chart
const mavenrepoChart = new k8s.helm.v3.Release("mavenrepo", {
    chart: "mavenrepo",
    version: "1.0.0", // replace with the chart version you need
    repositoryOpts: {
        repo: "https://charts.example.com/", // replace with the Helm repository URL if needed
    },
    values: {
        // specify your chart values here
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: kubeconfig }) });

// Export the Helm release name
export const mavenrepoReleaseName = mavenrepoChart.name;
```

This program accomplishes the following:

- Defines a GKE cluster named `mavenrepo-cluster` with two nodes and uses the latest available version for both the master and nodes.
- Exports the cluster's name and a kubeconfig file which allows you to interact with the cluster using `kubectl` or any Kubernetes client.
- Creates a Helm release from the `mavenrepo` chart. It assumes that the chart is hosted at `https://charts.example.com/` which you should replace with the actual URL of your chart repository.
- The `values` object within the Helm release should be configured according to the specific needs of the Maven Repository chart you are using. This may include things such as persistence configuration, resource requests, and limits or any other configurable parameters of the Helm chart.

Make sure to replace placeholders like the chart version, repository URL, and values with actual information corresponding to the Maven Repository Helm chart you want to deploy.

To run the program:

1. Ensure you have the Pulumi CLI installed and configured with the correct access to your GCP account.
2. Save the code to a file with a `.ts` extension (e.g., `deployMavenRepo.ts`).
3. Run `pulumi up` within the directory containing your `.ts` file to create the resources.

### Important Notes:

- The Helm chart version (`1.0.0` in the code) and repository URL (`https://charts.example.com/` in the code) are placeholders and should be replaced with the actual values corresponding to the Maven Repository Helm chart you intend to deploy.
- The `kubeconfig` is generated using Pulumi's built-in `all` and `apply` functions, which allow generating dynamic data after other resources have been created. This configuration enables you to use `kubectl` against the provisioned GKE cluster.

Please replace the chart-related values with the actual Maven Repository chart details you wish to deploy.