<!--
 ▄▄▄       ██▓███   ▄▄▄       ▄████▄   ██░ ██ ▓█████     ██▓  ▄████  ███▄    █  ██▓▄▄▄█████▓▓█████
▒████▄    ▓██░  ██▒▒████▄    ▒██▀ ▀█  ▓██░ ██▒▓█   ▀    ▓██▒ ██▒ ▀█▒ ██ ▀█   █ ▓██▒▓  ██▒ ▓▒▓█   ▀
▒██  ▀█▄  ▓██░ ██▓▒▒██  ▀█▄  ▒▓█    ▄ ▒██▀▀██░▒███      ▒██▒▒██░▄▄▄░▓██  ▀█ ██▒▒██▒▒ ▓██░ ▒░▒███
░██▄▄▄▄██ ▒██▄█▓▒ ▒░██▄▄▄▄██ ▒▓▓▄ ▄██▒░▓█ ░██ ▒▓█  ▄    ░██░░▓█  ██▓▓██▒  ▐▌██▒░██░░ ▓██▓ ░ ▒▓█  ▄
 ▓█   ▓██▒▒██▒ ░  ░ ▓█   ▓██▒▒ ▓███▀ ░░▓█▒░██▓░▒████▒   ░██░░▒▓███▀▒▒██░   ▓██░░██░  ▒██▒ ░ ░▒████▒
 ▒▒   ▓▒█░▒▓▒░ ░  ░ ▒▒   ▓▒█░░ ░▒ ▒  ░ ▒ ░░▒░▒░░ ▒░ ░   ░▓   ░▒   ▒ ░ ▒░   ▒ ▒ ░▓    ▒ ░░   ░░ ▒░ ░
  ▒   ▒▒ ░░▒ ░       ▒   ▒▒ ░  ░  ▒    ▒ ░▒░ ░ ░ ░  ░    ▒ ░  ░   ░ ░ ░░   ░ ▒░ ▒ ░    ░     ░ ░  ░
  ░   ▒   ░░         ░   ▒   ░         ░  ░░ ░   ░       ▒ ░░ ░   ░    ░   ░ ░  ▒ ░  ░         ░
      ░  ░               ░  ░░ ░       ░  ░  ░   ░  ░    ░        ░          ░  ░              ░  ░
-->

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">

    <link rel="canonical" href="https://ignite.apache.org/use-cases/in-memory-data-grid.html"/>
    <!--#include virtual="/includes/scriptshead.html" -->

    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <meta name="description"
          content="The Apache Ignite® in-memory data grid accelerates and scales out databases, services, and APIs and supports key-value, ANSI SQL, and machine learning APIs"/>

    <title>In-Memory Data Grid - Apache Ignite</title>

    <!--#include virtual="/includes/styles.html" -->

    
</head>
<body>
<!--#include virtual="/includes/header.html" -->
<article>
    <header>
        <div class="container">
            <h1><strong>In-Memory Data Grid</strong> with Apache Ignite</h1>
        </div>
    </header>
    <div class="container">

        <p>
            Apache Ignite can be used as an in-memory data grid that accelerates and scales your existing databases and
            data stores. The grid supports key-value and ANSI SQL APIs, ACID transactions, co-located processing,
            and machine learning libraries. As an in-memory data grid, Ignite is frequently used to increase the
            performance and scalability of real-time applications, to support <a href="/use-cases/high-performance-computing.html">
            high-performance computing</a>, and to cache data that is scattered across databases.
        </p>
        <img class="img-fluid diagram-right" src="/images/svg-diagrams/data_grid.svg" alt="In-Memory Data Grid with Apache Ignite" width="555" height="600" />
        
        <h2>What is an In-Memory Data Grid?</h2>

        <p>
            An in-memory data grid is an advanced read-through/write-through cache that is deployed on top of multiple databases.
            The grid supports various APIs, such as SQL, compute, and key-value. Applications write to and read from the
            grid, and the grid propagates changes to the underlying data stores in a consistent way.
        </p>
        <p>
            With Ignite, your applications can utilize multiple APIs for data processing. Key-value and SQL queries
            enable you to request, join, and group distributed datasets. Compute and machine-learning APIs execute
            logic close to the data, thus eliminating expensive data shuffling over the network.
        </p>

        <h2>IGNITE AS AN IN-MEMORY DATA GRID AND EXTERNAL DATABASES</h2>

        <p>
            Ignite can improve the performance and scalability of most external databases and data stores (such as RDBMS,
            NoSQL, and  Hadoop) by sliding in as an in-memory data grid between the application and the database layers.
            When the application writes data to the cache, Ignite writes-through or writes-behind all data modifications
            to the underlying external store. Ignite also performs ACID transactions (coordinating and committing transactions
            across both the cluster and the database).
        </p>

        <p>
            Additionally, Ignite can be deployed as a shared and unified in-memory layer that stores datasets that originate
            from disjointed databases. Your applications can consume all the data from Ignite as a single store while Ignite
            synchronizes the original databases whenever in-memory data is updated.
        </p>

        <h2>IGNITE NATIVE PERSISTENCE</h2>

        <p>
            Ignite Native Persistence is a distributed ACID-compliant, SQL-compliant disk store that transparently
            integrates with the Ignite in-memory layer. When Native Persistence is enabled, Ignite stores both
            data and indexes on disk, thus eliminating the time-consuming cache warm-up step. Native Persistence
            keeps a full copy of data on disk, so you are free to cache a subset of records in memory. If a required
            data record is missing from memory, Ignite reads the record from the disk automatically, regardless of the
            API (whether SQL, key-value, or scan queries).
        </p>


        <div class="jumbotron jumbotron-fluid">
            <div class="container">
                <div class="display-6 title">Learn More</div>
                <hr class="my-4">
                <div class="row">
                    <div class="col-sm-6">
                        <ul>
                            <li>
                                <a href="/features/sql.html">
                                    Distributed SQL <i class="fas fa-angle-double-right"></i>
                                </a>
                            </li>
                            <li>
                                <a href="/features/collocated-processing.html">
                                    Co-located Processing <i class="fas fa-angle-double-right"></i>
                                </a>
                            </li>
                            <li><a href="/features/acid-transactions.html">
                                ACID Transactions <i class="fas fa-angle-double-right"></i>
                            </a></li>
                            <li><a href="/features/machinelearning.html">
                                Machine and Deep Learning <i class="fas fa-angle-double-right"></i>
                            </a></li>
                        </ul>
                    </div>
                    <div class="col-sm-6">
                        <ul>
                            <li>
                                <a href="/arch/native-persistence.html">
                                    Native Persistence <i class="fas fa-angle-double-right"></i>
                                </a>
                            </li>
                            <li><a href="/use-cases/in-memory-database.html">
                                Ignite as an In-Memory Database <i class="fas fa-angle-double-right"></i>
                            </a></li>
                            <li><a href="/use-cases/digital-integration-hub.html">
                                Ignite as a Digital Integration Hub <i class="fas fa-angle-double-right"></i>
                            </a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>


    </div>
</article>
<!--#include virtual="/includes/footer.html" -->
<!--#include virtual="/includes/scripts.html" -->
</body>
</html>