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

Question

Pulumi · Accepted Answer

To deploy the `ansible-semaphore` Helm chart on Google Kubernetes Engine (GKE), you will need to complete the following steps:

1. Create a GKE cluster.
2. Configure your Pulumi program to use the Helm chart.
3. Deploy the chart to your cluster.

Below is a Pulumi program that demonstrates this process using TypeScript. This program leverages Pulumi's GKE and Helm support to create a Kubernetes cluster and deploy the chart to it.

### Detailed Explanation

#### Creating GKE Cluster

The `google-native.container/v1.Cluster` resource ([docs](https://www.pulumi.com/registry/packages/google-native/api-docs/container/v1/cluster/)) is used to create the GKE cluster. You must provide various properties required for the cluster configuration, such as the name, location, and node configuration.

#### Setting up K8s Provider

To interact with the Kubernetes cluster that we just created, we need to use the Pulumi `kubernetes` provider. This provider will allow us to deploy Helm charts to the cluster. The Pulumi program must authenticate to the cluster. This is implicitly handled by Pulumi, which reads the kubeconfig file generated during the GKE cluster creation.

#### Deploying Helm Chart

The `kubernetes.helm.v3.Chart` resource ([docs](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/)) represents a Helm chart in a Pulumi program. We use it to deploy `ansible-semaphore`. Note that you need to specify the chart name and may also need to specify the repository URL where the Helm chart is located if it's not in the default Helm repository.

### Pulumi TypeScript Program

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as k8s from "@pulumi/kubernetes";
import * as googleNative from "@pulumi/google-native";

// Step 1: Create a GKE cluster
const cluster = new googleNative.container.v1.Cluster("ansible-semaphore-cluster", {
    // Replace these with appropriate values or logic to generate them
    project: "your-gcp-project-id",
    location: "us-central1-c",
    initialNodeCount: 1,
    nodeConfig: {
        // Machine type can be adjusted based on the load you expect
        machineType: "e2-medium",
    },
});

// Step 2: Set up the Pulumi Kubernetes provider to interact with the GKE cluster
const k8sProvider = new k8s.Provider("k8s", {
    kubeconfig: cluster.endpoint.apply(endpoint =>
        cluster.masterAuth.apply(masterAuth => {
            const context = `gke_${process.env.PULUMI_GCP_PROJECT}_${cluster.location}_${cluster.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
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 3: Deploy the Helm chart to the GKE cluster
const semaphoreHelmChart = new k8s.helm.v3.Chart("ansible-semaphore-chart", {
    chart: "ansible-semaphore",
    // Assuming the Helm chart for ansible-semaphore is in a repo called 'ansible-semaphore-repo',
    // replace this with the actual repository URL if needed.
    fetchOpts: {
        repo: "https://charts.yourcompany.com/",
    },
    // Define any values here you need to customize your Helm chart installation
    values: {},
}, { provider: k8sProvider });

// Export relevant resources
export const clusterName = cluster.name;
export const kubeconfig = k8sProvider.kubeconfig;
```

This program will create a new GKE cluster and deploy the `ansible-semaphore` Helm chart to it. Make sure to replace the placeholders with actual values. For example, you'll need a proper GCP project ID and determine the best location and machine type for your cluster's needs.

Finally, the `kubeconfig` export statement will output the kubeconfig you can use to interact with your Kubernetes cluster using other tools outside of Pulumi, such as `kubectl`.

When you're ready, you can run this Pulumi program using the Pulumi CLI, and it will perform all the defined actions.