Deploy the harbor-operator helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the harbor-operator Helm chart on Google Kubernetes Engine (GKE), you first need to create a GKE cluster. Pulumi provides an easy way to create and manage a GKE cluster using the `google-native.container/v1beta1.Cluster` resource. After the cluster is set up, you can deploy a Helm chart using the `kubernetes.helm.v3.Chart` resource.

Here is a step-by-step explanation and a corresponding TypeScript program to accomplish this task:

1. **Create a GKE Cluster**: We'll use the `google-native.container/v1beta1.Cluster` resource to create a GKE cluster. You can customize the cluster configuration as needed, but for the sake of simplicity, I'll show you a basic setup.

2. **Provider Configuration**: For deploying Helm charts, we need to configure a Kubernetes provider that will communicate with the GKE cluster. Pulumi allows us to do this by passing the cluster's kubeconfig to the Kubernetes provider.

3. **Deploy Harbor Operator Helm Chart**: Once the GKE cluster is ready and the Kubernetes provider is configured, we'll use the `kubernetes.helm.v3.Chart` resource from the Pulumi Kubernetes provider to deploy the Harbor Operator Helm chart.

Below is the TypeScript program that performs these steps:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as gcpNative from "@pulumi/google-native";
import * as k8s from "@pulumi/kubernetes";

// Step 1: Creating a GKE cluster.
const cluster = new gcpNative.container.v1beta1.Cluster("harbor-cluster", {
    project: gcp.config.project,
    location: gcp.config.region,
    initialNodeCount: 1,
    nodeConfig: {
        machineType: "e2-medium", // You can choose the machine type based on your requirements
    },
});

// Export the Kubeconfig for the GKE cluster
export const kubeconfig = cluster.name.apply(name => {
    const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
    return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${cluster.masterAuth.apply(ma => ma.clusterCaCertificate)}
    server: https://${cluster.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}'
`;
});

// Step 2: Configure the Kubernetes provider to the GKE cluster
const k8sProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy the Harbor Operator Helm chart using the Kubernetes provider
const harborOperatorChart = new k8s.helm.v3.Chart("harbor-operator", {
    chart: "harbor-operator",
    version: "1.2.3", // Specify the version of harbor-operator you wish to deploy; check the chart repo for the latest version
    fetchOpts: {
        repo: "https://helm.goharbor.io", // Harbor Helm chart repository
    },
}, { provider: k8sProvider });

// Export the Harbor Operator Helm chart deployment status
export const harborOperatorStatus = harborOperatorChart.status;
```

Explanation:

- **Cluster Creation**: We define a basic GKE cluster with one node. `initialNodeCount` is set to 1 and the node machine type is `e2-medium`. You can adjust these values depending on your workload and requirements.
  
- **Export Kubeconfig**: The `kubeconfig` is calculated and exported so that the Kubernetes provider can use it to deploy resources to the cluster.
  
- **Kubernetes Provider Configuration**: We instantiate the Kubernetes provider using the exported `kubeconfig`. This provider is responsible for deploying and managing Kubernetes resources on the GKE cluster.
  
- **Harbor Operator Helm Chart Deployment**: We declare a Helm chart resource representing the Harbor Operator. The `repo` option specifies the location of the Harbor Helm chart repository.

This program will create a GKE cluster and deploy the specified version of the Harbor Operator Helm chart to it. The exported values can be used to interact with the cluster and the deployed application.