# DevHub

> Hands-on tutorials and how-to guides for building applications with Apache Ignite and GridGain.

DevHub is a developer learning site for Apache Ignite (2.x and 3.x) and GridGain (8.x and 9.x). Content follows the Diataxis framework: learning-oriented tutorials and task-oriented how-to guides. All content is free and open. No registration or login is required.

## Start here
- Getting started: https://devhub.gridgain.com/get-started
- Data architecture guide: https://devhub.gridgain.com/data-architecture-guide
- Tutorials index: https://devhub.gridgain.com/tutorials
- How-to guides index: https://devhub.gridgain.com/guides
- Learning paths: https://devhub.gridgain.com/learning-paths

## Products covered
- Apache Ignite 2.x: cache-centric architecture
- Apache Ignite 3.x: schema-driven architecture
- GridGain 8.x: enterprise platform built on Apache Ignite 2
- GridGain 9.x: enterprise platform built on Apache Ignite 3

## Tutorials
- [Start Your Local Development Cluster](https://devhub.gridgain.com/docs/tutorials/start-local-cluster/): Set up a 3-node cluster with Docker Compose, load the Music Store sample dataset, and verify it with SQL queries.
- [Create Tables and Query Data with SQL](https://devhub.gridgain.com/docs/tutorials/query-music-store-sql/): Create tables with distribution zones, insert data, and run SELECT, JOIN, and aggregation queries against the Music Store schema.
- [Connect with the Java Thin Client](https://devhub.gridgain.com/docs/tutorials/connect-java-thin-client/): Build a Java application that connects to the cluster, creates tables, inserts records, and runs queries using the thin client.
- [Work with RecordView and KeyValueView](https://devhub.gridgain.com/docs/tutorials/recordview-keyvalueview/): Master both Table API view types: CRUD operations, bulk processing, cache-aside patterns, and the unified storage model that eliminates separate caching infrastructure.
- [Use Transactions](https://devhub.gridgain.com/docs/tutorials/transactions-ignite3/): Perform multi-table ACID transactions with explicit and functional patterns. Handle conflicts, rollbacks, and colocation-aware transaction scope.
- [Stream Data with the Data Streamer API](https://devhub.gridgain.com/docs/tutorials/data-streaming/): Build a high-throughput data pipeline that streams hundreds of thousands of records into Ignite using the DataStreamer API with backpressure handling, configuration tuning, and multi-table referential integrity.
- [Design a Schema for Distributed SQL](https://devhub.gridgain.com/docs/tutorials/schema-distributed-sql/): Analyze access patterns, build colocation chains, choose distribution zones, and verify your schema design with system views and EXPLAIN plans.
- [Implement Schema with Java Annotations](https://devhub.gridgain.com/docs/tutorials/schema-java-annotations/): Translate schema design decisions into Java annotations, map POJOs to distributed tables, and configure colocation keys programmatically.
- [Choose the Right Data Access Pattern](https://devhub.gridgain.com/docs/tutorials/data-access-patterns/): Apply a three-question decision framework to select KeyValueView, RecordView, or SQL at every call site. Build a data access layer where schema design, operation shape, and safety requirements determine the API.
- [Start a Local Cache Development Cluster](https://devhub.gridgain.com/docs/tutorials/start-local-cache-cluster/): Set up a single-node Ignite 2 or GridGain 8 cluster with Docker Compose for cache-centric development and testing.
- [Work with the Cache API](https://devhub.gridgain.com/docs/tutorials/work-with-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.
- [Cache Sizing and Expiry](https://devhub.gridgain.com/docs/tutorials/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.
- [Cache-Aside Under Load](https://devhub.gridgain.com/docs/tutorials/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.
- [Use Transactions with the Cache API](https://devhub.gridgain.com/docs/tutorials/cache-transactions/): Group related cache operations into ACID transactions. Choose between pessimistic and optimistic concurrency, configure isolation levels, and use EntryProcessor for atomic mutations.
- [Understand How Your Cache Is Distributed](https://devhub.gridgain.com/docs/tutorials/understand-cache-distribution/): 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.
- [From Key-Value to SQL: The JOIN Problem](https://devhub.gridgain.com/docs/tutorials/from-keyvalue-to-sql/): Move beyond client-side joins. Annotate POJOs with @QuerySqlField, run SqlFieldsQuery on cached data, and use colocation for fast cross-cache JOINs.
- [Atomic Operations Across Keys: The Transaction Problem](https://devhub.gridgain.com/docs/tutorials/cross-partition-transactions/): 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.
- [Compute Where the Data Lives: The Round-Trip Problem](https://devhub.gridgain.com/docs/tutorials/colocated-compute/): 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.
- [Beyond Cache: The Persistence Problem](https://devhub.gridgain.com/docs/tutorials/native-persistence-beyond-cache/): 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.
- [Distributed Primitives: The Coordination Problem](https://devhub.gridgain.com/docs/tutorials/distributed-data-structures/): 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.
- [Real-Time Event Processing: The Streaming Problem](https://devhub.gridgain.com/docs/tutorials/continuous-queries-streaming/): 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.
- [Design Keys for Colocation](https://devhub.gridgain.com/docs/tutorials/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.
- [Verify Colocation Is Working](https://devhub.gridgain.com/docs/tutorials/verify-colocation/): 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.
- [Affinity-Aware Compute at Scale](https://devhub.gridgain.com/docs/tutorials/affinity-aware-compute/): 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.
- [When to Break Colocation](https://devhub.gridgain.com/docs/tutorials/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.
- [Build a RESTful Web Service with Spring Boot and Ignite](https://devhub.gridgain.com/docs/tutorials/build-rest-service-spring/): Build a Spring Boot REST service backed by Apache Ignite as an in-memory database, using Spring Data repositories over an Ignite cluster.
- [Build Microservices with Micronaut and Ignite](https://devhub.gridgain.com/docs/tutorials/build-microservices-micronaut/): Build a Micronaut microservice backed by Apache Ignite, query distributed data over HTTP, and deploy it in Docker.
- [Serverless Computing with Ignite and Azure Functions](https://devhub.gridgain.com/docs/tutorials/serverless-azure-functions/): Combine serverless and in-memory computing: call an Apache Ignite cluster from Azure Functions to serve data without managing infrastructure.
- [GridGain JSON Basics](https://devhub.gridgain.com/docs/tutorials/gridgain-json-basics/): Store, query, and index JSON data with GridGain 8 SQL functions (Enterprise/Ultimate 8.9+), including JSON_VALUE and JSON_QUERY.
- [GridGain 8 Management and Monitoring Guide](https://devhub.gridgain.com/docs/tutorials/gridgain8-management-monitoring/): Monitor and manage a GridGain 8 cluster in production with Control Center: storage and cluster health, alerts, performance tracing, and backups.

## How-to guides
- [Start a Cluster with Docker Compose](https://devhub.gridgain.com/docs/guides/start-cluster-docker-compose): Start a 3-node development cluster on your laptop. One command, two minutes, a running topology with a client connection endpoint on localhost:10800.
- [Manage Cluster Lifecycle with the REST API](https://devhub.gridgain.com/docs/guides/manage-cluster-rest-api): Initialize, monitor, and shut down your cluster using the REST API. Check node status, inspect topology, and verify partition distribution with curl and jq.
- [Configure Logging for the Java Thin Client](https://devhub.gridgain.com/docs/guides/configure-java-client-logging): Configure logging for the Java thin client using java.util.logging, Logback, or Log4j2.
- [Work with the Ignite CLI](https://devhub.gridgain.com/docs/guides/work-with-ignite-cli): Connect to a cluster, execute SQL, and manage cluster state from the command line.
- [Choose a Partition Count for Your Workload](https://devhub.gridgain.com/docs/guides/choose-partition-count): The default is 1,024. More partitions means finer rebalance granularity and more metadata overhead. Fewer means coarser rebalance and potential hot partitions. Walk through the decision for cluster sizes from 3 to 30 nodes and cache sizes from 1GB to 1TB.
- [Debug a Hot Partition](https://devhub.gridgain.com/docs/guides/debug-hot-partition): One node is pegged, the others are idle. Diagnose key skew, whether natural (timestamp keys, autoincrement keys) or accidental (a bug in the affinity mapper). Apply the fix: salt the key, change the affinity function, or redesign the schema.
- [Encrypt Cluster Traffic with Istio mTLS on Kubernetes](https://devhub.gridgain.com/docs/guides/encrypt-cluster-traffic-istio): Enforce mutual TLS across inter-node, thin-client, and external traffic with an Istio service mesh. No keystores, no SSL configuration on the cluster itself.
- [Encrypt Inter-Node Cluster Traffic with Linkerd on Kubernetes](https://devhub.gridgain.com/docs/guides/encrypt-inter-node-traffic-linkerd): Encrypt discovery and communication traffic between cache nodes with Linkerd automatic mTLS. One annotation per pod, no keystores, no cluster configuration changes.
- [Monitor GridGain Clusters with New Relic](https://devhub.gridgain.com/docs/guides/monitor-gridgain-new-relic): Export GridGain 8 metrics and logs to New Relic using the OpenTelemetry Java agent, then visualize them with a prebuilt dashboard.
- [Configure SSL/TLS/HTTPS Security](https://devhub.gridgain.com/docs/guides/configure-ssl-tls-https): Set up SSL/TLS to secure GridGain node-to-node, thin-client (ODBC/JDBC), and HTTPS REST traffic with a self-signed certificate authority.
- [Integrate Control Center with Okta](https://devhub.gridgain.com/docs/guides/integrate-control-center-okta): Configure GridGain Control Center to authenticate users through an Okta OpenID Connect authorization server, using a free Okta developer account.
- [Integrate Control Center with LDAP](https://devhub.gridgain.com/docs/guides/integrate-control-center-ldap): Authenticate and authorize GridGain Control Center users against an LDAP directory, using an OpenLDAP server, group-based roles, and an application.yaml configuration.
- [Integrate Control Center with PingOne](https://devhub.gridgain.com/docs/guides/integrate-control-center-pingone): Configure PingOne SSO with GridGain 8 Control Center to enforce role-based access control and validate cluster action permissions through OIDC.
- [Authenticate to Control Center with Kerberos](https://devhub.gridgain.com/docs/guides/authenticate-control-center-kerberos): Set up GridGain 8 Control Center to authenticate users with Kerberos through Keycloak, using OAuth2, a KDC, and browser SPNEGO.
- [Monitor GridGain 8 with Prometheus and Grafana](https://devhub.gridgain.com/docs/guides/monitor-gridgain8-prometheus-grafana): Export GridGain 8 metrics to Prometheus with the OpenCensus exporter, then connect Prometheus to Grafana and import a prebuilt dashboard.
- [Export Data to Apache Iceberg on AWS](https://devhub.gridgain.com/docs/guides/export-data-iceberg-aws): Batch-export GridGain 8 data to an Apache Iceberg table in AWS Glue and Amazon S3 with COPY FROM ... INTO, query it in Athena, then import it back.
- [Configure NUMA-aware Memory Allocation](https://devhub.gridgain.com/docs/guides/configure-numa-memory-allocation): Enable NUMA-aware memory allocation in GridGain 8 so data regions optimize memory access patterns on multiprocessor Linux hardware for higher performance.
- [Deploy Code with UriDeploymentSpi](https://devhub.gridgain.com/docs/guides/deploy-code-uri-deployment-spi): Deploy and redeploy Java compute tasks, services, and POJOs to a running GridGain 8 cluster without restarting nodes, using UriDeploymentSpi.
- [Run the GridGain Kafka Connector on Amazon MSK](https://devhub.gridgain.com/docs/guides/integrate-kafka-connector-msk): Run Kafka on Amazon MSK with the GridGain Kafka Connector on EC2 to source and sink data between MSK and a GridGain cluster in AWS.
- [Monitor GridGain 9 with Prometheus and Grafana](https://devhub.gridgain.com/docs/guides/monitor-gridgain9-prometheus-grafana): Export GridGain 9 metrics over OTLP to Prometheus, then connect Grafana to visualize cluster performance with a prebuilt dashboard.
- [Build Retrieval-Augmented Generation with GridGain and LangChain](https://devhub.gridgain.com/docs/guides/build-rag-langchain): Use GridGain 8 distributed vector search as the unified backend for a LangChain RAG application, with a working laptop-recommendation demo.
- [Build a Low-Code RAG Application with GridGain and Langflow](https://devhub.gridgain.com/docs/guides/build-lowcode-rag-langflow): Build a visual RAG application on Langflow, using GridGain 8 vector search with HNSW as the vector store and chat memory, no code required.
- [Build a Machine Learning Feature Store with GridGain and Feast](https://devhub.gridgain.com/docs/guides/ml-feature-store-feast): Use GridGain 8 as a low-latency Feast online store for real-time machine learning feature serving, illustrated with a CGM glucose-prediction demo.
- [Cache Machine Learning Predictions with GridGain and BigQuery](https://devhub.gridgain.com/docs/guides/cache-ml-predictions-bigquery): Serve BigQuery ML predictions with sub-millisecond latency by caching them in GridGain 8, using a Google Analytics product recommendation demo as the reference.

## Learning paths
- [Distributed SQL Foundations](https://devhub.gridgain.com/learning-paths#foundations): From a bare laptop to working code against a running cluster. This path covers cluster setup, SQL fundamentals with a real dataset, connecting the Java thin client, typed data access through RecordView and KeyValueView, and multi-table ACID transactions.
- [Schema Design for Distributed SQL](https://devhub.gridgain.com/learning-paths#schema-design): Distributed SQL behaves differently from a single-node RDBMS. This path teaches you to analyze access patterns, build colocation chains, choose distribution zones, translate those decisions into Java annotations, pick the right data access pattern for each use case, and evolve schemas on a running cluster.
- [Data Pipeline APIs](https://devhub.gridgain.com/learning-paths#data-pipeline): High-throughput data ingestion with the Data Streamer API and distributed compute that runs where data lives. This path covers the two major data movement APIs: streaming data into the cluster and processing it on the nodes that hold it.
- [Caching and Key-Value Access](https://devhub.gridgain.com/learning-paths#caching): Use the distributed platform as a high-performance caching layer. This path starts with the KeyValueView and RecordView APIs, builds up to data structure patterns that replace traditional cache systems, and finishes with the cache-aside integration pattern for existing applications.
- [Cache-Centric Foundations](https://devhub.gridgain.com/learning-paths#foundations-cache): From a bare laptop to a working cache-aside implementation backed by real benchmark data. Start a single-node Docker cluster, learn the cache API, connect Java clients, then add a MariaDB database and see the cache offload read pressure under sustained production-like workload.
- [Beyond Key-Value: When Caching Isn't Enough](https://devhub.gridgain.com/learning-paths#beyond-key-value): For developers whose caching layer has created new challenges. Covers SQL-on-cache queries, cross-key ACID transactions, colocated compute, cache-store consistency patterns, distributed data structures, and real-time event processing.
- [Design for Data Locality](https://devhub.gridgain.com/learning-paths#data-locality): Affinity and data locality are the defining design concerns on Apache Ignite 2 and GridGain 8. Design keys for colocation, verify colocation at runtime, write affinity-aware compute that scales, and learn when to deliberately break colocation for reference data.

## Notes
- All tutorials use a standardized 3-node Docker cluster as the development environment.
- Tutorials and guides cover both architecture generations; code tabs switch between cache-centric (Ignite 2 / GridGain 8) and schema-driven (Ignite 3 / GridGain 9).

## Index
- Sitemap: https://devhub.gridgain.com/sitemap.xml