Deploy the multus-cni helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Google Kubernetes Engine (GKE) with Pulumi can be done in several steps. First, you need to create a GKE cluster, and then use the Helm package to deploy the Multus CNI (Container Network Interface) chart to your cluster. Pulumi's gcp.container.Cluster and harness.service.Helm resources will help achieve our goal.

Setting up Google Kubernetes Engine (GKE) Cluster

Before you can deploy the Multus CNI on GKE, you need a Kubernetes cluster running on GKE. Here's how you would set up the GKE cluster using Pulumi:

Create the GKE Cluster Resource: Use gcp.container.Cluster to create a new Kubernetes cluster.
Configure the Node Pool: You should specify the type and number of machines you want to have in your node pool. You can adjust the size, type, disk size, and other properties related to the machines.

Deploying the Multus CNI

Once you have a GKE cluster, you can install the Multus CNI using the Helm chart.

Set up Helm and the Kubernetes Provider: Use Pulumi's Helm and Kubernetes providers to deploy resources with Helm charts.
Deploying the Chart: Use the harness.service.Helm resource to deploy the Multus CNI Helm chart by specifying the chart name, version, and any values you want to customize.

Pulumi Program to Deploy Multus CNI on GKE

Here is a full TypeScript program for Pulumi that sets up a basic GKE cluster and deploys the Multus CNI Helm chart. Remember to replace placeholders like <your_project>, <your_zone>, and <chart_version> with your actual project ID, desired GCP zone, and the specific version of the Multus CNI Helm chart you wish to deploy.

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("multus-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    location: "<your_zone>",
    project: "<your_project>",
});

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

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

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeConfig,
});

// Deploy Multus CNI using Helm chart
const multusCni = new helm.v3.Chart("multus-cni", {
    chart: "multus",
    version: "<chart_version>",
    fetchOpts: {
        repo: "https://example.com/charts", // replace with the actual chart repo URL
    },
}, { provider: k8sProvider });

// Export the Helm chart name
export const chartName = multusCni.metadata.apply(metadata => metadata.name);

Explanation

The gcp.container.Cluster resource sets up a new GKE cluster. This includes configuration details such as the initial number of nodes, the Kubernetes version, and the geographical location of the cluster. The project parameter specifies the GCP project under which the cluster is deployed.
We're exporting the kubeConfig, which will be used to communicate with your Kubernetes cluster via kubectl.
The k8s.Provider is a Pulumi resource that understands how to interact with Kubernetes clusters using the kubeconfig.
The helm.v3.Chart resource is used to deploy the Multus CNI. Its parameters include the chart name and version, as well as the repository where the chart can be found. Ensure to provide the correct Helm repository that hosts the Multus CNI chart.
Finally, we export the name of the deployed Helm chart for easy reference.

After writing this code in a .ts file, you would run it using Pulumi CLI commands:

Initialize a new Pulumi project: pulumi new typescript
Set your GCP configuration: pulumi config set gcp:project <your_project>
Deploy the stack: pulumi up

When you run pulumi up, Pulumi will provision the GKE cluster and deploy Multus CNI Helm chart into it. You can see the outputs by running pulumi stack output. Remember to replace values like <your_project>, <your_zone>, and <chart_version> with your specific configurations.