Deploy the crossplane-exoscale-factory helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `crossplane-exoscale-factory` Helm chart on a Google Kubernetes Engine (GKE) cluster, you will need to perform the following tasks:

1. **Set up a GKE cluster**: This will be your Kubernetes environment where the Helm chart will be deployed.
2. **Install Crossplane**: Crossplane is an open-source multicloud control plane. It allows you to manage your services from different cloud providers using Kubernetes as a common layer. The `crossplane-exoscale-factory` Helm chart specifically seems to be designed to work with Crossplane to set up resources in Exoscale (a cloud service provider).
3. **Deploy the Helm chart**: After setting up Crossplane, you will deploy your `crossplane-exoscale-factory` chart onto your GKE cluster.

Below is a detailed TypeScript program using Pulumi to complete these tasks. The program will define the necessary resources for the GKE cluster and Crossplane installation.

### Prerequisites
- The Pulumi CLI installed and set up for GKE deployment.
- Access to a GCP account with permissions to create GKE clusters.
- `kubectl` installed to interact with the Kubernetes cluster.

### Detailed Program Explanation
First, let's start with the GKE cluster setup. Pulumi provides resources under the `@pulumi/gcp` package to create and manage GKE clusters. We will create a simple GKE cluster with default settings.

Next, we will ensure that `kubectl` is correctly configured to connect to your new GKE cluster using Pulumi's `KubernetesProvider` resource. This resource takes the kubeconfig from the GKE cluster output to manage Kubernetes resources.

After setting up the cluster, we'll install Crossplane using its Helm chart. For that, we need to create a `Chart` resource from the `@pulumi/kubernetes` package, specifying Crossplane's Helm repository and chart name.

Finally, we deploy the `crossplane-exoscale-factory` Helm chart. The chart's details will depend on the specifics of the chart and any values you need to override. Ensure you have the correct chart name and repository URL.

Here is the TypeScript program that performs the above tasks:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
});

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

// Export the Kubeconfig to access your cluster from kubectl
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
`;
    });

// Set up the Kubernetes provider using the generated kubeconfig
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Install Crossplane using Helm chart
const crossplane = new k8s.helm.v3.Chart("crossplane", {
    chart: "crossplane",
    version: "1.6.0", // specify the desired Crossplane chart version
    fetchOpts:{
        repo: "https://charts.crossplane.io/stable",
    },
}, { provider: k8sProvider });

// Now, install the crossplane-exoscale-factory Helm chart
const exoscaleFactory = new k8s.helm.v3.Chart("exoscale-factory", {
    chart: "crossplane-exoscale-factory",
    // Assuming that the chart is available in a repository, otherwise you might need to use a local path.
    fetchOpts: {
        repo: "https://example.com/helm", // Replace with the correct repository URL
    },
    // You may need to include additional configuration for the Helm chart here:
    values: {
        // ... specify any values required for the Helm chart
    },
}, { provider: k8sProvider });

// Export resources
export const crossplaneChart = crossplane;
export const exoscaleFactoryChart = exoscaleFactory;
```

### Usage Notes
- Replace `https://example.com/helm` with the actual repository URL where the `crossplane-exoscale-factory` Helm chart is hosted.
- This program assumes you're deploying charts with default configurations. Any specific configurations can be passed in the `values` field.
- Crossplane's Helm chart version is set to `1.6.0`, but you should use the latest version compatible with your deployment.
- The Pulumi program will automatically use your GCP credentials configured on your system.
- After deploying the program with `pulumi up`, you can use `kubectl` with the exported kubeconfig to interact with your GKE cluster.