Deploy the nginx-revproxy helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `nginx-revproxy` Helm chart on Google Kubernetes Engine (GKE), you'll need to follow these general steps:

1. Provision a GKE cluster.
2. Install the Helm chart for nginx reverse proxy onto the cluster.

Here's a breakdown of this process in Pulumi using TypeScript:

### Provision a GKE Cluster
To provision a GKE cluster, we use the `google-native.container/v1beta1.Cluster` resource from the `google-native` provider. This resource allows us to create and manage a GKE cluster.

### Install the nginx-revproxy Helm Chart
To install a Helm chart, we use the `kubernetes.helm.sh/v3.Release` resource from the `kubernetes` provider. This resource is capable of deploying Helm charts.

Below is a TypeScript program that creates a new GKE cluster and then deploys the `nginx-revproxy` Helm chart to that cluster. Note that you must have `gcloud` configured with credentials and appropriate permissions to create resources on Google Cloud Platform, and you must be logged in with the `pulumi` CLI.

```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("my-gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        preemptible: true,
        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 Cluster endpoint
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 k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the nginx-revproxy Helm chart
const nginxRevproxyChart = new k8s.helm.v3.Chart("nginx-revproxy", {
    chart: "nginx-revproxy",
    version: "1.0.0", // Specify the version of the Helm chart
    fetchOpts:{
        repo: "http://charts.example.com/", // Replace with the actual chart repository
    },
}, { provider: k8sProvider });

// Export the nginx-revproxy service's external IP address
export const nginxRevproxyIp = nginxRevproxyChart.getResourceProperty("v1/Service", "nginx-revproxy", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

### Breaking Down the Code
1. **Cluster Creation**: Instantiate a GKE cluster with desired node count and versioning settings using the `gcp.container.Cluster` class.
2. **Kubeconfig Generation**: Create the kubeconfig needed to interact with the cluster. The kubeconfig is dynamically generated with the necessary credentials and endpoint information.
3. **Kubernetes Provider**: Setup the Pulumi Kubernetes provider configured to use our newly created GKE cluster's kubeconfig.
4. **Helm Chart Deployment**: Use the `k8s.helm.v3.Chart` resource to deploy the `nginx-revproxy` Helm chart on our GKE cluster.

Keep in mind, you'll have to replace `http://charts.example.com/` with the actual repository URL that hosts your Helm chart.

This program will provision both the GKE cluster and the nginx reverse proxy when you run it with `pulumi up`. Remember to have your Pulumi and GCP configuration set up beforehand.