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

Question

Pulumi · Accepted Answer

To deploy the `stunnel` Helm chart on Google Kubernetes Engine (GKE), you'll want to follow these general steps:

1. Set up a GKE cluster: You need a Kubernetes cluster to deploy Helm charts. GKE provides managed Kubernetes clusters that simplify the process of cluster creation and management.
2. Configure kubectl: `kubectl` is a Kubernetes command-line tool which allows you to run commands against Kubernetes clusters. You'll use it to interact with your GKE cluster.
3. Install Helm: Helm is a package manager for Kubernetes that enables you to package, configure, and deploy applications and services onto Kubernetes clusters.
4. Add the necessary Helm repository that contains the `stunnel` chart, if it's not part of the stable charts that come with Helm.
5. Deploy the `stunnel` chart using Helm.

Below is a Pulumi program in TypeScript that accomplishes this. Please note that for this scenario, you'll need to ensure that you have the correct configurations set up for accessing GKE, such as having the `gcloud` CLI installed and authenticated to your Google Cloud account, as Pulumi relies on these configurations to provision and manage resources in GKE.

```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("stunnel-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
        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 the Cluster name
export const clusterName = cluster.name;

// Export the Kubeconfig file to access the cluster using kubectl locally
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 provider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Add the Helm chart repository hosting the stunnel chart
const repo = "helm-repo";
const helmRepo = new k8s.helm.v3.Repository(repo, {
    url: "https://charts.helm.sh/stable", // Replace with the actual repo URL
}, { provider: provider });

// Deploy the `stunnel` helm chart
const stunnelReleaseName = "stunnel-release";
const stunnelChart = new k8s.helm.v3.Chart(stunnelReleaseName, {
    chart: "stunnel",
    version: "1.0.0", // Replace with the actual chart version
    namespace: "default",
}, { provider: provider });

// Export the `stunnel` release's status
export const stunnelStatus = stunnelChart.status;

// It is essential to refer to the documentation of the stunnel chart for configuration
// details and ensure that you configure the chart values according to your requirements.
// In case the stunnel chart requires a custom values file or specific settings, you can
// use the `values` property in `k8s.helm.v3.ChartArgs` to provide them.

```

This Pulumi program does the following:

1. **Create a GKE cluster**: It declares a new GKE cluster with a specific node count and machine type. The `oauthScopes` enable the necessary Google Cloud APIs on the nodes.

2. **Export configuration**: It exports the cluster name and the kubeconfig, which can be used to connect to the cluster using `kubectl`.

3. **Create a Kubernetes provider** that points to our newly created GKE cluster. This provider will be used for all Kubernetes resources.

4. **Add a Helm chart repository**: This code adds the repository which hosts the `stunnel` Helm chart. You would use the URL to the repository that contains the chart.

5. **Deploy the `stunnel` Helm chart**: It installs the `stunnel` chart into the default namespace using Helm. The chart’s version and any custom values would be replaced with those relevant to your usage.

6. **Export the `stunnel` release status**: After deployment, you can access the `stunnel` release status, which provides details on the health and configuration of the deployed chart.

Please note that the `chart` and `version` fields for the `stunnel` Helm chart should be replaced with the relevant details corresponding to the chart you wish to deploy. This may involve drawing from a specific Helm repository if the `stunnel` chart is provided by a source outside the main Helm repository.

Additionally, the program assumes that you place the actual URL of the `stunnel` helm chart repository instead of `https://charts.helm.sh/stable`, since there is no official `stunnel` chart in the stable Helm repository as of my knowledge cutoff in 2023.

If the `stunnel` chart requires additional configuration via values (e.g., customizing ports, enabling persistence, etc.), you'll need to include a `values` field in the `k8s.helm.v3.ChartArgs` structure passed to the `Chart` resource, or you can use a `values.yaml` file.

Before running the Pulumi program, ensure that:

- You have Pulumi installed and configured.
- You have configured the Pulumi CLI with the right credentials for accessing GCP.
- You have the `gcloud` CLI installed and authenticated to your Google Cloud account.
- You have Helm installed if you wish to add repositories or manage Helm releases manually.

To deploy this Pulumi program, you should run `pulumi up` from the directory where the program file is located. The Pulumi CLI will guide you through the preview and deployment process.