Deploy the kubevirt-manager helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the kubevirt-manager Helm chart on a Google Kubernetes Engine (GKE) cluster using Pulumi, you will need to follow these steps:

1. **Set up a new GKE cluster**: You'll create a new GKE cluster to host your Kubernetes workloads. 
2. **Install the Helm chart**: Once you have your Kubernetes cluster, you'll use Pulumi's Helm support to deploy the `kubevirt-manager` chart to your cluster.

Let's start by setting up the GKE cluster:

- We will use `gcp.container.Cluster` to create a new GKE cluster. You can customize the properties like `name`, `location`, and `nodeConfig` according to your requirements.

Once the cluster is created, you'll need to configure Pulumi to use the newly created kubeconfig so that Pulumi can connect to your GKE cluster. This typically involves fetching the kubeconfig data from the GKE API and setting it in our local Pulumi provider configuration.

- To deploy the Helm chart, you'll need to use `helm.v3.Chart`. This requires the name of the chart and optionally the version and any custom values you wish to provide.

Each of these steps will be represented by Pulumi code written in TypeScript below:

```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("kubevirt-cluster", {
    initialNodeCount: 1,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // or choose a different machine type as per your need
        oauthScopes: [
            "https://www.googleapis.com/auth/cloud-platform",
        ],
    },
});

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

// Obtain the kubeconfig from the GKE cluster
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 using the kubeconfig
const gkeK8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy kubevirt-manager helm chart using the Helm Chart resource
const kubevirtManagerChart = new k8s.helm.v3.Chart("kubevirt-manager", {
    chart: "kubevirt-manager",
    version: "0.1.0", // replace with desired chart version
    // Values from the helm documentation and customized for your environment
    values: {
        // Add any custom Chart values here
    },
}, { provider: gkeK8sProvider });

// Export the kubevirt-manager chart resources
export const kubevirtResources = kubevirtManagerChart.resources;
```

This program begins by importing the required Pulumi modules. We then create a GKE cluster with a specified node count and node configuration. You could change the machine type or any other property that suits your requirement.

Following the creation of the cluster, we construct a kubeconfig file. This step is crucial as it enables Pulumi to interact with our GKE cluster. We're using Pulumi's output combinators to build the kubeconfig string required to interact with the Kubernetes API.

We then instantiate a Kubernetes provider with this `kubeconfig`. This provider is what Pulumi uses to deploy Kubernetes resources to the specified cluster.

The last step deploys the kubevirt-manager Helm chart. We specify the chart name and version. You can also provide custom values to tailor the deployment to your needs.

Note that we're also exporting the names of the cluster and resources so that you can easily reference them later, such as when you need to retrieve their names or establish dependencies on them.

To run this program:

1. Save the above code to a file with a `.ts` extension, for example, `deployKubeVirtManager.ts`.
2. Ensure you have the Pulumi CLI installed and you are logged in.
3. Run `pulumi up` from the command line in the same directory as your `deployKubeVirtManager.ts` file.

If you encounter any errors, ensure that you have set up the GCP provider correctly and that you have the necessary permissions to create and manage GKE clusters and Helm deployments.

Remember to replace the placeholder text (like the Helm chart version `'0.1.0'`) with actual values that match your requirements.