Build with Cassandra

Cassandra Projects

Learn to build production-ready applications with Cassandra!

🚀 Building Cassandra Projects

Learn to build scalable, production-ready applications with Apache Cassandra from scratch!

What You'll Build:

🌐 Web Applications: REST APIs with Node.js, Python, Java
📱 Mobile Backends: Scalable backends for mobile apps
📊 Analytics Platforms: Real-time data processing
💬 Messaging Systems: Chat apps, notifications
🎮 Gaming Backends: Player data, leaderboards
📈 IoT Applications: Time-series data collection

This Guide Will Teach You:

✅ Project structure and organization

✅ Data modeling for your use case

✅ Application architecture patterns

✅ Testing and deployment strategies

📦 Project Setup

Install Cassandra Locally

# Using Docker (Recommended)
$ docker pull cassandra:latest
$ docker run --name cassandra -p 9042:9042 -d cassandra:latest

# Verify it's running
$ docker exec -it cassandra cqlsh
Connected to Test Cluster at 127.0.0.1:9042
cqlsh>

# Or install locally (Linux/Mac)
$ brew install cassandra  # Mac
$ sudo apt install cassandra  # Ubuntu

Create Project Structure

# Example: Node.js project
my-cassandra-app/
├── src/
│   ├── config/
│   │   └── cassandra.js      # Database config
│   ├── models/
│   │   └── user.js            # Data models
│   ├── routes/
│   │   └── users.js           # API routes
│   ├── services/
│   │   └── userService.js     # Business logic
│   └── app.js                 # Main app
├── tests/
│   └── user.test.js           # Unit tests
├── migrations/
│   └── 001_create_tables.cql   # Schema
├── package.json
└── README.md

Initialize Your Project

# Node.js/Express
$ npm init -y
$ npm install express cassandra-driver

# Python/Flask
$ pip install flask cassandra-driver

# Java/Spring Boot
$ spring init --dependencies=web,data-cassandra myapp

🏗️ Data Modeling Workflow

1️⃣

Define Your Use Cases

Start with queries, not entities!

# Example: Social media app queries
Q1: Get user profile by user_id
Q2: Get posts by user_id (most recent first)
Q3: Get comments for a post
Q4: Get user's followers
Q5: Get user's feed (following users' posts)

2️⃣

Design Tables for Queries

One table per query pattern!

-- Table for Q1: User profile
CREATE TABLE users (
    user_id uuid PRIMARY KEY,
    username text,
    email text,
    created_at timestamp
);

-- Table for Q2: User's posts
CREATE TABLE posts_by_user (
    user_id uuid,
    post_id timeuuid,
    title text,
    content text,
    PRIMARY KEY (user_id, post_id)
) WITH CLUSTERING ORDER BY (post_id DESC);

3️⃣

Choose Partition Keys Wisely

Partition key determines data distribution!

Partition Key Rules

✅ High cardinality: Many unique values
✅ Even distribution: No hot partitions
✅ Query-based: Matches your WHERE clauses
❌ Avoid: Status flags, boolean fields

4️⃣

Test with Sample Data

Verify your model with realistic data!

-- Insert test data
INSERT INTO posts_by_user 
    (user_id, post_id, title, content)
VALUES 
    (uuid(), now(), 'My First Post', 'Content here');

-- Test your queries
SELECT * FROM posts_by_user 
WHERE user_id = ?
LIMIT 10;

🏛️ Application Architecture

🔄

MVC Pattern

Model-View-Controller

Model: Cassandra tables
View: REST API responses
Controller: Request handlers
Perfect for web apps

📦

Repository Pattern

Data access abstraction

Repository classes per table
Encapsulate queries
Easy to test and mock
Clean separation

🎯

Service Layer

Business logic

Services call repositories
Complex workflows
Transaction coordination
Reusable logic

🔌

Microservices

Distributed architecture

Each service has DB
Independent scaling
API gateway
Event-driven

Example: 3-Layer Architecture

// 1. Repository Layer (Data Access)
class UserRepository {
    async findById(userId) {
        const query = 'SELECT * FROM users WHERE user_id = ?';
        return await cassandra.execute(query, [userId]);
    }
}

// 2. Service Layer (Business Logic)
class UserService {
    constructor(userRepo) {
        this.userRepo = userRepo;
    }
    
    async getUserProfile(userId) {
        const user = await this.userRepo.findById(userId);
        if (!user) throw new Error('User not found');
        return user;
    }
}

// 3. Controller Layer (API Endpoints)
app.get('/users/:id', async (req, res) => {
    try {
        const user = await userService.getUserProfile(req.params.id);
        res.json(user);
    } catch (error) {
        res.status(404).json({ error: error.message });
    }
});

💻 Development Workflow

Schema Migrations

# Create migration file
# migrations/001_create_users.cql

CREATE KEYSPACE IF NOT EXISTS myapp
WITH REPLICATION = {
    'class': 'SimpleStrategy',
    'replication_factor': 1
};

