extend ../_components/base.pug

block pagetitle
    title Distributed Key-Value APIs - Apache Ignite
    meta(name="description", content="Apache Ignite as a distributed key-value store is supported for different caching techniques. Ignite key-value APIs allow to create database key-value tables on-chain and increase processing performance.")
    link(rel="canonical", href="https://ignite.apache.org/features/key-value-apis.html")

    meta(property="og:title", content="Distributed Key-Value APIs - Apache Ignite")
    meta(property="og:type", content="article")
    meta(property="og:url", content="https://ignite.apache.org/features/key-value-apis.html")
    meta(property="og:image", content="/img/og-pic.png")
    meta(property="og:description", content="Apache Ignite as a distributed key-value store is supported for different caching techniques. Ignite key-value APIs allow to create database key-value tables on-chain and increase processing performance.")

block css 
    link(rel="stylesheet", href="../css/native-persistence.css?ver=" + config.version)
    link(rel="stylesheet", href="../css/key-value-api.css?ver=" + config.version)


block main
    - global.pageHref = "features"
    - config.hdrClassName = "hdr__blue"
    include ../_components/header.pug


    section.innerhero.innerhero--keyvalue
        .container.innerhero__cont
            .innerhero__main
                .innerhero__pre.pb-5 Apache Ignite
                h1.h1.innerhero__h1 Distributed <br>Key-Value APIs
                .innerhero__descr.pt-2.h5.
                    Query your distributed data in the fastest way possible <br>with key-value APIs 
                .innerhero__action 
                    a.button.innerhero__button(href="https://ignite.apache.org/docs/latest/index") Start Coding
            img.innerhero__pic.innerhero__pic--keyvalue(src="/img/features/key-value/hero.svg", alt="Distributed Key-Value APIs")
    // /.innerhero


    section.keyvalue1.container.flexi
        .keyvalue1__left
            h2.capstext Key-Value APIs Overview
            .keyvaluetext.pt-5
                p Every record in Ignite is stored as a key-value pair. All the records are distributed evenly across the cluster nodes. Your key-value queries are directed automatically to the nodes that store requested data. This is how Ignite utilizes all the given memory, disk, and CPU resources.
                p Key-value APIs are supported by all existing Ignite client libraries:
            .keyvalue1__libs.pt-5
                p.h5.leyvalue__lang Java <small>(implements JSR-107 specification known as JCache)</small>
                p.h5.leyvalue__lang .NET
                p.h5.leyvalue__lang Python
                p.h5.leyvalue__lang Node.JS
                p.h5.leyvalue__lang Your language
        .keyvalue1__right 
            .keyvalue1__picwrap.picwrap
                img(src="/img/features/key-value/key-value-api-pic.svg", alt="").keyvalue1__pic
    // /.keyvalue1


    section.keyvalueplank.container 
        .keyvalueplank__inner Apache Ignite key-value APIs provide additional capabilities such as&nbsp;<strong>automatic synchronization</strong> with external databases, <strong>near caching</strong> and <strong>ACID transactions.</strong>


    section.keyvalue2.container.flexi
        .keyvalue2__left
            h3.keyvalue__title Automatic Synchronization With External <br>Databases To Keep A Consistent Copy Of Data
            .keyvaluetext.pt-2.pb-5
                p Two synchronization strategies are available in Apache Ignite: <br>write-through/behind and read-through.
            dl.keyvalue2__box.pb-2
                dt Write-through and write-behind capabilities
                dd.pt-2 Ignite can automatically write-through or&nbsp;write-behind all the changes to&nbsp;an&nbsp;external database for every key-value request issued by&nbsp;your applications.
            dl.keyvalue2__box
                dt Read-through capabilities
                dd Read-through means that Ignite can automatically load data from an&nbsp;external database if&nbsp;a&nbsp;record is&nbsp;missing in&nbsp;memory.
        .keyvalue2__right 
            .keyvalue2__picwrap.picwrap
                img(src="/img/features/key-value/key-value-api-2.svg", alt="").keyvalue2__pic
    // /.keyvalue2


    section.keyvalue3.container.flexi
        .keyvalue3__right
            h3.keyvalue__title Near Cache To Process Your Requests In&nbsp;Microseconds
            .keyvaluetext.pt-2.pb-5
                p A near cache is a local client-side cache that stores the most frequently <br>used data on the application end.
            .keyvalue__title How it works
            .keyvaluetext.pt-2.pb-5
                p It is applied to applications that require a consistent response time of a few <strong>microseconds.</strong> Ignite automatically invalidates and updates the near cache.
                p Whenever the primary copy of&nbsp;a&nbsp;record gets updated on&nbsp;a&nbsp;server node, Ignite propagates the change to&nbsp;all the nodes that store the record&rsquo;s backup copy, as&nbsp;well as&nbsp;to&nbsp;the applications that keep the record&rsquo;s copy in&nbsp;their near caches.
        .keyvalue3__left
            .keyvalue3__picwrap.picwrap
                img(src="/img/features/key-value/key-value-api-3.svg", alt="").keyvalue3__pic
                .keyvalue3__picdescr
                    p 1. Call to the near cache
                    p 2. Call to the Ignite cluster 
                        span (if a record is not found in the near cache)
                    p 3. Read-through from the external database
                        span (if the record is not in the Ignite cluster yet)
    // /.keyvalue3


    section.keyvalue4.container.flexi.pb-1
        .keyvalue4__left
            h3.keyvalue__title ACID Transactions To Update Your Distributed Records Consistently
            .keyvaluetext.pt-2.pb-5
                p Apache Ignite key-value APIs are fully transactional, which means that data can be&nbsp;updated consistently and reliably.
            .keyvalue__title How it works
            .keyvaluetext.pt-2.pb-5
                p An&nbsp;Ignite transaction can update multiple records from different tables stored on&nbsp;different cluster nodes. Ignite can even span a&nbsp;transaction to&nbsp;an&nbsp;underlying relational database. Ignite implements <a href="/features/acid-transactions.html">two-phase-commit protocol to&nbsp;ensure data consistency at&nbsp;scale.</a>
        .keyvalue4__right
            .keyvalue4__picwrap.picwrap
                img(src="/img/features/key-value/key-value-api-4.svg", alt="").keyvalue4__pic
    // /.keyvalue3


    section.native-bottom.container
        .native-bottom__grid 
            article.nativebotblock
                .h4.nativebotblock__title
                    img(src="/img/features/native-rocket.svg", alt="").nativebotblock__icon
                    span Ready to Start?
                p.nativebotblock__text Create your first application using <br>Ignite key-value APIs
                a.nativebotblock__link.arrowlink(href="https://ignite.apache.org/docs/latest/key-value-api/basic-cache-operations", target="_blank") Using Key-Value APIs
            article.nativebotblock.nativebotblock--learn
                .h4.nativebotblock__title
                    img(src="/img/features/native-docs.svg", alt="").nativebotblock__icon
                    span Want to Learn More?
                p.nativebotblock__text Check out how Apache Ignite can be configured <br>and used as a standard key-value store
                a.nativebotblock__link.arrowlink(href="/use-cases/key-value-store.html") Key-Value Store