Apache Cassandra
Apache Cassandra is a course in the distributed NoSQL database using Cassandra 5.0, from installation, cluster setup and the masterless architecture to data modelling, CQL, security, performance tuning, repair and backup. It suits system and database administrators, developers and anyone who already knows some SQL and wants to run Cassandra with confidence.
- Duration18 hours · 3 days
- FormatOnsite / live online
- Next roundOn request
- CertificateIncluded
Course overview
Systems that take in huge volumes of data all the time, such as IoT device readings, usage history, chat messages or online service logs, need a database that writes fast, scales by adding machines and does not go down when one machine fails. Apache Cassandra meets that need with a masterless architecture in which every node is equal and data is copied to several places, but using Cassandra well means thinking differently from SQL databases right from table design.
This course takes learners through Apache Cassandra 5.0 from the basics to running a cluster. It starts with NoSQL concepts, installing Cassandra with Docker and on Linux, setting up a multi-node cluster and understanding the architecture, replication and read and write paths. Learners then practise query-first data modelling, write CQL, use the Storage Attached Indexes and vector search introduced in 5.0 and connect from an application. The course moves on to operations: security and Dynamic Data Masking, the Unified Compaction Strategy, monitoring and performance tuning, repair, backup and adding or removing nodes, and closes with a capstone that designs and runs a real system. (3 days, 6 hours per day, 18 hours in total, Intermediate level.)
What you’ll gain
- Understand NoSQL databases and choose Cassandra for the right workloads
- Install Apache Cassandra 5.0 and set up a multi-node cluster
- Explain the architecture, replication, gossip and the read and write paths
- Choose the right consistency level for each type of work
- Design query-first data models and create keyspaces and tables
- Write CQL to manage data and search with Storage Attached Indexes and vector search
- Configure security, choose a compaction strategy and tune cluster performance
- Maintain a cluster, including repair, backup and adding, replacing or removing nodes
Who this course is for
- System and database administrators who install and look after Cassandra
- Developers who design tables and write applications that use Cassandra
- Data engineers who work with large volumes of data or time-series data
- Students, teachers and anyone interested in distributed NoSQL databases
Prerequisites
- Basic database use and some knowledge of SQL
- Basic use of the Linux command line or a terminal
- Some Python or Java will help in the application connection labs
- A laptop with at least 16 GB of RAM that can run Docker Desktop, with permission to install software
Curriculum
Course Details
This is the 2026 edition of the Apache Cassandra course, rewritten for Apache Cassandra 5.0, the current stable release. It runs for 3 days, 6 hours per day (18 hours in total, 09:00-16:00), as lectures with labs on a three-node cluster that runs with Docker Compose on the learner's own machine. Intermediate level. It covers the developer's side, with data modelling, CQL, indexes and connecting from applications, and the administrator's side, with installation, security, compaction, performance tuning, repair and backup. Compared with the previous edition it adds Storage Attached Indexes, vector search, the Unified Compaction Strategy, Dynamic Data Masking and guardrails. All tools are open source. Learners take home a lab guide, CQL scripts and the cluster's docker-compose files.
Day 1 NoSQL, Installation and Architecture
Section 1: Introducing NoSQL and Apache Cassandra
- Types of NoSQL database and the CAP theorem
- Workloads that suit Cassandra and those that do not, compared with SQL databases
- Key terms: cluster, data center, node, keyspace, partition and replica
- What is new in Cassandra 5.0 and where Cassandra 6.0 is heading
- Real-world uses such as IoT, messaging and time series
Section 2: Lab: Installing Cassandra 5.0
- Prerequisites: Java 17, machine resources and operating system
- Install with Docker and as a package on Linux
- Key settings in cassandra.yaml and the JVM options files
- Start using cqlsh and check status with nodetool status
- Lab: run the first Cassandra node and create test data
Section 3: Lab: Setting Up a Multi-Node Cluster
- cluster_name, seed nodes and how a new node joins the cluster
- Snitches, data centers and racks with GossipingPropertyFileSnitch
- SimpleStrategy compared with NetworkTopologyStrategy
- Build a three-node cluster with Docker Compose
- Lab: see how data is distributed with nodetool ring and getendpoints
Section 4: The Masterless Architecture
- The ring, tokens, virtual nodes and the partitioner
- Data replication and the replication factor
- The gossip protocol and failure detection
- Hinted handoff and read repair to bring data back in line
- Coordinator nodes and how a request travels through the cluster
Section 5: Lab: Reads, Writes and Consistency
- The write path: commit log, memtable and SSTable, including trie memtables in 5.0
- The read path: Bloom filters, partition index and caches
- Tunable consistency: ONE, QUORUM, LOCAL_QUORUM and ALL
- The R + W > RF rule and its effect on data freshness
- Lab: shut down a node and test reads and writes at several consistency levels
Day 2 Data Modelling and CQL
Section 6: Cassandra Data Modelling Principles
- Design from the application's queries rather than from the data structure
- Partition keys, clustering columns and ordering within a partition
- Partition size, hot partitions and spreading load with bucketing
- Denormalisation and deliberately storing data in several tables
- Lab: design the tables of a chat system from the queries it must support
Section 7: Lab: Keyspaces and Tables
- Create and alter keyspaces with suitable replication
- Create tables with primary keys and clustering order
- CQL data types, collections, user-defined types and counters
- TTL, static columns and writetime, including on collections in 5.0
- Lab: create the schema for an IoT sensor data system
Section 8: Lab: Managing Data with CQL
- INSERT, UPDATE and DELETE and their upsert behaviour
- How tombstones arise and their effect on performance
- Lightweight transactions with IF and the cost to be aware of
- Using batches correctly, and when not to use them
- Lab: write and read sensor data by time range
Section 9: Lab: Indexes, Search and Vector Search
- Why ALLOW FILTERING should be avoided
- Storage Attached Indexes (SAI) for searching on non-key columns
- The vector data type and similarity search with SAI
- Materialized views and triggers: their current status and caveats
- Lab: search data with SAI and find similar text with vectors
Section 10: Lab: Functions and Connecting from Applications
- Built-in functions, the new math functions in 5.0 and aggregates
- User-defined functions and their security considerations
- Connect with the Python or Java driver and use prepared statements
- Load balancing policies, paging and setting consistency in code
- Lab: a small application that writes to and reads from the cluster
Day 3 Operations and Performance Tuning
Section 11: Lab: Securing Cassandra
- Enable authentication and manage roles and permissions
- Dynamic Data Masking to hide sensitive data according to user rights
- The CIDR authorizer to restrict access by network
- Encrypt connections with TLS and enable audit logging
- Lab: create users at several levels and test their permissions
Section 12: Lab: Compaction and Compression
- How compaction works and why it is needed
- STCS, LCS and TWCS compared with the Unified Compaction Strategy in 5.0
- gc_grace_seconds and handling tombstones
- Choose compression and chunk size to suit the workload
- Lab: change the compaction of a time-series table and measure the result
Section 13: Lab: Monitoring and Performance Tuning
- Monitor with nodetool tpstats, tablestats and virtual tables
- Metrics through JMX and forwarding them to a monitoring system
- Tune the JVM, garbage collector and heap
- Tune the operating system, disks and guardrails
- Lab: load-test with cassandra-stress and tune the results
Section 14: Lab: Maintaining the Cluster
- Add, replace, move and remove nodes safely
- Full and incremental repair and planning repair schedules
- Backups with snapshots and incremental backups, and restoring them
- Change Data Capture for passing data on to other systems
- Lab: remove a node and add a new one without stopping the system
Section 15: Workshop: Capstone Design and Operations
- Choose a brief such as an IoT data store or a messaging system
- Design the data model and keyspace on a three-node cluster
- Load-test, simulate a node failure and analyse the results
- Present the work, review it together and wrap up with a pre-production checklist
Schedule & training options
For individuals — public rounds
No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770
For organisations — in-house / private
- Tailor the content to your team’s tools and projects
- Your dates, at your office or live online
- Quotation with tax ID for procurement
Instructors
Frequently asked questions
How does Cassandra's masterless architecture work?
Cassandra arranges all nodes as equals in a ring with no master, and any node can accept reads and writes. Data is spread across nodes by the hash of its partition key and copied according to the replication factor. Nodes share their status through the gossip protocol, so there is no single point of failure, and you can add nodes to scale without taking the service down.
What is tunable consistency in Cassandra?
Tunable consistency lets you choose, per request, how many replicas must acknowledge a read or write. ONE is fastest but may return stale data, QUORUM needs a majority, LOCAL_QUORUM needs a majority within one data center and ALL needs every replica. If the replicas used for reads plus those used for writes exceed the replication factor, such as QUORUM for both, reads always return the latest data.
What is a Storage Attached Index (SAI) in Cassandra 5.0?
SAI is a new index type in Cassandra 5.0 that is attached to each node's SSTables, making searches on non-partition-key columns more efficient than the old secondary indexes and SASI, which is no longer recommended. It supports numeric ranges, text and the vector data type for similarity search. Tables should still be designed around the main queries first, with SAI added for more flexible searching.
Who is the Apache Cassandra course for, and what should I know beforehand?
It suits system and database administrators, developers who design tables and write applications that use Cassandra, data engineers who work with large data volumes, and students and teachers interested in distributed NoSQL databases. You should be able to work with databases at a basic level, know some SQL and use the command line. Some Python or Java will help in the application connection labs.
What will I be able to do after the Apache Cassandra course?
You will be able to install Cassandra 5.0 and set up a multi-node cluster, explain its architecture, replication and read and write paths, choose suitable consistency levels, design query-first keyspaces and tables, write CQL, search with SAI and vector search, connect from an application, configure security, choose a compaction strategy, tune performance and maintain the system with repair, backup and adding or removing nodes. Participants who complete the training receive a Certificate of Completion with its own number, which can be verified online.
Can the Apache Cassandra course be run in-house for our team?
Yes. It can be run in-house for your team, with examples adapted to your own work, such as designing tables around the query patterns of a system your team is building. You can request a quotation from this page, or contact us on LINE @itgenius or by phone on 02-570-8449.