USE myapp;

CREATE TABLE IF NOT EXISTS users (
    user_id uuid PRIMARY KEY,
    username text,
    email text,
    created_at timestamp
);

# Run migrations
$ cqlsh -f migrations/001_create_users.cql

Connection Management

// config/cassandra.js
const cassandra = require('cassandra-driver');

// Create ONE client for entire app
const client = new cassandra.Client({
    contactPoints: [process.env.CASSANDRA_HOST || '127.0.0.1'],
    localDataCenter: 'datacenter1',
    keyspace: 'myapp'
});

// Connect on startup
async function connect() {
    await client.connect();
    console.log('Connected to Cassandra');
}

// Graceful shutdown
process.on('SIGTERM', async () => {
    await client.shutdown();
});

module.exports = { client, connect };

Environment Variables

# .env file
CASSANDRA_HOST=127.0.0.1
CASSANDRA_PORT=9042
CASSANDRA_KEYSPACE=myapp
CASSANDRA_USERNAME=cassandra
CASSANDRA_PASSWORD=cassandra

# Load in app
require('dotenv').config();

🧪 Testing Strategies

Unit Tests

// tests/userService.test.js
const { expect } = require('chai');
const sinon = require('sinon');
const UserService = require('../src/services/userService');

describe('UserService', () => {
    it('should get user by id', async () => {
        // Mock repository
        const mockRepo = {
            findById: sinon.stub().resolves({ user_id: '123', name: 'Alice' })
        };
        
        const service = new UserService(mockRepo);
        const user = await service.getUserProfile('123');
        
        expect(user.name).to.equal('Alice');
    });
});

Integration Tests

// tests/integration/user.test.js
const request = require('supertest');
const app = require('../src/app');

describe('User API', () => {
    it('should create a user', async () => {
        const res = await request(app)
            .post('/api/users')
            .send({
                username: 'testuser',
                email: 'test@example.com'
            });
        
        expect(res.status).to.equal(201);
        expect(res.body.username).to.equal('testuser');
    });
});

Test with Docker

# docker-compose.test.yml
version: '3.8'
services:
  cassandra:
    image: cassandra:latest
    ports:
      - "9042:9042"
    environment:
      - CASSANDRA_CLUSTER_NAME=TestCluster

# Run tests
$ docker-compose -f docker-compose.test.yml up -d
$ npm test
$ docker-compose -f docker-compose.test.yml down

🚀 Deployment

🐳

Docker

Containerize your app

# Dockerfile
FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

☸️

Kubernetes

Orchestrate at scale

Deploy pods
Auto-scaling
Load balancing
Health checks

☁️

Cloud Services

Managed platforms

DataStax Astra DB
AWS Keyspaces
Azure Cosmos DB
Instaclustr

🔧

CI/CD

Automated deployment

GitHub Actions
GitLab CI
Jenkins
CircleCI

💡 Best Practices

Development Best Practices

✅ Model queries first: Design tables based on access patterns
✅ Use prepared statements: Always use { prepare: true }
✅ Reuse connections: ONE client for entire app
✅ Handle errors: Implement retry logic
✅ Monitor performance: Track query latency
✅ Version your schema: Use migration scripts

Common Mistakes

❌ Modeling like SQL: Think queries, not normalization
❌ Using ALLOW FILTERING: Sign of bad data model
❌ Large partitions: Keep partitions under 100MB
❌ No denormalization: Duplicate data for queries
❌ Ignoring consistency: Choose appropriate consistency level
❌ Creating per-request clients: Very expensive!

Project Checklist

Before Production

☑️ Data model validated with real queries
☑️ Prepared statements used everywhere
☑️ Connection pooling configured
☑️ Error handling and retries implemented
☑️ Unit and integration tests written
☑️ Monitoring and logging in place
☑️ Backups configured
☑️ Security hardened (authentication, encryption)
☑️ Performance tested at scale
☑️ Documentation complete

🎉 You're Ready to Build!

You now have everything you need to start building production Cassandra applications!

🚀 Your Journey:

✅ Install Cassandra (Docker is easiest)
✅ Define your queries and use cases
✅ Design tables that match queries
✅ Build your application layer by layer
✅ Write tests for critical paths
✅ Deploy with confidence
✅ Monitor and optimize

💡 Key Takeaways:

🎯 Query-first design: Model for your access patterns
📊 Denormalization is OK: Duplicate data for performance
⚡ Prepare everything: Use prepared statements
🔄 Reuse connections: One client per application
🧪 Test thoroughly: Unit + integration tests
🚀 Start simple: Begin with basic CRUD, scale up

📚 Next Steps:

📖 Study example projects in your language
💻 Build a simple CRUD application
🔍 Explore advanced features (UDTs, collections, etc.)
📊 Learn monitoring and observability
🌐 Deploy to production environment

🚀 Start building amazing apps with Cassandra! 💪

📱 Responsive Ad 📱