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

<!--
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
"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>
    <link rel="canonical" href="https://ignite.apache.org/use-cases/datagrid.html"/>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <meta name="description"
          content="Apache Ignite as an In-Memory Data Grid accelerates and scales your databases, services, and APIs
          through ANSI SQL, ACID transactions, co-located compute, and machine learning."/>

    <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® is an in-memory data grid that accelerates and scales your databases, services, and APIs.
            It supports key-value and ANSI SQL APIs, ACID transactions, co-located compute, and machine learning
            libraries required for real-time applications.
        </p>
        <p>
            An in-memory data grid deployment is a read-through/write-through caching strategy, in which the application
            layer treats the data grid as the primary data store. The application layer writes to and reads from Ignite.
            Ignite ensures that any underlying database stays updated and consistent with the in-memory data.
        </p>
        <img class="img-fluid diagram-right" src="/images/svg-diagrams/data_grid.svg" alt="In-Memory Data Grid with Apache Ignite"/>
        <p>
            As an in-memory data grid, Ignite provides all essential APIs needed to simplify its adoption.
            The APIs include distributed key-value and ANSI SQL queries, ACID transactions, co-located
            computations, and machine learning models. While key-value and SQL calls let you request, join, and
            group distributed data sets, the compute and machine learning components help to eliminate data
            shuffling over the network, thus, boosting compute and data-intensive calculations.
        </p>

        <p>
            Ignite is capable of storing data both in memory and on disk with two options for data persistence
            -- you can persist changes in an external database or let Ignite keep data in its native persistence.
            Let's review both of these options.
        </p>

        <h2>Ignite and External Databases</h2>

        <p>
            Ignite can improve the performance and scalability of any external database such as RDBMS,
            NoSQL or Hadoop, by sliding in as an in-memory cache between the application and the database
            layer. When an application writes data to the cache, Ignite automatically writes-through or
            writes-behind all data modifications to the underlying external store. Ignite also performs
            ACID transactions where it coordinates and commits a transaction across the cluster as well as
            the database.
        </p>
        <p>
            Additionally, Ignite can be deployed as a shared and unified in-memory layer that stores data
            sets originating from disjointed databases. Your applications can consume all the data from
            Ignite as a single store while Ignite can keep the original databases in sync whenever in-memory
            data gets updated.
        </p>
        <p>
            However, there are some limitations if an external database is used as a persistence layer for
            Ignite deployments. For instance, if you run Ignite SQL or scan queries, you need to ensure that
            all the data has been preloaded to the in-memory cluster. Note that Ignite SQL or scan queries
            can read data from disk only if it is stored in the native persistence.
        </p>

        <h2>Ignite Native Persistence</h2>
        <p>Ignite native persistence is a distributed ACID and SQL-compliant disk store that transparently integrates
            with Ignite in-memory layer. When the native persistence is enabled, Ignite stores both data and indexes on
            disk and eliminates the time-consuming cache warm-up step. Since the native persistence always keeps a full
            copy of data on disk, you are free to cache a subset of records in memory. If a required data record is
            missing in memory, then Ignite reads it from the disk automatically regardless of the API you use -- be it
            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="fa fa-angle-double-right"></i>
                                </a>
                            </li>
                            <li>
                                <a href="/features/collocatedprocessing.html">
                                    Co-located Processing <i class="fa fa-angle-double-right"></i>
                                </a>
                            </li>
                            <li><a href="/features/transactions.html">
                                ACID Transactions <i class="fa fa-angle-double-right"></i>
                            </a></li>
                            <li><a href="/features/machinelearning.html">
                                Machine and Deep Learning <i class="fa fa-angle-double-right"></i>
                            </a></li>
                        </ul>
                    </div>
                    <div class="col-sm-6">
                        <ul>
                            <li>
                                <a href="/arch/persistence.html">
                                    Native Persistence <i class="fa fa-angle-double-right"></i>
                                </a>
                            </li>
                            <li><a href="/use-cases/in-memory-database.html">
                                Ignite as an In-Memory Database <i class="fa fa-angle-double-right"></i>
                            </a></li>
                            <li><a href="/use-cases/digital-integration-hub.html">
                                Ignite as a Digital Integration Hub <i class="fa 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>