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

Question

Pulumi · Accepted Answer

To deploy the Open vSwitch Helm chart on Google Kubernetes Engine (GKE), you'll need to follow these steps:

1. Set up a new GKE cluster or use an existing one.
2. Install Helm on your local machine and configure it to communicate with the GKE cluster.
3. Use Helm to deploy the Open vSwitch chart to your GKE cluster.

Below is a Pulumi TypeScript program that accomplishes these steps:

- It provisions a new GKE cluster.
- It configures the Kubernetes provider to communicate with the newly created GKE cluster.
- It uses the Helm chart resource to deploy Open vSwitch onto the GKE cluster.

```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,
    minMasterVersion: "latest", // Ensure that the master version is up to date
    nodeVersion: "latest", // Ensure that the nodes are up to date
    nodeConfig: {
        machineType: "n1-standard-1", // Minimal viable machine type, adjust as needed
        oauthScopes: [ // Required scopes for the GCP services the nodes may interact with
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring",
            "https://www.googleapis.com/auth/servicecontrol",
            "https://www.googleapis.com/auth/service.management.readonly",
            "https://www.googleapis.com/auth/trace.append"
        ],
    },
});

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

// Export the Kubeconfig to access the GKE 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 clusterProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy Open vSwitch using the Helm chart.
const openvSwitchChart = new k8s.helm.v3.Chart("openvswitch", {
    chart: "openvswitch", // This is the name of the chart; you may need to adjust this based on the Helm repository.
    version: "YOUR_CHART_VERSION", // Replace with the specific version of Open vSwitch chart you want to deploy
    fetchOpts: {
        // If Open vSwitch is hosted in a custom Helm repo, you would need to provide the repo URL here
        // For example: repo: "https://helm-repo-url"
    },
}, { provider: clusterProvider });

// Export the Helm chart name
export const openvSwitchChartName = openvSwitchChart.releaseName;
```

Make sure to replace `"YOUR_CHART_VERSION"` with the version of the Open vSwitch chart that you wish to use.

**Explanation:**

- We start by importing the necessary Pulumi libraries for our program.
- Next, we provision a new GKE cluster with a couple of nodes with the specified machine type and OAuth scopes.
- We export the cluster name and generate a kubeconfig that will allow us to interact with our GKE cluster via the Kubernetes API.
- We create a new instance of the Kubernetes provider that knows how to communicate with our GKE cluster using the kubeconfig we generated.
- Finally, we deploy the Open vSwitch Helm chart to our GKE cluster using the `k8s.helm.v3.Chart` resource. We provide the name of the chart and specify the version to deploy. If the chart is hosted in a custom repository, the repository URL should be provided in `fetchOpts`.

After running this Pulumi program, you will have a GKE cluster with Open vSwitch deployed. You can manage and interact with your GKE cluster using `kubectl` with the generated kubeconfig.