Deploy the sdnc-ansible-server helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE), we'll go through the following steps:

1. **Set up a GKE cluster**: We'll create a Kubernetes cluster in GKE where the Helm chart will be deployed.
2. **Install and Configure Helm in our local environment**: Helm is a package manager for Kubernetes, which helps you define, install, and upgrade even the most complex Kubernetes applications.
3. **Deploy the Helm chart**: We'll use Helm to deploy the `sdnc-ansible-server` chart to our GKE cluster.

Let's start with the Pulumi program in TypeScript to create a GKE cluster.

To do this, we'll use the `google-native.container/v1beta1.Cluster` resource from [Pulumi's Google Native provider](https://www.pulumi.com/registry/packages/google-native/api-docs/container/v1beta1/cluster/), which allows us to provision a GKE cluster directly using the Google Kubernetes Engine API. The advantage of using the Google Native provider is that it has one-to-one feature parity with the resources available in the Google Cloud Platform.

Below is a Pulumi program that sets up a GKE cluster. This code assumes you have already configured the Pulumi CLI and Google Cloud provider. Before running this program, please ensure that you have the necessary permissions to create resources in Google Cloud.

```typescript
import * as gcp from "@pulumi/gcp";
import * as gcpnative from "@pulumi/google-native";
import * as pulumi from "@pulumi/pulumi";

const projectName = gcp.config.project;
const zone = gcp.config.zone || "us-west1-a";

const gkeCluster = new gcpnative.container.v1beta1.Cluster("sdnc-ansible-server-cluster", {
    // Set the location to the correct GCP zone
    location: zone,

// Configure the cluster
    autoscaling: {
        resourceLimits: [{ resourceType: "cpu", minimum: "1", maximum: "10" }],
    },
    initialNodeCount: 3,
    nodeConfig: {
        machineType: "e2-standard-2",
        oauthScopes: [
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring",
        ],
    },
});

export const clusterName = gkeCluster.name;
export const kubeconfig = pulumi.all([gkeCluster.name, gkeCluster.endpoint, gkeCluster.masterAuth]).apply(([name, endpoint, masterAuth]) => {
    const context = `${projectName}_${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
`;
});

// After the GKE cluster is created, we need to configure kubectl to connect to the new cluster.
// The output `kubeconfig` contains the configuration needed for kubectl to connect to the cluster.
```

After running the above program with Pulumi, which will create a GKE cluster, the next step is to configure kubectl to connect to the new cluster using the output `kubeconfig`. This step usually involves copying the kubeconfig to `~/.kube/config` or setting the `KUBECONFIG` environment variable to the path of the kubeconfig file.

Next, we'll need to install Helm if you haven't already done so. This is typically done through a package manager. For example, on macOS with Homebrew, you can run `brew install helm`. After Helm is installed, you can add the repository for the `sdnc-ansible-server` chart if the chart is hosted on a Helm repository. You could then deploy the chart with `helm install` as follows, substituting `your-release-name` with the desired release name and `chart-repo/sdnc-ansible-server` with the correct chart repository and name:

```shell
helm repo add chart-repo <URL-of-helm-chart-repository>
helm install your-release-name chart-repo/sdnc-ansible-server
```

Note that this step is not part of the Pulumi program and should be executed in your command line shell (like Bash, zsh, etc.). Additionally, if `sdnc-ansible-server` requires custom values, you'll need to provide a `values.yaml` file or set the values directly via the command line.

Make sure that the Helm version you are using is compatible with the version of the Kubernetes cluster created by the Pulumi program.

This is a basic workflow for deploying a GKE cluster and a Helm chart on that cluster. There can be more customizations and additional steps needed depending on the Helm chart's requirements and your specific application's needs.