Deploy the php-stack helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a PHP stack using a Helm chart on Google Kubernetes Engine (GKE), you'll need to create a GKE cluster and then use Pulumi's `@pulumi/kubernetes` package to deploy the Helm chart.

Below is a Pulumi program written in TypeScript that demonstrates how to accomplish this:

1. **Set up a GKE cluster**: The GKE cluster is the environment where your PHP application will run. We will create a zonal cluster, which means it will be located within a single compute zone. We define the necessary node count and machine type for the cluster's default node pool.
   
2. **Install the Helm Chart**: Helm is a package manager for Kubernetes, which allows you to define, install, and upgrade complex Kubernetes applications. Pulumi allows you to install Helm charts directly into your GKE cluster using the Pulumi Kubernetes provider. The `@pulumi/kubernetes` package enables you to reference Helm charts from public or private chart repositories and manage them using Pulumi.

Here is the detailed TypeScript code that you can use to deploy a PHP stack on GKE. The comments within the code will help you understand what each section does:

```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("php-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 GKE cluster from your local machine
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,
});

// Deploy the PHP Helm chart into our cluster.
// You should replace `repoURL` and `chart` with the actual values of the PHP stack you want to deploy.
const phpHelmChart = new k8s.helm.v3.Chart("php-stack", {
    // This should be changed to the specific repository where your PHP stack Helm chart is located.
    chart: "php-stack",
    version: "1.0.0",
    fetchOpts: {
        repo: "https://charts.your-repo.com",
    },
}, { provider });

```

### Explanation:

- **Cluster Creation**: We create a new instance of a GKE cluster using `gcp.container.Cluster`. We also define the machine type for the nodes and the required OAuth scopes for the GCP APIs that the nodes will access.

- **Kubeconfig**: This is your cluster's configuration, which you'll need in order to interact with the cluster via `kubectl` or any Kubernetes SDK. Pulumi automatically generates this for you by combining the cluster's details.

- **Kubernetes Provider**: This resource lets Pulumi know which cluster to deploy resources into. It uses the `kubeconfig` we defined earlier.

- **Helm Chart Deployment**: Finally, we deploy a PHP stack Helm chart using `k8s.helm.v3.Chart`. You would need to customize the `chart` field with the name of a PHP Helm chart and `fetchOpts` to include the URL of the Helm repository containing the chart.

### Notes:

- Ensure you have the necessary access rights in your GCP project to create and manage GKE clusters.

- The Helm chart and repository here are placeholders; you should replace the `chart` and `repo` fields with the appropriate values for the PHP stack you wish to deploy.

- The `kubeconfig` resource is being exported, enabling you to interact with your Kubernetes cluster using `kubectl` from your local machine.

Remember to replace placeholder values within the Helm chart `fetchOpts` property to match the Helm chart details of your PHP stack. Once you've created this Pulumi program, run `pulumi up` to deploy it to GCP.