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

Question

Pulumi · Accepted Answer

To deploy an `apache_prueba` helm chart on Google Kubernetes Engine (GKE) with Pulumi, you'll need to follow these general steps:

1. **Set up a GKE cluster**: This is the environment where your Helm chart will be deployed. The cluster requires a name, a location (zone or region), and configurations related to the type of machines, networking, and possibly other settings depending on your needs.

2. **Install and Configure Pulumi Kubernetes Provider**: To interact with the Kubernetes API server of your GKE cluster, you’ll need to use the Pulumi Kubernetes provider. This provider enables Pulumi to perform actions such as applying Helm charts. The provider requires configuration that will point it to the right cluster and authenticate correctly.

3. **Deploy the Helm Chart**: With the cluster and provider set up, you can proceed to deploy the helm chart. The `apache_prueba` helm chart will include configurations, such as chart values which might be different than the defaults provided in the chart itself.

Below is a Pulumi program written in TypeScript that sets up a GKE cluster and deploys an `apache_prueba` helm chart. This program assumes you've already set up [Pulumi and Google Cloud SDK](https://www.pulumi.com/docs/get-started/gcp/) on your machine.

The program includes comments that explain each part of the process.

```typescript
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", {
    // You can specify additional settings for your cluster here.
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
});

// The Kubeconfig can be used to connect to the cluster using kubectl or the Kubernetes SDK to deploy applications.
// Here we are exporting the Kubeconfig for the cluster.
export const kubeconfig = cluster.masterAuth.apply(masterAuth => {
    const context = `${gcp.config.project}_${gcp.config.zone}_${cluster.name}`;
    return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${cluster.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-path: gcloud
        cmd-args: "config config-helper --format=json"
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'`
});

// Set up the Pulumi Kubernetes provider to use the generated kubeconfig so that we can deploy resources to the cluster.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the apache_prueba helm chart into the cluster using the Kubernetes provider.
const apachePruebaChart = new k8s.helm.v3.Chart("apache-prueba", {
    chart: "apache", // The name of the chart. Change this to "apache_prueba" if that is the real name of your chart.
    values: {
        // You can define the values for your chart here. Use the values as specified by the chart's documentation.
    },
}, { provider: k8sProvider });

// Export the URL of the deployed Apache service.
export const apacheServiceUrl = apachePruebaChart.getResourceProperty("v1/Service", "apache-prueba", "status").apply(status => status.loadBalancer.ingress[0].ip);
```
With this program:
- A new GKE cluster named `my-gke-cluster` is created with 2 nodes.
- A kubeconfig file is generated to interact with the cluster.
- The Pulumi Kubernetes provider is set up using the kubeconfig.
- The `apache_prueba` Helm chart is deployed to the cluster.
- The URL of the Apache service deployed by the Helm chart is exported.

Please, replace `"apache"` with `"apache_prueba"` in the `chart` property of `helm.v3.Chart` if that is the actual name of your Helm chart.

To run this Pulumi program:
1. Initialize a Pulumi project with `pulumi new gcp-typescript`.
2. Replace the content of `index.ts` with the program above.
3. Run `pulumi up` to create the resources.
4. After the deployment, Pulumi will output the IP address of the Apache service.

Remember, Helm charts have their own set of values that you can customize as per your requirements. These values are to be provided in the `values` object when declaring the `helm.v3.Chart` resource. Check the documentation of the `apache_prueba` chart for available configuration options.