Deploy the caddy-reverse-proxy helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

In order to deploy the `caddy-reverse-proxy` Helm chart on Google Kubernetes Engine (GKE), you'll need to follow these steps:

1. Set up a new GKE cluster or use an existing one.
2. Use a Helm Chart resource within Pulumi to deploy `caddy-reverse-proxy` on the GKE cluster.

Below is a detailed Pulumi TypeScript program that walks you through this process:

1. **Setting up a GKE Cluster**: To start, we'll use the `google-native.container.v1beta1.Cluster` resource to create a new GKE cluster. This step is necessary only if you don't already have a GKE cluster. If you do, you can skip to step 2 and make sure your context is set to your existing cluster.

2. **Deploying the Helm Chart**: We will then deploy the chart using the `kubernetes.helm.v3.Chart` resource, which is part of the Pulumi Kubernetes provider. This will install the `caddy-reverse-proxy` chart from its repository into your cluster.

Please make sure to have the necessary Pulumi and Kubernetes packages installed in your environment before running this program:

- `@pulumi/pulumi`
- `@pulumi/kubernetes`
- `@pulumi/gcp` or `@pulumi/google-native` for GCP resources

The `@pulumi/gcp` package is used here over the native GCP package as the higher-level components make it simpler to establish and configure the GKE cluster. Now, here is the complete program:

```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("gke-cluster", {
    initialNodeCount: 1,
    minMasterVersion: "latest", // Use the latest available version of Kubernetes
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // This is a cost-effective machine type, change as needed
        oauthScopes: [
            "https://www.googleapis.com/auth/cloud-platform"
        ],
    },
});

// Export the Cluster name
export const clusterName = cluster.name;

// Once the cluster is created, we can connect to it to deploy applications.
// Note: It may take a minute or two to establish a working connection to the new cluster.
const provider = new k8s.Provider("gke-provider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the 'caddy-reverse-proxy' Helm chart
const caddyChart = new k8s.helm.v3.Chart("caddy-reverse-proxy", {
    chart: "caddy-reverse-proxy",
    version: "0.1.0", // specify the version you want to deploy, or remove to deploy the latest
    fetchOpts:{
        repo: "https://caddyserver.github.io/helm://" // use the actual Helm chart repository
    },
}, { provider });

// Export the Kubeconfig to access the cluster
export const kubeConfig = cluster.kubeconfig;

```

### How this Program Works

1. **GKE Cluster Creation**: The `google-native.container.v1beta1.Cluster` resource is used to create a new GKE cluster. We specify the node count and the version of Kubernetes to use. 
   
2. **Kubernetes Provider Setup**: We then set up a Pulumi Kubernetes Provider that uses the kubeconfig from the newly created GKE cluster to communicate with it.
   
3. **Helm Chart Deployment**: Finally, `caddy-reverse-proxy` is deployed using the `kubernetes.helm.v3.Chart` resource. You might need to customize the `chart` parameter and `fetchOpts.repo` with the correct chart name and Helm repository URL. The `version` field is optional and if it's not specified, Pulumi deploys the latest version available in the Helm repository. The `{ provider }` argument ensures that Helm uses the correct Kubernetes provider which is linked to our GKE cluster.

### What to Do Next

To deploy this Pulumi program:

1. Save the above code in a file called `index.ts`.
2. Run `pulumi up` to preview and deploy the changes.
3. Once the deployment is complete, you'll receive outputs on the command line, including the cluster name and the kubeconfig needed to interact with the Kubernetes cluster.

Make sure you have the appropriate permissions set up in GCP for Pulumi to create and manage resources. If you're using an existing cluster, you'll need to configure the appropriate `kubeconfig` for Pulumi to connect to your Kubernetes cluster.