Declaration: DataStax® is a registered trademark of DataStax, Inc. Apache®, Apache Cassandra®, Cassandra®, and the Apache feather logo are trademarks of The Apache Software Foundation (ASF). This course material is not affiliated with, endorsed by, or sponsored by DataStax, Inc. or the ASF.

Additional Material

• Study Material [PDF] eBook: Please download the PDF book (200 pages, study guide) as a companion resource for your certification exam preparation. The download link is provided in the Resources section of Practice Paper 1, Question 1. It is must you go through this book.

Master Apache Cassandra on Kubernetes — Exam-Focused Practice Tests (Zero Fluff)

Become job-ready for operating Apache Cassandra® on Kubernetes with timed practice tests that mirror real exam difficulty and real production incidents. You’ll drill exactly what matters: cass-operator for lifecycle management, K8ssandra for the full stack, Medusa for backups/restores, Reaper for automated repairs, Prometheus & Grafana for observability, and Stargate APIs (REST, GraphQL, Document) for secure app access.

Why this course (and why now)

• Practice-first design: exam-style questions with short, surgical explanations.

• Production realism: YAML/Helm values, kubectl output, CRDs, failure modes, runbooks.

• Speed training: timed/untimed modes, target scoring, per-domain analytics to close gaps.

• Always actionable: every explanation tells you what to do on a cluster and why.

You’ll drill (exam scope, hands-on outcomes)

• Deploy & scale Cassandra on K8s: StatefulSets, PVC/StorageClass selection, liveness/readiness probes, headless Services.

• cass-operator: cluster create/scale, rack/zone topology, rolling upgrades, node replacement, safe drains.

• K8ssandra: opinionated provisioning, day-2 operations, component wiring (Reaper, Medusa, Prometheus, Grafana, Stargate).

• Medusa: full/incremental backups, S3/GCS/MinIO targets, PITR, restore validation, recovery drills.

• Reaper: repair strategies, intensity/parallelism tuning, schedule design, error handling, safety rails.

• Observability: Prometheus metrics, Grafana dashboards, actionable alerts, SLOs for latency/availability.

• Security: TLS (node-node, clientnode), Secrets, RBAC, ingress/port-forwarding patterns, least-privilege.

• Stargate APIs: REST/GraphQL/Document access patterns, auth, read/write paths, troubleshooting.

• Performance & reliability: compaction, JVM/GC, resource requests/limits, anti-patterns to avoid under load.

How the practice tests work

1. Question → Best answer → Why not the others in 60–120 words—quick to read, easy to retain.

2. Mini-labs inside explanations: copy-paste commands and helm values to try locally.

3. Focus mode: re-quiz weak domains (backups, repairs, observability, security) until stable.

4. Score goals: iterate until your average is 10–15% above your target pass mark.

Realistic scenarios you’ll face (and solve)

• Rolling upgrade goes sideways: drain, decommission, replace node with correct topology keys.

• Backups exist but restores fail: diagnose Medusa storage paths, credentials, snapshot metadata, PITR windows.

• Read latency spikes: identify compaction backlog, heap pressure, pod CPU throttling, mis-sized requests/limits.

• Repairs overload cluster: tame Reaper intensity/parallelism; isolate tables; schedule for off-peak windows.

• TLS breaks connectivity: verify keystores, truststores, SANs; rotate certs without downtime.

• Missing metrics or empty dashboards: fix scrape configs, relabeling, namespaces, ServiceMonitors.

• Ingress vs. port-forward: pick the right exposure pattern for ops vs. app access; lock it down with RBAC.

Troubleshooting matrix (what you’ll internalize)

• Pod restarts, disk pressure, node affinity, gossip issues, hinted handoff, tombstone explosions, repair conflicts, schema mismatches, and storage throttling—mapped to concrete kubectl/helm/Cassandra steps you can execute under pressure.

DR & multi-region playbook

• Design for recovery: snapshot cadence, retention, encryption, location strategy.

• Validate restore: table-level checks, repair post-restore, client re-pointing, consistency levels.

• Failover patterns: topology keys, RF choices, traffic steering, read/write safety during incidents.

Who this is for

DevOps engineers, SREs, DBAs, platform/infrastructure teams, backend developers integrating via Stargate, and architects building high-availability, low-latency NoSQL on Kubernetes. Ideal for VM→K8s migrations and K8ssandra/Cassandra operations certification prep.

Requirements

No strict prerequisites. Basic CLI helps. Optional: Docker Desktop or local K8s to try the embedded mini-labs. Everything else is inside the tests and explanations.

What you’ll leave with

• Confidence to deploy, monitor, back up, restore, and repair Cassandra on Kubernetes.

• Rehearsed responses to the exam’s trickiest real-world scenarios.

• A lean study path that avoids theory overload and maximizes exam-ready execution.

Enroll now to pressure-test your knowledge with current, exam-level practice tests—short explanations, real commands, zero fluff.

Who this course is for:

• DevOps engineers and SREs who need to deploy and operate Apache Cassandra on Kubernetes for cloud-native workloads.
• Database administrators transitioning to Cassandra operations on K8s (cass-operator, K8ssandra, Medusa, Reaper).
• Platform and infrastructure engineers building a scalable, highly available NoSQL data platform on Kubernetes.
• Backend/Java developers who want hands-on practice using Stargate APIs (REST, GraphQL, Document) to integrate apps with Cassandra.
• Cloud architects designing production-grade Cassandra clusters with observability via Prometheus & Grafana.
• Data engineers seeking real-world Cassandra + Kubernetes skills for performance, capacity planning, and reliability.
• Teams migrating from VM/bare-metal Cassandra to containerized clusters with automated backup & repair.
• Engineers preparing for Cassandra/K8ssandra operations certifications and wanting exam-style practice tests.
• Kubernetes practitioners who want practical StatefulSet, storage, security (TLS/RBAC), and networking experience for databases.
• Startups and enterprises standardizing on GitOps-friendly Cassandra operations and disaster recovery on K8s.
• Site reliability teams implementing runbooks for node replacement, rolling upgrades, and incident response.
• Developers building low-latency, high-throughput microservices backed by Cassandra on Kubernetes.
• Observability and reliability engineers who need dashboards, alerts, and SLOs for Cassandra clusters.
• IT professionals upskilling to cloud-native data operations and modern NoSQL practices.
• Motivated beginners with basic CLI comfort who want a guided, end-to-end path into Cassandra on Kubernetes.