Deploy the developer-portal helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To accomplish the deployment of the `developer-portal` helm chart on Google Kubernetes Engine (GKE), you will be following these steps:

1. **Create a GKE Cluster**: You need a running Kubernetes cluster on GKE to deploy the helm chart. This will involve specifying details like the machine type for your nodes, the number of nodes, and the cluster version.

2. **Install and Configure Helm in your local environment**: Helm is a package manager for Kubernetes that allows you to deploy applications using charts. Make sure you have Helm installed in your local environment and that it is configured to interact with your GKE cluster.

3. **Deploy the Helm Chart**: You would find the `developer-portal` helm chart and deploy it to your GKE cluster using Helm. This involves adding the chart repository, fetching the chart, and using `helm install` to deploy it to the cluster.

Here is a Pulumi program written in TypeScript that does all the steps above:

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

// Step 1: Create GKE Cluster
// Here we create a GKE cluster with the desired configurations.
const cluster = new gcp.container.Cluster("developer-portal-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "e2-medium",
    },
});

// Export the Cluster name and Kubeconfig
export const clusterName = cluster.name;
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
`;
    });

// Step 2: Set up the Kubernetes provider using the GKE cluster's kubeconfig
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Step 3: Deploy the helm chart to the GKE cluster
// Assuming that the "developer-portal" helm chart is available in a public repository
const chart = new k8s.helm.v3.Chart("developer-portal-chart", {
    chart: "developer-portal",
    fetchOpts: {
        repo: "http://example.com/helm/repo", // specify the actual chart repository URL here
    },
    // You can specify additional configuration values here as needed.
}, { provider: k8sProvider });

// Export the status of the Helm deployment
export const helmDeploymentStatus = chart.status;
```

**Detailed Explanation**:

- We're importing the necessary Pulumi packages. You'll need `@pulumi/gcp` for creating the GKE cluster, `@pulumi/kubernetes` for managing Kubernetes resources, and `@pulumi/pulumi` for programming against the Pulumi API.

- We create a GKE cluster using the `gcp.container.Cluster` class. This class accepts various configurations, such as the node count, machine types for the nodes, and Kubernetes versions.

- Once the cluster is created, we generate a `kubeconfig` file. This file is used for configuring kubectl and Kubernetes client libraries to interact with your Kubernetes cluster.

- We then set up the Kubernetes provider by creating an instance of `k8s.Provider`. This provider object is configured to use the `kubeconfig` we generated.

- Finally, we deploy the `developer-portal` helm chart using the `k8s.helm.v3.Chart` resource, which communicates with your cluster's API server to apply the desired state defined by the helm chart. You'll need to replace `"http://example.com/helm/repo"` with the actual URL for the `developer-portal` helm chart repository.

- The `export` statements at the end provide the output of your Pulumi program which you can use to interact with your deployed resources. The `helmDeploymentStatus` will give you insights into the status of your helm release.

**Prerequisites**:

1. Pulumi CLI installed and configured.
2. GCP account configured with the Pulumi.
3. Helm CLI installed locally for chart management.

**Next Steps After Running This Program**:

After executing this Pulumi program, your GKE cluster and the `developer-portal` helm chart should be up and running. You can verify by using `kubectl` with the exported `kubeconfig` to interact with your cluster and the deployed services.