Getting Started

Installation and Upgrade

Developer’s Guide

Administrator’s Guide

Performance and Troubleshooting Guide

GridGain Control Center

Apache Ignite Management and Monitoring Guide

RESTful Web Services with Spring and Apache Ignite

Microservice With Micronaut and Apache Ignite

Serverless Computing with Azure Functions

SSL Configuration Guide

What Is Ignite?

What Is Gridgain?

Quick Start Overview

Deployment Modes

Installing Using ZIP Archive

Installing Using Docker

Installing on z/OS

Manual Install on Amazon EC2

Amazon EKS Deployment

GridGain on Azure

Azure Kubernetes Service Deployment

Google Kubernetes Engine

Operator Overview

Quick Start Guide

Operator Download

Operator Configuration

Troubleshooting

RedHat OpenShift Deployment

Rolling Upgrades

Versioning and Support Lifecycle

Understanding Configuration

Configuring Logging

Starting and Stopping Nodes

TCP/IP Discovery

ZooKeeper Discovery

Discovery in the Cloud

Network Configuration

Connecting Client Nodes

Running Client Nodes Behind NAT

Data Partitioning

Affinity Colocation

Memory Architecture

Configuring Data Regions

Eviction Policies

Memory Quotas for SQL Queries

Cache Configuration

Configuring Partition Backups

Atomicity Modes

On-Heap Caching

Managing Data Distribution

Data Compression

Ignite Persistence

External Storage

Implementing Custom Cache Store

Baseline Topology

Data Rebalancing

Historical Rebalancing

Partition Loss Policy

Basic Cache Operations

Working with Binary Objects

Using Scan Queries

Using Continuous Queries

Performing Transactions

Understanding Schemas

Defining Indexes

Distributed Joins

SQL Transactions

Custom SQL Functions

JDBC Client Driver

Multiversion Concurrency Control

SQL and Key-Value Usage

Distributed Computing API

Executor Service

Fault Tolerance

Colocating Computations with Data

Enabling and Listenting to Events

Peer Class Loading

Handling Exceptions

Thin Clients Overview

Java Thin Client

.NET Thin Client

C++ Thin Client

Python Thin Client

PHP Thin Client

Node.js Thin Client

Connection String and DSN

Querying and Modifying Data

Machine Learning

Partition Based Dataset

Linear Regression

K-Means Clustering

Genetic Algorithms

Multilayer Perceptron

k-NN Classification

k-NN Regression

SVM Binary Classification

SVM Multi-class Classification

Model Cross Validation

Logistic Regression

Gradient Boosting

ANN (Approximate Nearest Neighbor)

Model Importing

Configuration Options

Deployment Options

Standalone Nodes

Java Services Execution

.NET Platform Cache

Cross-Platform Support

Platform Interoperability

Remote Assembly Loading

Troubleshooting

ASP.NET Output Caching

ASP.NET Session State Caching

Entity Framework 2nd Level Cache

Snapshots and Recovery

Full and Incremental Snapshots

Point-in-Time Recovery

Network Backups

Heterogeneous Recovery

Snapshots Management Tool

Configuring Replication

Managing and Monitoring

Defragmentation

Authorization and Permissions

Securing Data Deserialization

Transparent Data Encryption

Monitoring and Auditing Web Console Activity

Implementing Custom Authenticator

Configuring Metrics

Capacity Planning

Persistence Defragmentation

Empirical Estimation of Disk Capacity Usage

Conflict Resolution

Migrating from Oracle Coherence

General Performance Tips

Memory and JVM Tuning

Persistence Tuning

Thread Pools Tuning

Troubleshooting and Debugging

SQL Reference Overview

SQL Conformance

Data Definition Language (DDL)

Data Manipulation Language (DML)

Operational Commands

Aggregate functions

Numeric Functions

String Functions

Date and Time Functions

System Functions

Certified Kafka Connector

Kafka Connector Quick Start

Kafka Connector Architecture

Kafka Connector Data Schema

Kafka Connector Configuration

Kafka Connector Monitoring

GridGain vs. Apache Ignite Kafka Connector

Example: Persisting Ignite Data in Relational Database with Kafka Connector

Example: Ignite Data Replication with Kafka Connector

GoldenGate Replication

GridGain Handler

Data Source Operation Handler

GoldenGate Conflicts Resolution

Deep Learning with TensorFlow

Distributed Training

Command Line Tool

Getting Started

Data Loading and Synchronization

Loading and Synchronizing with Hive

Loading Data with Spark

Synchronizing Data Using Apache Sqoop

Cross-Database Queries

Installation and Upgrade

Deployment Modes
Installing Using ZIP Archive
Installing Using Docker
Installing on z/OS
AWS
Microsoft Azure
- GridGain on Azure
- Azure Kubernetes Service Deployment
Google Kubernetes Engine
GridGain Operator
RedHat OpenShift Deployment
Rolling Upgrades
Versioning and Support Lifecycle
Licensing

On this page:

Documentation Feedback

Trainings and Tech Talks

Consulting Resources