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

<!--
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/database/key-value-store.html"/>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <meta name="description"
          content="Apache Ignite operates as a distributed key-value store that stores data both in memory and on disk
          with support for key-value, SQL, ACID transactions, compute, and machine learning APIs."/>

    <title>Distributed Key-Value Store - Apache Ignite</title>

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

    
</head>
<body>

    <!--#include virtual="/includes/header.html" -->
<article>
    <header>
        <div class="container">
            <h1>Distributed <strong>Key-Value Store</strong></h1>
        </div>
    </header>
    <div class="container">
            <p>
                Apache Ignite® is a distributed key-value store that stores data in memory and on disk. Ignite functions
                as a distributed partitioned hash map with every cluster node owning a portion of the overall data set
                in this deployment mode. You can access the cluster with key-value requests or take advantage of APIs
                available exclusively in Ignite which include distributed ACID transactions, SQL,
                co-located computations, and machine learning.
            </p>
            
            <img class="img-responsive diagram-right" src="/images/svg-diagrams/key_value_store.svg" alt="Distributed Key-Value Store" />
            
            <h2>JCache and Extended Key-Value APIs</h2>
            <p>
                Ignite key-value APIs comply with the JCache (JSR 107) specification and support:
            </p>

            <ul class="page-list">
                <li>Basic Cache Put/Get Operations</li>
                <li>ConcurrentMap APIs</li>
                <li>EntryProcessor and CacheInterceptor APIs</li>
                <li>Events and Metrics</li>
            </ul>

            <p>
                Ignite also extends the JCache specification and supports distributed key-value ACID transactions,
                scan and continuous queries, co-located computations, and much more. For instance, continuous
                queries are useful if you want an application to be notified whenever a record gets updated on
                the server nodes. The ACID transactions support lets you update a set of records stored in different
                caches/tables with data consistency.
            </p>

            <h2>Near Cache</h2>

            <p>
                A near cache is a local client-side cache that stores the most frequently used data on the application end.
                This caching technique is supported for key-value APIs only and can be considered for applications that
                require a consistent response time ranging in microseconds. Ignite automatically invalidates and
                updates the near cache. Whenever the primary copy of a record gets updated on a server node, Ignite
                propagates the change to all the nodes that store the record's backup copy as well as to your
                applications that keep the record's copy in their near caches.
            </p>

            <h2>Read-through and Write-Through/Behind</h2>

            <p>
                If Ignite is deployed as a key-value store on top of an external database, then Ignite can automatically
                write-through or write-behind all the changes to that external store for every key-value request
                issued by your applications. It also includes key-value ACID transactions - Ignite coordinates and
                commits a transaction across its in-memory cluster as well as a relational database.
            </p>

            <p>
                The read-through capability means that Ignite can read data from an external database if a record is
                missing in memory. This feature is fully supported for both JCache and extended key-value APIs.
            </p>

            <h2>Ignite Native Persistence</h2>

            <p>
                If you want Ignite to function as a key-value store that caches data in memory and persists it to
                disk instead of an external database, then you can enable Ignite native persistence. The native
                persistence feature lets you eliminate the time-consuming cache warm-up step as well as the data reloading phase
                from external databases. Furthermore, 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 disk automatically regardless of the API you use.
            </p>

            <div class="jumbotron jumbotron-fluid">
                <div class="container">
                  <div class="title display-6">Learn More</div>
                  <hr class="my-4">
                  <div class="row">
                    <div class="col-sm-6">
                        <ul>
                            <li><a href="/arch/multi-tier-storage.html">Multi-Tier Storage <i class="fas fa-angle-double-right"></i></a></li>
                            <li><a href="/arch/native-persistence.html">Native Persistence <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>
                        </ul>
                    </div>
                    <div class="col-sm-6">
                        <ul>
                            <li><a href="/features/collocated-processing.html">Co-located Processing <i class="fas fa-angle-double-right"></i></a></li>
                            <li><a href="/features/sql.html">Distributed SQL <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>
            </div>
        </div>
    </div>
</article>         
    <!--#include virtual="/includes/footer.html" -->

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