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

Question

Pulumi · Accepted Answer

To deploy the Swagger Editor Helm chart on Google Kubernetes Engine (GKE), you would typically follow these steps:

1. Provision a GKE cluster.
2. Install and initialize Helm, if not already done.
3. Add the Helm chart repository that contains the Swagger Editor chart.
4. Install the Swagger Editor chart onto your GKE cluster using Helm.

With Pulumi, you can automate all of the above steps within your infrastructure as code. Below is a Pulumi program written in TypeScript that demonstrates how you can achieve this.

This program does the following:
- Uses the `@pulumi/gcp` package to create a new GKE cluster.
- Uses the `@pulumi/kubernetes` package to deploy the specified Helm chart into the provisioned GKE cluster.

Before you run the program, ensure that you have Pulumi installed and configured for use with GCP. You'll need to have a GCP project and appropriate credentials configured.

Here's the complete program that deploys the Swagger Editor Helm chart on GKE:

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

// Create a GKE cluster.
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        machineType: "n1-standard-1",
        oauthScopes: [
            "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;

// Manufacture a GKE-style kubeconfig. Note that this is slightly "different"
// because of the way GKE requires gcloud to get the user credentials for kubectl.
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 k8s provider instance of the cluster.
const clusterProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Use Helm to deploy the Swagger Editor chart.
const swaggerEditorChart = new k8s.helm.v3.Chart("swagger-editor", {
    chart: "swagger-editor",
    version: "2.2.0", // replace with the desired chart version
    fetchOpts: {
        repo: "https://charts.helm.sh/stable", // replace with the chart's repository URL
    },
}, { provider: clusterProvider });

// Export the Swagger Editor service endpoint
export const swaggerEditorEndpoint = pulumi.interpolate `http://${swaggerEditorChart.getResourceProperty("v1/Service", "swagger-editor", "status").apply(status => status.loadBalancer.ingress[0].ip)}`;
```

This code will create a new GKE cluster and deploy the Swagger Editor onto it using Helm. The `swaggerEditorChart` resource specifies the name of the Helm chart, and the fetching options including the repository where the chart is stored.

Please replace `version` with the desired chart version and `repo` with the correct Helm chart repository URL for the Swagger Editor chart if it's different from what is given. If the Swagger Editor chart is not available in the stable Helm repo, you might need to add the Helm repo that contains the Swagger Editor chart using `helm repo add`.

After running this Pulumi program with `pulumi up`, you will have a GKE cluster with the Swagger Editor deployed.

Remember to destroy the resources created by Pulumi when they're no longer needed to avoid ongoing charges on your GCP bill. You can do this by running `pulumi destroy` from the command line.