Tutorials
Distributed data platforms are not something you can fully learn from documentation alone. The concepts require working code and a real cluster to make sense. These tutorials give you that. You start with a Docker cluster on your laptop, load a real dataset, and write code that applies in production. Each tutorial builds on the last. The hard parts are not skipped.
Source Code Included3-Node Docker ClusterEvery Step Verifiable
Recommended Starting Point
Start a Local Cache Development Cluster
Set up a single-node Ignite 2 or GridGain 8 cluster with Docker Compose for cache-centric development and testing.
Beginner20 minignite2gridgain8
Begin tutorialAll Tutorials
Each tutorial uses the same 3-node Docker cluster and Music Store dataset. Published tutorials link directly to their content. Filter by category or difficulty to find what you need.
Platform
Category
Difficulty
Tutorial
Start a Local Cache Development Cluster
Set up a single-node Ignite 2 or GridGain 8 cluster with Docker Compose for cache-centric development and testing.
Beginner|20 min
Tutorial
Work with the Cache API
Connect a Java thick client to your cluster, create distributed caches, and perform put, get, and bulk operations with IgniteCache using real Chinook Customer data.
Beginner|45 min
Tutorial
Cache Sizing and Expiry
Solve the two invalidation problems that make a cache usable in production. Bound the on-heap tier with LRU eviction, set entry lifetime with JCache expiry policies, and watch the cache manage itself.
Beginner|45 min
Tutorial
Cache-Aside Under Load
Implement cache-aside against a real MariaDB instance, pressure the database with a workload simulator, and measure the read offload as the cache absorbs 95% of customer lookups.
Beginner|60 min
Tutorial
Use Transactions with the Cache API
Group related cache operations into ACID transactions. Choose between pessimistic and optimistic concurrency, configure isolation levels, and use EntryProcessor for atomic mutations.
Intermediate|60 min
Tutorial
Understand How Your Cache Is Distributed
Watch a cache spread 10,000 entries across three nodes and then four. Use the Affinity API to see which node owns each key, learn the vocabulary of partitions and primaries, and establish the mental model every cache user needs.
Beginner|45 min
Tutorial
From Key-Value to SQL: The JOIN Problem
Move beyond client-side joins. Annotate POJOs with @QuerySqlField, run SqlFieldsQuery on cached data, and use colocation for fast cross-cache JOINs.
Intermediate|60 min
Tutorial
Atomic Operations Across Keys: The Transaction Problem
Span partitions with atomic multi-key writes, no cross-shard glue code required. Use OPTIMISTIC + SERIALIZABLE for non-blocking concurrency, and recover from conflicts with a retry-with-backoff loop whose budget bounds unrecoverable contention.
Intermediate|40 min
Tutorial
Compute Where the Data Lives: The Round-Trip Problem
Ship Java closures to the nodes that own the data instead of pulling the data to the client. Measure pull-to-client, broadcast, and affinityCall against the same question on a three-node cluster.
Intermediate|60 min
Tutorial
Beyond Cache: The Persistence Problem
Configure native persistence on the cache, kill the cluster, restart, and watch every entry come back. The cluster becomes the durable store, with no separate database.
Intermediate|60 min
Tutorial
Distributed Primitives: The Coordination Problem
Acquire cluster-wide IgniteAtomicLong, IgniteLock, and IgniteQueue primitives by name. Three JUC-shaped APIs replace the libraries an application would otherwise import to coordinate across processes.
Intermediate|45 min
Tutorial
Real-Time Event Processing: The Streaming Problem
Subscribe to a cache as an event source. Register a server-side filter that drops non-matching updates before they cross the network, and a client-side listener that fires only on the events the application cares about.
Intermediate|60 min
Tutorial
Design Keys for Colocation
Three mechanisms declare cache-to-cache colocation: the @AffinityKeyMapped annotation on a composite key, the AffinityKey wrapper at the call site, and CacheKeyConfiguration on the cache. Run all three against a Customer and Invoice schema, confirm each produces the same placement, and learn how to pick one for a production schema.
Advanced|60 min
Tutorial
Verify Colocation Is Working
Colocation fails silently. Learn the verification toolkit: GridCacheAffinity introspection, SYS.CACHE_GROUPS and SYS.PARTITION_STATES system views, local scan queries, and JOIN correctness tests that prove colocation before you deploy.
Advanced|60 min
Tutorial
Affinity-Aware Compute at Scale
Ship code to the data. Three affinity-aware compute patterns (broadcast with local scan, single-key affinityCall, and the Collection-overload cross-cache affinityCall) measured against pull-to-client at 1,000, 10,000, and 100,000 customers.
Advanced|75 min
Tutorial
When to Break Colocation
Not every cache should be colocated. Teach REPLICATED vs PARTITIONED as a design choice, build a star schema with partitioned facts and replicated dimensions, and understand the cost of setDistributedJoins when the schema cannot avoid cross-partition work.
Advanced|60 min
Need to solve a specific problem?
If you already know the platform and need to complete a task, a guide gives you the direct steps without the learning progression.