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

Question

Pulumi · Accepted Answer

Sure! I'll walk you through deploying the OneDev Helm chart on a Google Kubernetes Engine (GKE) cluster using Pulumi and TypeScript. First, we'll set up the GKE cluster, then we'll deploy OneDev using the Helm chart.

### Step 1: Set Up a GKE Cluster

Before we can deploy any applications, we need a Kubernetes cluster to run them. We'll use Pulumi to create a GKE cluster. Here's how:

1. We'll start by importing the required Pulumi packages for GCP and the Helm chart.
2. We'll then create a new GKE cluster by defining a `Cluster` resource.
3. For simplicity, we'll use the default node pool configurations, but you can customize these as necessary for production use.

### Step 2: Deploy the OneDev Helm Chart

Once our GKE cluster is ready, we can deploy OneDev using its Helm chart.

1. We will add the Helm chart using the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes library.
2. We need to set the chart name to `onedev`, and usually, Helm charts will be sourced from a Helm repository, but for this demo, we will assume the chart is available in the default Helm repositories.
3. We pass the Kubernetes provider to the Helm chart to let it know which cluster to deploy to.

Below you'll find the program that performs these steps. It's written in TypeScript, a language Pulumi supports for infrastructure as code:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    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 Cluster 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("my-k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the OneDev Helm chart
const onedevChart = new k8s.helm.v3.Chart("onedev", {
    chart: "onedev",
    // Version can be specified if required. For latest version, it is commented.
    // version: "specific-chart-version",
}, { provider: k8sProvider });

// Export the OneDev service endpoint
export const onedevService = onedevChart.getResourceProperty("v1/Service", "onedev", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In the above program:

- `gcp.container.Cluster` initializes a new GKE cluster. We provide a couple of basic configurations like `initialNodeCount` and `nodeConfig`.
- We create a `kubeconfig` which is used to interact with the cluster using tools like `kubectl`.
- `k8s.Provider` tells Pulumi which Kubernetes cluster we want to deploy resources to, using the generated `kubeconfig`.
- Finally, `k8s.helm.v3.Chart` deploys OneDev. It specifically points to the Helm chart called `onedev`. The chart is assumed to be in the default Helm chart repositories.
- We export important details, such as the cluster name and OneDev service's IP address, which can be used to access your OneDev instance.

To run this Pulumi program:
- Ensure you have Pulumi CLI installed and the GCP SDK configured with your credentials.
- Place this code in a file named `index.ts` within a Pulumi project.
- Run `pulumi up` to create the resources. Follow the CLI prompts to execute the deployment.

After the deployment is complete, Pulumi will output the IP address where you can access OneDev. Now you have a fully operational instance of OneDev running in GKE!