Deploy the fastapi-app helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `fastapi-app` Helm chart on Google Kubernetes Engine (GKE), we will go through the following steps:

1. **Create a GKE Cluster**: First, we need to set up a Kubernetes cluster on GKE where our Helm chart will be deployed.
2. **Install the Helm Chart**: Using Pulumi's Helm support, we will deploy the `fastapi-app` chart into our GKE cluster.

For this, we’ll use the `@pulumi/gcp` package to create the GKE cluster and the `@pulumi/kubernetes` package to work with Kubernetes resources, including deploying the Helm chart.

Here's a TypeScript Pulumi program that accomplishes both of the above steps:

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as gcp from '@pulumi/gcp';
import * as k8s from '@pulumi/kubernetes';

// Step 1: Create a GKE cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "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 to access the cluster with kubectl
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}'`;
    });

// Step 2: Deploy the `fastapi-app` Helm chart into the created cluster
const helmChart = new k8s.helm.v3.Chart("fastapi-app", {
    chart: "fastapi",
    version: "1.0.0", // Specify the version of the chart if required
    // Replace 'exampleRepo' with the actual repository that hosts the 'fastapi-app' chart.
    // If 'fastapi-app' is a local chart, you can set `path: "./path-to-your-chart"`.
    fetchOpts: { 
        repo: "http://exampleRepo/chart" 
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig })});

// Export the Helm chart resources
export const helmChartResources = helmChart.resources;
```

### Explanation:

- We import the required Pulumi libraries for GCP and Kubernetes.
- We create a GKE cluster with a specified machine type and certain OAuth scopes for the nodes.
- We then export the cluster name and a kubeconfig, which is used to communicate with the cluster using tools like `kubectl` or Pulumi's Kubernetes provider.
- We deploy a Helm chart named `fastapi-app` from a hypothetical `http://exampleRepo/chart` repository.
- We instantiate a Kubernetes provider with this kubeconfig, which Pulumi uses to communicate with the created GKE cluster.
- Finally, we export the resources created by the Helm chart for visibility.

Ensure you replace `"http://exampleRepo/chart"` with the actual repository URL that contains your `fastapi-app` chart, and specify the correct version if necessary.

After running this program with Pulumi, you should have the `fastapi-app` Helm chart deployed on a GKE cluster. You can then proceed to manage and interact with your FastAPI application running within that cluster.