How do I deploy Redis and Cube.js on Kubernetes?

In this guide, we will deploy Redis and Cube.js on a Kubernetes cluster using Pulumi. Redis will be deployed using the RedisLabs Kubernetes operator, and Cube.js will be deployed as a custom application. We will define the necessary Kubernetes resources including deployments, services, and configurations.

import * as pulumi from "@pulumi/pulumi";
import * as k8s from "@pulumi/kubernetes";

// Define the Redis Enterprise Cluster (REC)
const redisCluster = new k8s.apiextensions.CustomResource("redisCluster", {
    apiVersion: "app.redislabs.com/v1",
    kind: "RedisEnterpriseCluster",
    metadata: {
        name: "redis-cluster",
    },
    spec: {
        nodes: 3,
    },
});

// Define the Redis database
const redisDatabase = new k8s.apiextensions.CustomResource("redisDatabase", {
    apiVersion: "app.redislabs.com/v1",
    kind: "RedisEnterpriseDatabase",
    metadata: {
        name: "redis-database",
    },
    spec: {
        memorySize: 100, // 100 MB
        redisEnterpriseCluster: {
            name: redisCluster.metadata.name,
        },
    },
});

// Define the Cube.js deployment
const cubejsDeployment = new k8s.apps.v1.Deployment("cubejsDeployment", {
    metadata: {
        name: "cubejs",
    },
    spec: {
        selector: {
            matchLabels: {
                app: "cubejs",
            },
        },
        replicas: 1,
        template: {
            metadata: {
                labels: {
                    app: "cubejs",
                },
            },
            spec: {
                containers: [
                    {
                        name: "cubejs",
                        image: "cubejs/cube:v0.27.0",
                        ports: [
                            {
                                containerPort: 4000,
                            },
                        ],
                        env: [
                            {
                                name: "CUBEJS_DB_HOST",
                                valueFrom: {
                                    secretKeyRef: {
                                        name: redisDatabase.metadata.name,
                                        key: "host",
                                    },
                                },
                            },
                            {
                                name: "CUBEJS_DB_PORT",
                                value: "6379",
                            },
                            {
                                name: "CUBEJS_DB_TYPE",
                                value: "redis",
                            },
                        ],
                    },
                ],
            },
        },
    },
});

// Define the Cube.js service
const cubejsService = new k8s.core.v1.Service("cubejsService", {
    metadata: {
        name: "cubejs-service",
    },
    spec: {
        selector: {
            app: "cubejs",
        },
        ports: [
            {
                port: 80,
                targetPort: 4000,
            },
        ],
        type: "LoadBalancer",
    },
});

// Export the Cube.js service URL
export const cubejsServiceUrl = cubejsService.status.loadBalancer.ingress[0].hostname;

Key Points:

We deployed a Redis Enterprise Cluster using the RedisLabs Kubernetes operator.
We created a Redis database within the Redis Enterprise Cluster.
We deployed Cube.js as a Kubernetes deployment, configuring it to connect to the Redis database.
We exposed Cube.js through a Kubernetes service with a LoadBalancer type to make it accessible externally.

Summary:

This guide demonstrated how to deploy Redis and Cube.js on a Kubernetes cluster using Pulumi. We defined the necessary Kubernetes resources and configurations to ensure Redis and Cube.js work together seamlessly.

Deploy this code

Want to deploy this code? Sign up for a free Pulumi account to deploy in a few clicks.

New to Pulumi?

Want to deploy this code? Sign up with Pulumi to deploy in a few clicks.