Cassandra 3.x High Availability - Second Edition电子书

Cassandra 3.x High Availability

Cassandra 3.x High Availability - Second Edition

Credits

About the Author

About the Reviewer

www.PacktPub.com

eBooks, discount offers, and more

Why subscribe?

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Cassandras Approach to High Availability

Introducing the ACID properties

Monolithic simplicity

Scaling consistency - the master-slave model

Using sharding to scale writes

Handling the death of the leader

Breaking with tradition - Cassandra's alternative

Cassandra's peer-to-peer approach

Hashing to the rescue

Replication across the cluster

Replication across data centers

The consistency continuum

The CAP theorem

Summary

2. Data Distribution

Hash table fundamentals

Distributed hash tables

Consistent hashing

How it works

Token assignment

Manually assigned tokens

Vnodes

How vnodes improve availability

Adding and removing nodes

Node rebuild

Heterogeneous nodes

Partitioners

Hotspots

A time-series example

Summary

3. Replication

The replication factor

Replication strategies

SimpleStrategy

NetworkTopologyStrategy

Snitches

Maintaining the replication factor when a node fails

Consistency conflicts

Consistency levels

Repairing data

Balancing the replication factor with consistency

Summary

4. Data Centers

Use cases for multiple data centers

Live backup

Failover

Load balancing

Geographic distribution

Online analysis

Analysis using Hadoop

Analysis using Spark

Data center setup

RackInferringSnitch

PropertyFileSnitch

GossipingPropertyFileSnitch

Cloud snitches

Replication across data centers

Setting replication factors

Consistency in a multiple data center environment

Anatomy of a replicated write

Achieving stronger consistency between data centers

Summary

5. Scaling Out

Choosing the right hardware configuration

Scaling out versus scaling up

Growing your cluster

Adding nodes without vnodes

Adding nodes with vnodes

Adding a data center

How to scale up

Upgrading in place

Scaling up using data center replication

Removing nodes

Removing nodes within a data center

Decommissioning a data center

Other data migration scenarios

Snitch changes

Summary

6. High Availability Features in the Native Java Client

Thrift versus the native protocol

Setting up the environment

Connecting to the cluster

Executing statements

Prepared statements

Batched statements

Caution with batches

Handling asynchronous requests

Running queries in parallel

Load balancing

Failing over to a remote data center

Downgrading consistency level

Defining your own retry policy

Token awareness

Tying it all together

Falling back to QUORUM

Summary

7. Modeling for Availability

How Cassandra stores data

Implications of log-structured storage

Understanding compaction

Size-tiered compaction

Leveled compaction

Time-window compaction

CQL under the hood

Single primary key

Compound keys

Partition keys

Clustering columns

Composite partition keys

The importance of the storage model

Understanding queries

Query by key

Range queries

Embracing denormalization

Denormalizing using collections

Sets

Lists

Maps

Denormalizing with materialized views

Working with time series data

Designing for immutability

Modeling sensor data

The queries

Time-based ordering

Using a sentinel value

Satisfying our queries

When time is all that matters

Working with geospatial data

Summary

8. Anti-Patterns

Multi-key queries

Secondary indices

Secondary indices under the hood

Improvements with SASI

Distributed joins

Deleting data

Garbage collection

Resurrecting the dead

The problem with tombstones

Expiring columns

TTL anti-patterns

When null does not mean empty

Cassandra is not a queue

Unbounded row growth

Summary

9. Failing Gracefully

Knowledge is power

Monitoring via JMX

Using OpsCenter

Choosing a management toolset

Logging

Cassandra logs

Garbage collector logs

Monitoring node metrics

Thread pools

Table statistics

Finding latency outliers

Communication metrics

When a node goes down

Marking a downed node

Handling a downed node

Handling slow nodes

Backing up data

Taking a snapshot

Incremental backups

Restoring from a snapshot

Summary