Deploy the vertx helm chart on Google Kubernetes Engine (GKE)
TypeScriptTo deploy the Vert.x Helm chart on Google Kubernetes Engine (GKE) using Pulumi, we will go through a step-by-step process:
- Set up a GKE Cluster: We need to create a GKE cluster where our application will be deployed.
- 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:
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 usegcp.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 usingk8s.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:
- Save the code to a file with a
.ts
extension, for instance,index.ts
. - 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.