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

Question

Pulumi · Accepted Answer

To deploy the Vert.x Helm chart on Google Kubernetes Engine (GKE) using Pulumi, we will go through a step-by-step process:

1. **Set up a GKE Cluster**: We need to create a GKE cluster where our application will be deployed.
2. **Install the Helm Chart**: Once we have a Kubernetes cluster, we can proceed to install the Helm chart for Vert.x.

Firstly, we need to set up a GKE cluster using Pulumi's GCP provider. The `google-native.container/v1.Cluster` resource will allow us to create this cluster. We choose this resource because it is high-level and provides us with the necessary properties to configure a cluster in GKE.

Once the cluster is available, we'll use the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes provider to deploy the Vert.x Helm chart. The Helm chart resource gives us an interface to work with Helm charts similar to how we would with the Helm CLI but programmatically through Pulumi.

Below is a TypeScript program using Pulumi that accomplishes the deployment of a Vert.x Helm chart on a GKE cluster:

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

const name = "vertx-cluster";

// Creating a GKE cluster
const cluster = new gcp.container.Cluster(name, {
    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 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:
    client-certificate-data: ${masterAuth.clientCertificate}
    client-key-data: ${masterAuth.clientKey}
`;
});

// Create a Kubernetes provider instance that uses our cluster from above.
const clusterProvider = new k8s.Provider(name, {
    kubeconfig: kubeconfig,
});

// Deploy the vertx Helm chart onto the GKE cluster
const vertxChart = new k8s.helm.v3.Chart("vertx-chart", {
    chart: "vertx",
    version: "1.0.0", // Replace with the desired chart version
    fetchOpts: {
        repo: "http://your-helm-chart-repository/", // Specify the repository hosting the Vert.x Helm chart
    },
}, { provider: clusterProvider });

// Export the public IP to access the Vert.x service
export const vertxPublicIp = vertxChart.getResourceProperty("v1/Service", "vertx-chart", "status").apply(status => status.loadBalancer.ingress[0].ip);

```

Here's how the Pulumi program works:

- We define the `cluster` constant, where we use `gcp.container.Cluster` to set up a GKE cluster.
- We export `kubeconfig`, which will be used to communicate with our GKE cluster.
- We create a `k8s.Provider` which is required by the Helm chart resource to know which cluster we're working with.
- We then define the `vertxChart` constant using `k8s.helm.v3.Chart`. This resource is responsible for deploying the requested Helm chart to our cluster. 
- Finally, we export `vertxPublicIp` which fetches the load balancer IP that is allocated to the deployed service, allowing us to access the Vert.x application from the internet.

Please replace the placeholder values (e.g., `http://your-helm-chart-repository/`) with actual values that you wish to use in your deployment.

To deploy this program:

1. Save the code to a file with a `.ts` extension, for instance, `index.ts`.
2. Run `pulumi up` in the same directory where the file is located. Pulumi CLI will execute the code and create the resources in your GCP account. Make sure you have the correct GCP configuration set up.
   
Upon successful execution, Pulumi will provide you with the `vertxPublicIp` which you can use to access your Vert.x application on the internet.