# Aerospike Documentation > Aerospike is a real-time distributed NoSQL database for mission-critical applications. [Documentation root](https://aerospike.com/docs) ## Capabilities The documentation supports the following tasks: - Install and deploy Aerospike Database - Configure clusters and namespaces - Develop applications using Aerospike client libraries - Integrate Aerospike with streaming and analytics systems - Deploy Aerospike on Kubernetes - Operate and monitor production clusters ## Resource types Documentation includes: - Tutorials - Installation guides - Architecture explanations - Configuration reference - CLI documentation - Monitoring and operations guides ## Database - [Quickstart](https://aerospike.com/docs/database/quick-start.md): This Quickstart guide provides a step-by-step walkthrough for deploying an Aerospike Enterprise database using Docker. It includes installation instructions and code samples for connecting to the database and performing basic read and write operations across six major programming languages, including Java, Python, Go, C#, Node.js, and Rust. - [Aerospike Daemon CLI options](https://aerospike.com/docs/database/advanced/cli-options.md): This document details the command-line interface (CLI) options for the Aerospike daemon (`asd`), including how to specify config files and run in foreground mode for Docker or systemd. It covers Enterprise-specific flags like `--cold-start` and `--instance`, as well as newer options for experimental features and YAML schema validation introduced in version 8.1.1. - [Miscelaneous issues](https://aerospike.com/docs/database/advanced/misc.md): This document provides solutions for various Aerospike Database issues. It explains how to alter write commit levels for fire-forget behavior and how to manage concurrent access failures via the transaction-pending-limit. Additionally, it guides users on using gdb to decode stack traces in logs and clarifies that "key field too big" messages are informational. - [Benchmarking](https://aerospike.com/docs/database/install/benchmark.md): This document provides instructions for benchmarking an Aerospike installation, specifically detailing how to build and run the Java benchmark application to measure latency and concurrency. It also explains how to use the asadm tool to monitor cluster status, providing examples of network and namespace statistics. - [Install Aerospike](https://aerospike.com/docs/database/install.md): This document serves as the primary entry point for installing Aerospike Database across various environments. It provides navigation to detailed setup guides for 64-bit Linux distributions, Docker containers for macOS and Windows, and major cloud providers including AWS, GCP, and Azure, while highlighting critical connection tuning for virtualized environments. - [Install on macOS and Windows with Docker](https://aerospike.com/docs/database/install/docker.md): This guide provides step-by-step instructions for deploying Aerospike Database on macOS and Windows using Docker Desktop or AeroLab. It covers pulling Enterprise and Community images, configuring feature keys, verifying the installation with AQL data browser commands, and setting up shared directories for configuration files. - [Install Aerospike on Linux](https://aerospike.com/docs/database/install/linux.md): This guide provides step-by-step instructions for installing Aerospike Database on Debian, Ubuntu, and RHEL systems. It details critical prerequisites such as disabling SELinux enforcing mode and ensuring libcurl is installed, while offering installation paths via tgz archives or native .deb and .rpm packages. Additionally, it covers initial configuration, daemon management, and EE feature-key setup. - [Best practices for Aerospike and Linux](https://aerospike.com/docs/database/learn/best-practices.md): This guide outlines stability and performance best practices for Aerospike on Linux, focusing on startup checks and the `enforce-best-practices` flag. It provides specific tuning parameters for Aerospike service threads and memory budgets, alongside critical Linux kernel optimizations for All-Flash deployments, such as disabling THP and swappiness, NVMe partitioning, and managing file limits. - [Verify an installation](https://aerospike.com/docs/database/install/verify.md): This guide provides a procedure to verify that Aerospike is installed and running correctly. It details essential directory locations for configuration and binaries, then walks through using the aql tool to perform basic record operations—inserting, retrieving, and deleting a sample record—to ensure system functionality. - [Policies](https://aerospike.com/docs/database/learn/policies.md): This document explains how to configure Aerospike client policies globally or per-transaction across multiple programming languages. It provides detailed definitions for critical settings including replica selection, AP/SC read modes, write commit levels, and generation policies for optimistic concurrency control. Users can leverage these policies to fine-tune database behavior regarding timeouts, TTL, and record existence. - [Strong consistency](https://aerospike.com/docs/database/learn/strong-consistency.md): This document explains Aerospike's strong consistency (SC) mode, covering guaranteed write ordering and the management of unavailable or dead partitions via auto-revive. It details API differences such as InDoubt errors and linearizable read policies, while warning against operational hazards like clock discontinuity and non-durable deletes. - [Create and use transactions](https://aerospike.com/docs/database/learn/transactions.md): This guide explains how to implement transactions in Aerospike Database 8.0.0 using strong-consistency namespaces. It covers the full lifecycle from creation to commit or abort, provides strategies for handling MRT_BLOCKED and inDoubt errors, and includes multi-language code examples for setting timeouts and performing batched writes. - [Health check](https://aerospike.com/docs/database/observe/health-check.md): This document explains how Aerospike identifies health outliers—nodes or devices deviating from normal performance patterns—using a sliding window of statistics and the Interquartile Range (IQR) method. It details configuration via `aerospike.conf` and `asinfo`, specific metrics like fabric connections and replica latency, and provides guidance on building custom outlier detectors. - [Key metrics to monitor](https://aerospike.com/docs/database/observe/key-metrics.md): This document identifies critical Aerospike metrics for alerting and server health, including XDR performance and client error tracking. It provides a vital update for Database 7.0.0 users on how to calculate total namespace memory by summing specific component metrics since `memory_used_bytes` was removed. It also recommends tools like Prometheus Node Exporter for OS-level monitoring. - [3rd-party log analysis tools](https://aerospike.com/docs/database/observe/log-analysis.md): This document provides step-by-step instructions for configuring Aerospike Database log parsing and filtering in Fluent Bit and Splunk. It details how to download and implement specific configuration files, such as parser/filter rules for Fluent Bit and properties/transforms files for Splunk apps, to enable custom alerts and dashboards. - [Monitor latency with histograms](https://aerospike.com/docs/database/observe/latency.md): This guide details how Aerospike uses histograms in log files to track latency distributions across various transaction types. It covers auto-enabled benchmarks and provides instructions on enabling granular, configuration-based analysis for Read, Write, UDF, Batch, and Storage transactions using `asadm` to pinpoint bottlenecks within specific database subsystems. - [Error codes](https://aerospike.com/docs/database/reference/error-codes.md): This reference guide details Aerospike's client and server error codes, explaining the distinction between negative (client) and positive (server) values. It features a comprehensive table mapping numeric codes to constants like AS_ERR_NOT_FOUND and AS_ERR_TIMEOUT, categorized by functionality such as security, MRT transactions, and secondary indices. - [System limits and thresholds](https://aerospike.com/docs/database/reference/limitations.md): This document details technical constraints for Aerospike Database, including naming conventions and maximum capacities for bins, namespaces, records, and clusters. It provides critical thresholds for secondary indexes, XDR datacenters, security settings, and data masking across different database versions and editions. This is essential for capacity planning and system configuration. - [Aerospike Database versioning and releases](https://aerospike.com/docs/database/reference/platform-support.md): This document details Aerospike's four-part versioning scheme (epoch.major.minor.patch) and defines policies for breaking changes and deprecations. It includes a detailed OS compatibility matrix for various Linux distributions and provides General Availability and End-of-Life dates for both current and legacy database releases. - [Aerospike Benchmark (asbench)](https://aerospike.com/docs/database/tools/asbench.md): This document provides comprehensive instructions on using the asbench tool to test Aerospike cluster performance. It covers connection and TLS settings, detailed bin specifications through "object specs," and diverse workload configurations including random read/update and UDF calls. Additionally, it explains how to analyze latency via periodic and HDR histograms. - [Aerospike Configuration (asconfig)](https://aerospike.com/docs/database/tools/asconfig.md): This guide explains how to use the `asconfig` tool to convert Aerospike configurations between YAML and native formats, validate them against versioned schemas, and detect configuration drift using the `diff` command. It also covers generating config files from running nodes and comparing schema changes between server versions to facilitate database upgrades. - [Aerospike Info (asinfo)](https://aerospike.com/docs/database/tools/asinfo.md): This guide covers the asinfo command-line utility used for managing Aerospike clusters and updating server configuration parameters during runtime. It provides a detailed breakdown of CLI options for connectivity, authentication, and TLS, while also explaining how to access these functions via the telnet port. - [Validation tool (asvalidation)](https://aerospike.com/docs/database/tools/asvalidation.md): This guide details the `asvalidation` tool used to scan Aerospike namespaces for corrupted Collection Data Type (CDT) bins in Lists and Maps. It covers validation and fix modes, command-line options for partition scanning, and connection settings. It also defines specific error types—such as duplicate keys and ordering issues—and explains how to repair them using the `--cdt-fix-ordered-list-unique` option. - [Data Browsing](https://aerospike.com/docs/database/tools/data-browser.md): This document outlines the primary methods for viewing Aerospike Database data. It covers the lightweight Aerospike JDBC Driver for use with popular tools like DBeaver and DataGrip, as well as AQL, a text-based command-line interface for efficient data browsing. - [Aerospike tools configuration file](https://aerospike.com/docs/database/tools/conffile.md): This guide details how to use TOML configuration files to manage Aerospike tools settings. It explains the precedence of different configuration sources, syntax rules for options and values, and how to utilize group-based instance management. Users will also learn about the [include] functionality for modularizing configurations across multiple files. - [Aerospike tools](https://aerospike.com/docs/database/tools.md): This document provides a comprehensive directory of tools for managing Aerospike Database servers, categorized into packaged and non-packaged utilities. It details specific tools for cluster health (asadm), benchmarking (asbench), configuration (asconfig), data browsing (AQL), and backup/restore operations, while also introducing AeroLab for development environments. - [Metrics Command Examples](https://aerospike.com/docs/database/tools/metrics-examples.md): This document provides practical command examples for retrieving Aerospike database metrics using the asadm and asinfo tools. It covers specific syntax for querying statistics at various levels, including service-wide, namespace, set, secondary index, and Cross-Datacenter Replication (XDR) metrics to monitor system health. - [Dynamic Runtime Config](https://aerospike.com/docs/database/tools/runtime-config.md): This document provides comprehensive instructions for viewing and modifying Aerospike's dynamic runtime configuration parameters using the asadm and asinfo tools. It details specific command syntax for various contexts—including logging, namespace, service, network, and XDR—and explains how to manage subcontexts like sets and XDR datacenters. - [Aerospike Tools release notes](https://aerospike.com/docs/database/tools/release-notes.md): This document contains a detailed history of Aerospike Tools release notes from version 3.5.9 through 13.0.0. It outlines specific new features, bug fixes, and security updates for individual tools including asadm, asbackup, asbench, asconfig, and AQL. It serves as a technical reference for tracking software evolution and managing critical security patches. - [Aerospike Unique Data Agent (UDA)](https://aerospike.com/docs/database/tools/uda.md): This guide covers the installation, configuration, and usage of the Aerospike Unique Data Agent (UDA) to track unique data and license usage. It provides specific calculation formulas, details on REST API endpoints for querying entries, and instructions for integrating UDA with asadm. Note that UDA is obsolete in tools 12.0.0+. - [UDF Best Practices](https://aerospike.com/docs/database/advanced/udf/best-practices.md): This guide outlines best practices for developing Aerospike User-Defined Functions (UDFs) in development environments. It provides specific instructions on disabling UDF caching, utilizing `luac` to find undefined variables, and configuring detailed logging levels to debug Lua code without an interactive debugger. - [Getting Started With Lua UDFs](https://aerospike.com/docs/database/advanced/udf/get-started.md): This guide introduces User Defined Functions (UDFs) in Aerospike using Lua, detailing the transition from LuaJIT 2.1 to Lua 5.4 starting with Database 7.0.0. It explains critical programming constraints, such as the prohibition of global variables and specific rules for local function calls. Additionally, it identifies disabled modules including the debug module and os.exit(). - [User-Defined Functions (UDF) Development Guide](https://aerospike.com/docs/database/advanced/udf.md): This guide explains how to develop and deploy Lua-based User-Defined Functions (UDFs) in Aerospike, covering both Record UDFs for single-record operations and Stream UDFs for processing record streams via secondary indexes. It details the development lifecycle, provides code examples for statistics and word counts, and compares UDF benefits against standard atomic operations. - [Known limitations](https://aerospike.com/docs/database/advanced/udf/limitations.md): This document outlines the technical limitations of Aerospike's UDF system, specifically detailing Lua runtime constraints such as restricted io/os libraries and stack buffer limits. It covers functional boundaries regarding return types, record bin limits, and transaction locking, while also explaining how Lua state caching and invalidation operate across nodes. - [Managing UDFs](https://aerospike.com/docs/database/advanced/udf/managing.md): This document explains how to register and manage Aerospike UDF modules using tools like asadm and aql. It covers the UDF life-cycle from upload to byte-code compilation, handling non-Aerospike dependencies, and manually clearing Lua context caches via asinfo. Additionally, it provides details on default storage paths and server configuration for UDFs. - [Special upgrade from Database 4.3.0 to 4.9.0](https://aerospike.com/docs/database/advanced/special-upgrades/430-to-490-upgrade.md): This document provides specific instructions for upgrading Aerospike Database from version 4.3.0 or earlier to 4.9.0. It focuses on avoiding XDR compression errors that occur when source clusters are newer than destination clusters, detailing upgrade paths for both one-way and bi-directional shipping scenarios in preparation for version 5.0.0. - [Special upgrade to Database 5.0.0](https://aerospike.com/docs/database/advanced/special-upgrades/500-upgrade.md): This document outlines the critical steps for upgrading Aerospike Database to version 5.0.0, emphasizing the prerequisite upgrade to 4.9.0. It details the redesigned, hierarchical XDR stanza structure and provides an exhaustive list of deprecated configuration parameters across various services that must be removed to ensure the database starts successfully. - [Upgrade to Database 5.7.0 — mixed version clusters](https://aerospike.com/docs/database/advanced/special-upgrades/570-upgrade.md): This document provides critical guidelines for performing a rolling upgrade from Aerospike Database 5.6.0 or earlier to version 5.7.0. It emphasizes the necessity of waiting for migrations to complete between nodes and warns against altering cluster membership during the process to prevent secondary index corruption. - [Upgrade to Database 6.0.0](https://aerospike.com/docs/database/advanced/special-upgrades/600-upgrade.md): This guide details the transition to Aerospike Database 6.0.0, focusing on a new storage format that requires wiping persisted namespace devices before upgrading. It highlights critical risks regarding increased record overhead (4 bytes) and provides methods to identify and fix records exceeding write-block-size limits. Additionally, it lists configuration parameter changes and outlines the rolling upgrade procedure. - [Downgrade from Database 6.1.0 to 6.0.0](https://aerospike.com/docs/database/advanced/special-upgrades/610-to-600-downgrade.md): This guide provides specific instructions for downgrading Aerospike Database from version 6.1.0 to 6.0.0. It details how to reclaim shared memory segments used by secondary indexes via a command-line utility after stopping the server and notes that this downgrade process will necessitate a cold start. - [Special upgrade to Database 6.1.0](https://aerospike.com/docs/database/advanced/special-upgrades/610-upgrade.md): This guide outlines special tasks for upgrading to Aerospike Database 6.1.0, including critical pre-upgrade backups and storage format checks. It details a new 64-character limit for secondary index names and explains that sindexes created without a set name now index the entire namespace rather than just the null set. - [Special upgrade to Database 6.3.0](https://aerospike.com/docs/database/advanced/special-upgrades/630-upgrade.md): This document details the special upgrade requirements for Aerospike Database 6.3.0, specifically highlighting new feature keys required for XDR, Rack Awareness, Vault integration, and Flash indices. It provides essential pre-upgrade checklists, including backing up configuration files and addressing secondary index name length constraints to ensure a smooth transition. - [Special upgrade to Database 6.4.0](https://aerospike.com/docs/database/advanced/special-upgrades/640-upgrade.md): This guide details the special upgrade process to Aerospike Database 6.4.0, specifically for clusters using single-bin namespaces. It provides a five-step rolling upgrade procedure to convert these namespaces to multi-bin, explains node state compatibility during migration, and outlines post-migration characteristics such as empty string bin names and XDR limitations. - [Downgrade from Database 7.0.0](https://aerospike.com/docs/database/advanced/special-upgrades/700-downgrade.md): This guide outlines the mandatory steps for downgrading from Aerospike Database 7.0.0, emphasizing that a cold start is required. It details critical prerequisites including cleaning shared memory stripes, removing specific CDT and blob-type indexes, and verifying bin and set limits to prevent data loss or errors when returning to earlier versions. - [Downgrade from Database 7.1.0 to 7.0.0](https://aerospike.com/docs/database/advanced/special-upgrades/710-to-700-downgrade.md): This document provides specific instructions for downgrading Aerospike Database from version 7.1.0 to 7.0.0. It details critical configuration replacements, such as switching flush-size to write-block-size and post-write-cache to post-write-queue, while listing several 7.1.0 parameters that must be removed to avoid startup errors and ensure stability. - [Special upgrade to Database 7.0.0](https://aerospike.com/docs/database/advanced/special-upgrades/700-upgrade.md): This document provides detailed instructions for upgrading Aerospike Database to version 7.0.0 from 6.x.y.z. It explains the transition to a consolidated flat storage format across all engines, outlines required configuration changes to avoid startup failures, and provides specific migration paths for converting in-memory namespaces with or without persistence. - [Downgrade from Database 7.2.0](https://aerospike.com/docs/database/advanced/special-upgrades/720-downgrade.md): This document provides step-by-step instructions for downgrading from Aerospike Database 7.2.0. It specifically details how to disable the active-rack parameter using asadm and configuration file updates to prevent migration failures, providing distinct procedures for both AP (Available and Partition-tolerant) and SC (Strong Consistency) modes. - [Upgrade to Database 7.1.0 and later](https://aerospike.com/docs/database/advanced/special-upgrades/710-upgrade.md): This guide details the process of upgrading Aerospike Database to version 7.1.0 and later, specifically highlighting the replacement of write-block-size with flush-size and new restrictions on map key types. It provides a technical workflow using asvalidation and asconfig tools to ensure configuration compatibility and data integrity before the upgrade. - [Downgrade from Database 8.0.0](https://aerospike.com/docs/database/advanced/special-upgrades/800-downgrade.md): This document provides a step-by-step guide for downgrading from Aerospike Database 8.0.0. It details necessary precautions for namespaces using strong consistency, including how to disable transaction writes, verify provisional counts, and wipe storage on individual nodes to prevent data incompatibility before restarting with an older version. - [Upgrade from Database 5.0.0 or 5.1.0 to 5.3.0](https://aerospike.com/docs/database/advanced/special-upgrades/bin-projection-upgrade.md): This guide details the mandatory intermediate upgrade path for users moving from Aerospike 5.0.0 or 5.1.0 to 5.3.0 while utilizing XDR bin projection. It explains why an upgrade to version 5.2 is required first and provides specific instructions on transitioning configuration parameters from `ship-only-specified-bins` to `bin-policy`. - [Upgrade to Database EE for US Federal](https://aerospike.com/docs/database/advanced/special-upgrades/ee-to-600-fe-upgrade.md): This document provides step-by-step instructions for migrating Aerospike Database EE to the FIPS 140-2 compliant US Federal edition. It covers essential backups of configuration and SMD files, package replacement procedures, and critical security changes, specifically the requirement to use mTLS or LDAP instead of password authentication. - [Special upgrades and downgrades](https://aerospike.com/docs/database/advanced/special-upgrades.md): This document provides critical instructions for upgrading or downgrading specific Aerospike Database versions, ranging from 4.3.x to 8.0.0. It details essential pre-requisites and risks, such as handling transactions in version 8.0.0, storage engine rewrites in 7.0.0, and the removal of single-bin namespaces in 6.4.0 to ensure cluster stability during migrations. - [Client errors](https://aerospike.com/docs/database/advanced/troubleshoot/client.md): This document provides troubleshooting steps for Aerospike client errors, specifically addressing server memory issues and KEY_BUSY results caused by hotkeys. It details how to use asadm and asinfo for monitoring queue delays and adjusting transaction-pending-limits, while also explaining the "DUNNED NODE" status during network interruptions. - [Dynamically change parameters](https://aerospike.com/docs/database/advanced/troubleshoot/dynamic-config.md): This document provides instructions on using asadm and asinfo to modify Aerospike database parameters dynamically without restarting the cluster. It covers transient changes to namespace memory sizes, logging severity levels, secondary index garbage collection rates, and memory high-water marks, noting that these settings do not persist across restarts. - [Cluster problems](https://aerospike.com/docs/database/advanced/troubleshoot/cluster.md): This guide provides technical steps to resolve Aerospike cluster issues such as data migration delays and "split brain" scenarios. It covers network diagnostics via iptables and multicast validation using open-mtools, while explaining how to use the admin port (3003) to eject unresponsive nodes by modifying the cluster name configuration. - [Troubleshooting](https://aerospike.com/docs/database/advanced/troubleshoot.md): This guide outlines a diagnostic workflow for Aerospike Database, directing users to check server logs, use asadm for system statistics, and monitor cluster latency and network health. It emphasizes using the Knowledge Base and checking for software upgrades to resolve issues. The document also lists essential operational tasks, such as managing the asd process and updating configuration parameters. - [Install problems](https://aerospike.com/docs/database/advanced/troubleshoot/install.md): This guide helps resolve Aerospike installation failures by detailing specific package dependencies for CentOS 8 and Python3 requirements for Debian/Ubuntu tools. It provides fixes for /opt/aerospike directory conflicts and instructions on disabling SELinux to prevent user and group creation errors during the setup process. - [Miscellaneous issues](https://aerospike.com/docs/database/advanced/troubleshoot/misc.md): This document provides solutions for various Aerospike issues, including how to alter the write commit level for fire-forget functionality and managing the transaction-pending-limit to avoid hot key failures. It also explains how to use gdb to resolve non-meaningful stack traces and clarifies that "key field too big" log messages are informational. - [Node problems](https://aerospike.com/docs/database/advanced/troubleshoot/node.md): This document provides guidance on troubleshooting Aerospike node crashes, specifically focusing on Out of Memory (OOM) events. It explains how to use dmesg and system logs to identify memory issues caused by high write rates and insufficient eviction settings. Additionally, it covers capacity planning and verifying machine uptime to detect unexpected reboots in cloud environments. - [Troubleshooting startup problems](https://aerospike.com/docs/database/advanced/troubleshoot/startup.md): This guide provides solutions for common Aerospike `asd` daemon startup failures. It covers critical errors related to kernel shared memory settings, device initialization, feature-key requirements, and network interface configuration. It also explains how to resolve file descriptor limits and defrag loops to ensure the server joins the cluster successfully. - [Backup and Recovery in AWS](https://aerospike.com/docs/database/install/aws/backup.md): This document outlines three primary methods for backing up and recovering Aerospike data in AWS environments. It compares native Aerospike backup tools with EBS snapshots, highlighting trade-offs regarding speed, cost, and system metadata (SMD). Additionally, it provides a step-by-step process for recovering from instance failures by reattaching EBS volumes to new instances. - [Aerospike on Amazon EC2](https://aerospike.com/docs/database/install/aws/best-practices.md): This guide provides technical recommendations for deploying Aerospike on Amazon EC2 to ensure production-grade performance. It details critical configurations for VPC networking, RPS/ENA tuning, and the use of shadow devices to balance Instance Store speed with EBS durability, while explaining how to mitigate "grey failures" via NVMe I/O timeout adjustments. - [Install on Amazon EC2](https://aerospike.com/docs/database/install/aws/install.md): This guide provides step-by-step instructions for deploying Aerospike on Amazon EC2, covering both Marketplace AMIs and custom image creation. It specifies recommended instance types like r3.2xlarge, necessary security group port configurations (3000-3003), and explains how to implement mesh heartbeat clustering due to AWS's multicast restrictions. - [Recommendations for Microsoft Azure](https://aerospike.com/docs/database/install/azure/best-practices.md): This document provides technical recommendations for running Aerospike on Azure, including the use of Lsv2 VMs and Ubuntu Server LTS. It details network port configurations, persistent disk selection (P40), and strategies for using local SSDs via Shadow Device configuration to balance performance with persistence. Additionally, it covers fault tolerance through Azure Availability Sets. - [Amazon EC2 Capacity Planning](https://aerospike.com/docs/database/install/aws/plan.md): This guide helps users plan Amazon EC2 resources for Aerospike, mapping instance types to specific workloads and recommending OS versions. It covers network optimization via Receive Packet Steering (RPS), storage configurations using EBS or ephemeral SSD caches, and critical considerations for cluster autoscaling. - [Aerospike on Amazon EC2 - IP Addressing](https://aerospike.com/docs/database/install/aws/ip-addressing.md): This guide details how to configure private, public, and elastic IP addresses for Aerospike on AWS EC2, specifically using the `virtual` keyword with `access-address` to prevent client timeout issues. It provides a framework for isolating Client, XDR, Heartbeat, and Fabric traffic across multiple ENIs and explains necessary adjustments for mesh heartbeat mode and XDR IP mapping. - [Microsoft Azure capacity planning](https://aerospike.com/docs/database/install/azure/plan.md): This document provides guidance on deploying Aerospike in Microsoft Azure, focusing on the choice between in-memory and persistent data stores. It recommends using Lsv2 instance types for their local SSDs and Premium Storage support, while offering specific advice on configuring ReadOnly disk caching to optimize read-heavy workloads. - [Install on Microsoft Azure](https://aerospike.com/docs/database/install/azure/install.md): This guide provides step-by-step instructions for deploying Aerospike on an Azure VM, including recommended instance sizes (GS/LS) and specific Network Security Group rules for ports 3000-3003. It covers the initial VM creation process, installation via Ubuntu, and directs users to additional resources for network and storage configuration. - [Recommendations for Google Compute Engine](https://aerospike.com/docs/database/install/gcp/best-practices.md): This guide provides specific configuration recommendations for deploying Aerospike on Google Compute Engine, covering Ubuntu OS and network tuning for heartbeats. It details storage strategies including Persistent Disks, Local SSDs, and the Shadow Device configuration to optimize performance while ensuring data durability. - [Install on Google Compute Engine](https://aerospike.com/docs/database/install/gcp/install.md): This quickstart guide provides step-by-step instructions for deploying a single-node Aerospike cluster on a GCP VM instance using Ubuntu 24.04. It details how to configure essential firewall rules for ports 3000-3004 and 8081, download the server binaries, and use the asinstall script to get the database running for development and testing. - [Capacity Planning for Google Compute Engine](https://aerospike.com/docs/database/install/gcp/plan.md): This guide details capacity planning for Aerospike on Google Compute Engine, focusing on in-memory caching and fast persistent data stores. It explains the use of the Shadow Device Storage Engine with Local SSDs and Persistent Disks to optimize performance and reliability. The document also provides insights on achieving high availability across GCP zones and regions using XDR or message queues. - [Performance tuning on Google Compute Engine](https://aerospike.com/docs/database/install/gcp/tune.md): This document explains how to optimize Aerospike performance on Google Compute Engine by pinning the database process to specific vCPUs using the taskset command. By leaving certain vCPUs free to handle network IRQs, users can reduce network latencies and improve overall system efficiency. - [Recommendations for Openstack](https://aerospike.com/docs/database/install/openstack/recommendations.md): This guide details the optimal Openstack configuration for Aerospike, emphasizing Nova for compute and Cinder for SSD-based block storage. It provides critical advice on network isolation using separate NICs and cautions against Ceph's latency issues and SSD cache pools. Additionally, it suggests third-party tools like Ansible for cluster configuration management. - [Upgrading from Community to Enterprise](https://aerospike.com/docs/database/install/upgrade/community.md): This guide provides a step-by-step procedure to upgrade an Aerospike cluster from Community to Enterprise Edition without downtime. It details how to perform the upgrade one node at a time, covering migration checks, configuration backups, package replacement for RedHat and Debian systems, and verification steps to prevent data loss in non-persistent namespaces. - [Upgrading hardware](https://aerospike.com/docs/database/install/upgrade/hardware.md): This document provides a step-by-step guide for upgrading Aerospike cluster hardware while maintaining availability. It details best practices such as one-node-at-a-time upgrades, using `asadm` to verify data migration status, and adjusting configuration files for expanded SSD or RAM capacity. It also highlights the importance of equal storage across nodes to ensure optimal performance. - [Upgrade or repair an Aerospike server](https://aerospike.com/docs/database/install/upgrade.md): This guide details the rolling upgrade process for Aerospike servers, allowing version updates or hardware repairs without service interruption or data loss. It provides insights into estimating upgrade time, the impact of rebalancing, and links to critical resources like release notes and special version-specific upgrade paths. - [Standard Database upgrade](https://aerospike.com/docs/database/install/upgrade/standard.md): This guide provides a step-by-step procedure for performing a rolling upgrade of the Aerospike Database to ensure zero downtime. It covers downloading server packages, installing RPM or Debian formats, and best practices for AP and SC namespaces. Additionally, it explains how to monitor cluster stability using `asadm` and specific metrics like `cluster_key` and `migrate_partitions_remaining`. - [Access control with LDAP and PKI](https://aerospike.com/docs/database/learn/security/access-control.md): This document outlines authentication modes for Aerospike Enterprise Edition, covering password-based, PKI/mTLS, and external LDAP access control. It specifies the differences between internal and external users, requirements for certificate-based auth, and how the Federal Edition mandates LDAP or PKI. It also provides version-specific updates and critical XDR compatibility warnings. - [Data masking](https://aerospike.com/docs/database/learn/security/data-masking.md): This document explains Aerospike's dynamic data masking feature available in Database 8.1.1, which obfuscates PII in real-time without altering disk storage. It details the use of redaction and constant replacement methods to ensure regulatory compliance (GDPR, HIPAA) and secure non-production environments. Additionally, it covers built-in masking functions and audit logging for security events. - [Rate quotas](https://aerospike.com/docs/database/learn/security/rate-quotas.md): This document explains how to implement rate quotas in Aerospike Enterprise Edition to limit read and write transactions per second (TPS) via custom roles and `asadm`. It details the specific operations that count toward these quotas, including PI/SI queries, and clarifies that the system acts as a circuit breaker returning error code 83 rather than a throttle. - [Transport Layer Security](https://aerospike.com/docs/database/learn/security/tls.md): This document explains TLS implementation in Aerospike Enterprise Edition across client-to-cluster, node-to-node, and XDR traffic. It details authentication modes like mutual auth and subject name validation, hostname matching strategies, and language-specific client support. It also covers certificate revocation via blacklists and dynamic rotation using file-based or Secret Manager methods. - [Aggregation](https://aerospike.com/docs/database/learn/architecture/aggregation.md): This document details how to use Aerospike Stream UDFs in Lua to perform distributed aggregation of query results, emphasizing the use of secondary indexes for high performance. It provides a complete walkthrough using AQL to create indexes, write map-reduce modules, and execute aggregate queries like COUNT on specific record sets. - [Client architecture](https://aerospike.com/docs/database/learn/architecture/clients.md): This document details Aerospike's distributed client-server architecture and API capabilities. It explains how clients track cluster states via the info protocol and manage connections automatically, while listing advanced operations like CAS, batch gets, and User-Defined Functions (UDFs). This provides a technical foundation for understanding the client layer's efficiency. - [Durable deletes](https://aerospike.com/docs/database/learn/architecture/durable-deletes.md): This guide details Aerospike's durable deletes feature, which utilizes tombstones to ensure records remain deleted after cold starts. It provides technical specifics on tombstone sizing, the Tomb Raider cleanup mechanism for reclaiming space, and how these policies integrate with strong consistency mode and bin convergence. - [Flexible storage](https://aerospike.com/docs/database/learn/architecture/hybrid-storage.md): This document explains Aerospike's flexible storage options for data and indexes using DRAM, NVMe SSDs, and PMem. It details the Hybrid Memory Architecture (HMA), In-Memory, and All Flash configurations while explaining how namespaces are managed and records are stored with copy-on-write persistence and defragmentation to ensure reliability. - [Architecture overview](https://aerospike.com/docs/database/learn/architecture.md): This document details Aerospike's three-layer architecture consisting of a cluster-aware client layer, an automated distribution layer using Paxos, and a high-performance storage layer. It explains the schemaless data model—namespaces, sets, and bins—and how flash-optimized I/O and automatic rebalancing ensure linear scalability and low latency. - [Transactions](https://aerospike.com/docs/database/learn/architecture/transactions.md): This page details Aerospike Database 8.0.0's distributed ACID transactions, explaining how they ensure strict serializability through a client-coordinated process. It covers the dual-record locking mechanism for writes, read validation during commit, and the use of monitor records to handle failure recovery. It also outlines supported commands and the `txn` policy field implementation. - [Cross datacenter replication (XDR)](https://aerospike.com/docs/database/learn/architecture/xdr.md): This document explains Aerospike's XDR for asynchronous replication across WANs, detailing active-passive, mesh, star, and linear chain topologies. It covers configuration granularity for namespaces, sets, and bins, the role of the XDR proxy, and technical mechanisms like LUT/LST. Additionally, it outlines failure handling strategies and recovery modes to ensure global data redundancy. - [User-defined functions (UDFs)](https://aerospike.com/docs/database/learn/architecture/udf.md): This document explains how to extend Aerospike's functionality using Lua-based User-defined functions (UDFs). It details the differences between Record UDFs for single-record manipulation and Stream UDFs for low-latency MapReduce operations. Additionally, it covers cluster registration, C function integration, and performance protection mechanisms. - [Quickstart: Data masking](https://aerospike.com/docs/database/learn/tutorials/quick-start-data-masking.md): This quickstart demonstrates how to implement data masking in Aerospike Database Enterprise Edition using Docker and RBAC. It guides users through creating roles, defining redact and constant masking rules for bins like SSNs and emails, and verifying that unauthorized users receive masked values or role violation errors during writes. - [Tutorial for Expression Indexes](https://aerospike.com/docs/database/learn/tutorials/quick-start-expression-index.md): This tutorial provides a hands-on guide to implementing sparse expression indexes in Aerospike Database 8.1.0+. It demonstrates how to define complex filter logic via client libraries, generate Base64 strings for index creation using asadm, and perform range queries on computed values to reduce memory footprint and improve query latency. - [Monitoring stack components](https://aerospike.com/docs/database/observe/monitor/components.md): This document details the two-layer architecture of the Aerospike monitoring stack used for visualizing and analyzing operational metrics. It explains how the Prometheus Exporter, Prometheus, and Alert Manager collect data from Aerospike Database Enterprise Edition and outbound connectors, which is then visualized through Grafana dashboards. - [Monitoring stack dashboards](https://aerospike.com/docs/database/observe/monitor/dashboards.md): This document explains how to interpret Aerospike metrics within monitoring dashboards, detailing the mapping between API locations and Prometheus exporter prefixes. It covers metric types—including edition, duration, and data type—and provides specific labels and a PromQL query example for measuring transaction per second (TPS) read operations. - [Monitoring with Open Telemetry (OTel)](https://aerospike.com/docs/database/observe/monitor/otel.md): This guide explains how to export Aerospike monitoring data using the OpenTelemetry (OTel) Collector and Prometheus Exporter. It provides specific configuration steps and Docker Compose examples for integrating with New Relic, Datadog, DynaTrace, and Amazon CloudWatch. Users can choose between direct gRPC endpoint connections or utilizing an OTel Collector for telemetry processing. - [Add a node to an Aerospike cluster](https://aerospike.com/docs/database/manage/cluster/add-node.md): This guide details how to expand Aerospike cluster capacity by adding new nodes, emphasizing critical prerequisites like SSD initialization and system metadata cleanup. It provides specific configuration examples for mesh and multicast modes while warning about the resource impact of data rebalancing migrations. Users can also find instructions on verifying node integration using asadm and server logs. - [Delay migrations](https://aerospike.com/docs/database/manage/cluster/delay-migrations.md): This document explains how the `migrate-fill-delay` configuration in Aerospike Enterprise Edition can be used to suppress "fill" migrations during short node absences. It details the differences between AP and SC mode behaviors, provides guidance on setting delays for rolling upgrades or cold restarts, and illustrates a rack-aware maintenance scenario across different namespace types. - [Managing batched commands](https://aerospike.com/docs/database/manage/cluster/batches.md): This guide details the management of batched commands in Aerospike, focusing on tuning server-side buffers and response threads to optimize memory usage and prevent CPU spikes. It covers operational tools like asadm for configuration and provides a comprehensive breakdown of batch-index and sub-transaction metrics used to monitor performance and identify "huge" buffer issues. - [Cluster consistency](https://aerospike.com/docs/database/manage/cluster/consistency.md): This guide provides detailed procedures for managing nodes in Aerospike Strong Consistency (SC) namespaces, including updating the roster via asadm and performing rolling upgrades using ASMT for warm restarts. It covers rack-aware maintenance strategies, the active-rack optimization feature, and methods to validate partition health or revive dead partitions. - [Manage migrations](https://aerospike.com/docs/database/manage/cluster/migrations.md): This document explains how Aerospike balances data using partition-based migrations during cluster size changes. It provides methods for monitoring migration status via asadm, logs, and statistics, and details specific configuration parameters to either accelerate data movement or slow it down to protect application performance. - [Manage queries](https://aerospike.com/docs/database/manage/cluster/queries.md): This document provides instructions for managing query operations in an Aerospike cluster, including the creation of secondary indexes and tuning parameters like `query-threads-limit`. It details how to list and abort long queries using `asadm` or `asinfo` across different database versions and lists key performance metrics and histograms for monitoring PI and SI queries. - [Quiesce a node](https://aerospike.com/docs/database/manage/cluster/quiesce-node.md): This document provides detailed instructions on using quiescence to facilitate smooth master handoffs during planned Aerospike maintenance. It covers rolling software upgrades, host reboots with ASMT index preservation, and rack-aware strategies including the `active-rack` optimization. Users will learn how to verify handoffs via proxy metrics and ensure cluster stability before proceeding. - [Remove a node](https://aerospike.com/docs/database/manage/cluster/remove-node.md): This guide outlines the process for removing a node from an Aerospike cluster while maintaining data integrity. It details how to verify migrations via asadm, update seed configurations, clear the heartbeat tip list using 'tip-clear', and use 'services-alumni-reset' to prevent reconnection issues during future recommissioning. - [Manage UDFs](https://aerospike.com/docs/database/manage/cluster/udfs.md): This document details the management of Aerospike User-Defined Functions (UDFs), focusing on registration via asadm and client APIs. It explains the UDF lifecycle, provides a comprehensive list of namespace statistics for monitoring performance, and outlines operational configurations such as Lua module storage paths and caching behavior to optimize latency. - [Configure Aerospike Database](https://aerospike.com/docs/database/manage/database/as-config.md): This document explains how to configure an Aerospike Database node using the `aerospike.conf` file, detailing its structure of contexts and sub-contexts. It highlights critical configuration changes introduced in version 7.0.0 and provides a guide for the experimental YAML configuration feature available in version 8.1.1+, including conversion steps via the `asconfig` tool. - [Cold restart](https://aerospike.com/docs/database/manage/database/cold-start.md): This document explains how Aerospike cold restarts rebuild namespace indexes by scanning data storage. It details specific triggers for cold starts, such as daemon crashes or CE edition usage, and discusses performance impacts related to storage media and strong consistency settings. Additionally, it provides guidance on avoiding the resurrection of deleted records (zombie records). - [Aerospike daemon](https://aerospike.com/docs/database/manage/database/daemon.md): This document provides instructions for controlling the Aerospike daemon (`asd`) using either systemd or System V init.d, detailing commands for starting, stopping, and performing cold restarts. It also explains critical system configurations required for the daemon to run, including specific kernel parameters and ulimit settings for root and non-root users. - [Directory structure](https://aerospike.com/docs/database/manage/database/directory-structure.md): This document details the `/opt/aerospike` directory layout for tools and runtime operations. It explains the purpose of the `bin` and `lib` folders, as well as critical System MetaData (`smd`) files like `sindex.smd` and `UDF.smd`. It also distinguishes between static server content in `sys` and administrator-registered UDFs in `usr`. - [Fast restart](https://aerospike.com/docs/database/manage/database/fast-start.md): This document explains the fast restart feature for Aerospike EE and SE, detailing how persisting indexes avoids full data reads during startup. It covers performance differences between storage media, the use of the Aerospike Shared Memory Tool (ASMT) for host reboots, and how to monitor shared memory blocks using `ipcs -m`. - [Multiple database instances](https://aerospike.com/docs/database/manage/database/multiple.md): This document provides a step-by-step procedure for running multiple independent Aerospike Daemon (asd) instances on a single node, specifically to leverage NUMA pinning. It details how to create custom systemd service files and configure unique ports, work directories, and Lua paths for each instance. It also recommends using rack awareness for instances sharing a physical host. - [Configure Aerospike to run as non-root](https://aerospike.com/docs/database/manage/database/non-root.md): This document provides step-by-step instructions to configure Aerospike to run as a non-root user. It details how to handle shared memory blocks during upgrades, set systemd User/Group settings, manage permissions for data directories and raw SSD devices via udev rules, and apply required Linux kernel tuning parameters. - [Configure strong consistency](https://aerospike.com/docs/database/manage/namespace/consistency.md): This guide provides step-by-step instructions for configuring Aerospike namespaces in strong consistency (SC) mode. It covers essential tasks such as managing the node roster via asadm or asinfo, implementing rack awareness with active rack designation, and optimizing settings for expiration and commit-to-device. Additionally, it emphasizes the critical role of clock synchronization to prevent data loss. - [Configure namespace durability](https://aerospike.com/docs/database/manage/namespace/durability.md): This document explains how to protect Aerospike data from server failure using intracluster and cross-datacenter replication. It details the `replication-factor` setting for synchronous local copies, including its impact on storage and performance, and introduces XDR for asynchronous replication between clusters in Enterprise Edition. - [Manage namespaces](https://aerospike.com/docs/database/manage/namespace.md): This document provides instructions on managing Aerospike Database namespaces, including how to add or remove them by modifying the aerospike.conf file. It also details a multi-step process for renaming namespaces, which involves stopping traffic, backing up data with asbackup/asrestore, and updating the configuration before restoring records into the new namespace. - [Configure the primary index](https://aerospike.com/docs/database/manage/namespace/primary-index.md): This guide details how to configure the Aerospike primary index using shared memory, PMem, or NVMe Flash storage via the `index-type` parameter. It provides specific Linux kernel tuning, filesystem requirements (XFS/DAX), and capacity planning examples for large datasets. Additionally, it outlines configuration differences between Database 7.0.0 and earlier versions. - [Configure rack awareness (AP)](https://aerospike.com/docs/database/manage/namespace/rack-aware.md): This guide explains how to implement rack awareness in Aerospike AP namespaces to ensure replicas are stored across separate hardware failure groups using the `rack-id` parameter. It provides instructions for static and dynamic configuration via `aerospike.conf` or `asadm`, setting up client-side rack-aware reads, and designating an active rack to hold all master partitions. - [Configuring namespace data retention](https://aerospike.com/docs/database/manage/namespace/retention.md): This guide details Aerospike namespace data retention, focusing on TTL management, LRU eviction behavior, and NSUP configuration. It covers critical settings for stop-writes thresholds across different database versions and explains how to prevent record resurrection during cold restarts using durable deletes and the ASMT tool. - [Manage sets](https://aerospike.com/docs/database/manage/namespace/sets.md): This guide provides detailed instructions on managing Aerospike sets, including creating set indexes with sindex-create and configuring set-level TTL and eviction policies. It explains how to prevent storage exhaustion using stop-writes limits and outlines the procedure for truncating sets while ensuring transaction integrity. - [Configure secondary indexes](https://aerospike.com/docs/database/manage/namespace/secondary-index.md): This guide details how to configure Aerospike secondary indexes using the `sindex-type` parameter across SHMem, PMem, and Flash storage. It provides specific Linux kernel settings and filesystem requirements for NVMe/PMem deployments, as well as practical `asadm` commands for creating, listing, and deleting indexes. - [Log management](https://aerospike.com/docs/database/manage/logging/logs.md): This document explains how to set up and manage Aerospike log sinks, including file, syslog, and console options. It provides instructions for static configuration in aerospike.conf and demonstrates how to dynamically change severity levels using asinfo. Additionally, it defines the five severity levels and lists available logging contexts for precise system troubleshooting. - [Manual log rotation](https://aerospike.com/docs/database/manage/logging/manual-rotation.md): This guide provides step-by-step instructions for manually rotating Aerospike log files to free up storage or isolate debug logs. It explains how to move existing logs and trigger rotation by sending a SIGHUP signal to the asd PID. Additionally, it details using the asinfo command to identify current log IDs and their specific file locations on the system. - [Manage log rotation](https://aerospike.com/docs/database/manage/logging/rotation.md): This guide explains how to implement log rotation for Aerospike using the Linux logrotate tool, including installation and policy configuration. It emphasizes the critical use of the sharedscripts directive when rotating multiple logs (such as aerospike.log and xdr.log) to avoid race conditions and provides a method to force-test the rotation process. - [Server logs with systemd](https://aerospike.com/docs/database/manage/logging/systemd.md): This document provides instructions on accessing Aerospike server logs using journalctl, including specific flags for raw output. It explains how to extract logs for the asloglatency tool and offers detailed guidance on configuring systemd's Journal daemon for optimal log rotation, storage persistence, and retention settings. - [Network heartbeat configuration](https://aerospike.com/docs/database/manage/network/heartbeat.md): This document provides detailed instructions for configuring Aerospike's heartbeat protocols using Multicast (UDP) or Mesh (TCP) modes. It outlines specific configuration steps for each mode, explains the role of interval and timeout settings, and offers critical guidance for cloud environments where multicast is unsupported and network variability is higher. - [Network configuration](https://aerospike.com/docs/database/manage/network.md): This document provides a comprehensive guide to configuring Aerospike Database network ports, including service, fabric, heartbeat, and admin ports. It details specific parameters within each sub-stanza, offers practical examples for managing private/public IPs and NAT environments, and explains how to set up secure TLS connections via the admin port. - [Configure IPv6](https://aerospike.com/docs/database/manage/network/ipv6.md): This document provides technical requirements for enabling IPv6 in Aerospike clusters, emphasizing the need for global or site-local addresses over link-local ones. It details necessary Enterprise build settings, such as setting `advertise-ipv6` to true and using heartbeat protocol v3, while listing compatible client versions for Java, C, and C#. - [TLS configuration](https://aerospike.com/docs/database/manage/network/tls.md): This document provides step-by-step instructions for enabling TLS encryption for client, node-to-node, and XDR traffic in Aerospike Database EE/FE. It details the configuration of standard and mutual authentication (mTLS), including specific network stanzas and certificate requirements. Additionally, it covers rolling upgrade paths, certificate blacklisting, and a guide for generating self-signed certificates using OpenSSL. - [Feature-Key File](https://aerospike.com/docs/database/manage/planning/feature-key.md): This document explains how to manage the cryptographically-signed feature-key file required for Aerospike Database Enterprise and Standard Editions. It details various loading methods, including the filesystem, environment variables, HashiCorp Vault, and Aerospike Secret Agent, while providing configuration examples for the `service` stanza. Additionally, it covers updating keys and performing rolling restarts to apply changes across a cluster. - [Server hardware requirements](https://aerospike.com/docs/database/manage/planning/hardware.md): This document provides detailed hardware specifications for Aerospike Database deployments. It outlines minimum requirements and optimization tips for CPUs (x86-64-v2/ARMv8.2-A), RAM efficiency for indexing records, and the use of SSDs in Hybrid Memory architectures to achieve high cost-performance ratios. - [Planning](https://aerospike.com/docs/database/manage/planning.md): This document outlines system requirements for Aerospike Database across various Linux distributions and ARM architectures. It provides minimum specifications for development environments and a structured framework for production deployment planning, including guidance on estimating data size, selecting storage types (SSD, PMEM, or memory), and configuring namespaces. - [Network](https://aerospike.com/docs/database/manage/planning/network.md): This document details Aerospike's network usage, including specific TCP ports (3000-3004) and topology requirements for security and performance. It offers technical guidance on scaling TPS through interrupt balancing and link aggregation, while advising against the use of third-party load balancers and Storm Control to ensure cluster stability. - [Audit trail](https://aerospike.com/docs/database/manage/security/audit-trail.md): This document explains how to configure the audit trail in Aerospike Enterprise and Federal Editions using security and logging blocks. It details the pipeline from event generation to sinks like syslog or files and specifies the `sys-admin` role required for setup. It also provides a comprehensive guide to parsing result tags, actions, and detailed log entries for data operations and masking violations. - [Configure encryption at rest](https://aerospike.com/docs/database/manage/security/encryption.md): This guide details how to implement encryption at rest in Aerospike Enterprise Edition using XTS-AES and PBKDF2. It explains the hierarchy of Data Encryption Keys (DEK) and Key Encryption Keys (KEK), provides configuration steps for key management, and outlines procedures for rotating keys or wiping storage. It also analyzes performance impacts relative to record size and hardware acceleration. - [Configuring LDAP](https://aerospike.com/docs/database/manage/security/ldap.md): This document details the configuration of LDAP for external authentication in Aerospike Database Enterprise Edition. It covers essential `aerospike.conf` parameters, explains the difference between Direct Bind and Query User DN methods, and provides implementation examples for Active Directory and OpenLDAP. Users will also find guidance on enabling TLS, integrating with XDR, and debugging via security logs. - [Configure access control](https://aerospike.com/docs/database/manage/security/rbac.md): This guide provides a comprehensive walkthrough for enabling role-based access control (RBAC) in Aerospike EE and FE. It details how to use the `asadm` tool to manage users and roles, explains specific privilege scopes, and covers securing system metadata files. Additionally, it includes a minimum client version matrix for RBAC, LDAP, and PKI authentication support. - [Integrating with secrets management services](https://aerospike.com/docs/database/manage/security/secrets.md): This guide explains how Aerospike Enterprise Edition uses the Secret Agent proxy to fetch sensitive configurations from AWS, GCP, and Hashicorp Vault. It details connection methods via TCP/TLS or Unix Domain Sockets and lists supported configuration parameters that can be retrieved using the `secrets:[resource:]key` format. - [Secrets in HashiCorp Vault](https://aerospike.com/docs/database/manage/security/vault.md): This document explains how Aerospike Database Enterprise Edition integrates with HashiCorp Vault to securely fetch configuration secrets like encryption keys and passwords using a `vault:` prefix. It details required service stanza parameters, base64 encoding requirements for KV secrets, and the process for dynamically updating Vault tokens via asadm starting in version 6.3.0. - [Disk usage and defragmentation](https://aerospike.com/docs/database/reference/faq/ops-disk-defrag.md): This document explains how Aerospike's streaming write buffer and non-in-place updates lead to fragmentation. It details the background defragmentation process and provides specific guidance on tuning parameters like defrag-lwm-pct and defrag-sleep to manage write amplification, optimize disk I/O, and maintain available storage capacity. - [Frequently Asked Questions (FAQ)](https://aerospike.com/docs/database/reference/faq.md): This FAQ provides comprehensive answers on Aerospike Database editions (CE, SE, EE, FE), hardware compatibility including ARM support, and storage optimizations for SSDs. It details the implementation of multi-record transactions, data masking functionality, and specific procedures for validating software package signatures and checksums. - [Secondary index operations](https://aerospike.com/docs/database/reference/faq/ops-sindex.md): This document details the operational trade-offs of using Aerospike secondary indexes, focusing on capacity planning and performance impacts like replica reads during updates. It explains garbage collection triggers for deletions and provides best practices for choosing between native SIs and application-level indexing via lookup records or transactions. - [XDR operations](https://aerospike.com/docs/database/reference/faq/ops-xdr.md): This document details how Aerospike Cross Datacenter Replication (XDR) affects system resources, including network bandwidth, CPU load from compression, and memory usage for transaction queues. It also compares parallel partition-dedicated recovery versus single-threaded interleaved recovery modes to help administrators optimize performance during backlog catch-up. - [Bin policy](https://aerospike.com/docs/database/manage/xdr/bin-policy.md): This document details the `bin-policy` configuration in Aerospike XDR, explaining options such as `only-changed`, `changed-and-specified`, and `changed-or-specified`. It outlines the resulting storage overhead from last update times (LUT) and bin tombstones, while providing specific examples of how these policies interact with `ignore-bin` and `write-policy`. - [XDR compression, forwarding and deleted records](https://aerospike.com/docs/database/manage/xdr/comp-fwd-deletes.md): This document provides detailed configuration parameters for Aerospike XDR, focusing on data compression settings and the shipment of deleted or expired records. It explains how to filter forwarded records on intermediate nodes using set blacklisting and describes how to configure alternate access addresses to ensure connectivity between source and destination clusters. - [Bin convergence](https://aerospike.com/docs/database/manage/xdr/convergence.md): This guide explains how to configure bin convergence to ensure final state consistency in Aerospike active-active XDR topologies. It details critical configuration parameters, storage overhead, and restrictions on client record replace operations. Additionally, it covers the use of durable deletes ("bin cemeteries") and system clock dependencies for conflict resolution. - [Filters](https://aerospike.com/docs/database/manage/xdr/filters.md): This document explains how to use Aerospike Expressions to create XDR shipping filters based on record metadata and bin content. It provides detailed guidance on handling tombstone records for deletes and demonstrates how to set or retrieve filters via asinfo, asadm, and various client libraries with practical examples. - [Dynamic XDR configuration](https://aerospike.com/docs/database/manage/xdr/dynamic-xdr.md): This document provides detailed instructions on managing Aerospike's Cross-Datacenter Replication (XDR) dynamically via the `asadm` and `asinfo` tools. It covers creating datacenters, adding TLS-enabled nodes, and performing shipment rewinds for namespaces. Additionally, it explains XDR recovery modes, including parallel partition-dedicated and single-threaded interleaved recovery. - [XDR record shipment lifecycle](https://aerospike.com/docs/database/manage/xdr/lifecycle.md): This page outlines the Aerospike XDR record shipment process, covering transaction queues, service threads, and recovery modes. It provides technical details on tuning parameters such as ship-versions-policy and recovery-threads to optimize performance and resolve write blocking issues while listing key metrics for monitoring shipment health. - [XDR parameters and metrics](https://aerospike.com/docs/database/manage/xdr/parameters.md): This document provides a detailed mapping of Aerospike XDR configuration parameters and metrics that changed between pre-5.0.0 and version 5.0.0+. It includes tables for finding modern counterparts to legacy settings and comprehensive lists of parameters and metrics completely removed in Database 5.0.0, aiding in cluster upgrades and configuration migration. - [XDR security](https://aerospike.com/docs/database/manage/xdr/security.md): This document details the XDR login process and how to configure authentication using local access control, LDAP, or PKI certificates. It provides specific configuration examples for auth-mode and auth-user, explains session token refreshing, and describes how data masking privileges affect writes at destination clusters during replication. - [Set policy](https://aerospike.com/docs/database/manage/xdr/set-policy.md): This document explains how to use the ship-only-specified-sets, ship-set, and ignore-set parameters to control which Aerospike sets are replicated via XDR. It clarifies that set filtering occurs before records enter the transaction queue and provides practical configuration examples for both including only specific sets and excluding others. - [Static XDR configuration](https://aerospike.com/docs/database/manage/xdr/static-xdr.md): This document explains how to use the `xdr` stanza in the Aerospike configuration file to define target datacenters and namespaces for replication. It provides detailed syntax for parameters like `node-address-port` and `remote-namespace`, along with specific configuration examples for active-passive, mesh, linear chain, and star topologies. - [Write policy](https://aerospike.com/docs/database/manage/xdr/write-policy.md): This document explains how to configure the XDR write-policy (auto, update, replace) at the datacenter or namespace level in Aerospike. It details the complex interactions between write-policy, bin-policy, and ignore-bin settings, providing specific examples of when remote records are merged versus entirely replaced during replication. - [Aerospike Quick Look (AQL)](https://aerospike.com/docs/database/tools/aql.md): This page provides an overview of Aerospike Quick Look (AQL), a CLI tool for browsing data and developing user-defined functions. It details syntax considerations, the removal of the TRUNCATE command in favor of asadm, and recent updates such as double WHERE clauses and limit specifiers. The document also clarifies AQL's current maintenance status regarding security patches. - [Retrieve metadata details](https://aerospike.com/docs/database/tools/aql/metadata.md): This guide details how to use Aerospike Quick Look (AQL) commands to inspect database metadata. It covers listing namespaces, sets, bins, and indexes, while explaining the `explain select` command for accessing record-specific data such as digests, partition IDs, node locations, and replica policies. - [Manage records](https://aerospike.com/docs/database/tools/aql/records.md): This guide details Aerospike Quick Look (AQL) commands for record management, including INSERT INTO, DELETE FROM, and various SELECT query patterns. It explains how to use secondary index predicates, perform aggregations with Stream UDFs, and retrieve records using DIGEST or EDIGEST strings. The document also describes defining complex bin datatypes like MAP, LIST, and GeoJSON. - [Run Aerospike Quick Look](https://aerospike.com/docs/database/tools/aql/run-aql.md): This guide explains how to launch the Aerospike Quick Look (AQL) tool to browse database data, including basic command usage like listing namespaces. It provides a comprehensive list of CLI options for executing files and commands, as well as detailed instructions on managing AQL behavior via configuration files and instance suffixes. - [Configure Aerospike Quick Look settings](https://aerospike.com/docs/database/tools/aql/settings.md): This document provides instructions on retrieving and specifying environment settings within Aerospike Quick Look (AQL) using the get and set commands. It details various configurable parameters such as output formats, socket timeouts, and durable delete flags for strong consistency namespaces. These session-specific settings allow users to customize AQL's behavior for both interactive and non-interactive execution. - [Manage user-defined functions](https://aerospike.com/docs/database/tools/aql/udf.md): This document provides a technical guide on managing Lua User-Defined Functions (UDFs) using Aerospike Quick Look (AQL). It details the exact syntax for registering, executing, listing, describing, and removing UDF modules, including examples of running functions against specific namespaces, sets, or primary keys. - [Log analyzer mode commands](https://aerospike.com/docs/database/tools/asadm/analyzer.md): This document details the commands available in the deprecated log analyzer mode of asadm for analyzing Aerospike server logs. It covers specific operations like grep, count, diff, and histogram calculation, as well as session management for adding and selecting log files. It also suggests modern alternatives such as show latencies and Grafana dashboards. - [Aerospike Admin commands](https://aerospike.com/docs/database/tools/asadm/asadm-commands.md): This document provides a comprehensive reference for the asadm command-line tool used to manage Aerospike clusters. It details available commands like show, manage, and info, explains how to connect via the admin port, and describes modifiers such as for, like, and with. Additionally, it outlines options for non-interactive execution and syntax for running command files. - [Aerospike Admin (asadm)](https://aerospike.com/docs/database/tools/asadm.md): This document provides an overview of Aerospike Admin (asadm), an interactive Python utility for cluster-level monitoring and management. It details how to handle ACLs, UDFs, sindexes, and dynamic configurations across live clusters or via offline collectinfo and log analyzer modes. - [Collectinfo analyzer mode commands](https://aerospike.com/docs/database/tools/asadm/collectinfo.md): This document details the commands available in asadm's collectinfo-analyzer mode, enabling users to diagnose Aerospike clusters using offline archive files. It covers diagnostic tools like `info` for network and namespace stats, `show` for configuration and best-practices analysis, and the `summary` command for a high-level cluster overview. - [Backing Up Indexes with ASMT](https://aerospike.com/docs/database/tools/asmt/backup.md): This guide explains how to use the Aerospike Shared-Memory Tool (ASMT) to back up indexes from shared memory to the filesystem for Enterprise Edition. It details critical prerequisites, such as quiescing and stopping the daemon, and provides specific command examples using options like -b, -p, and -n to ensure a successful backup for future warm starts. - [Live cluster mode commands](https://aerospike.com/docs/database/tools/asadm/live-mode.md): This document provides a comprehensive reference for the asadm tool's live cluster mode, detailing commands for real-time monitoring and administration. It covers privileged mode access, diagnostic tools like info and show, administrative management of ACLs, XDR, and secondary indexes, and instructions for configuring SSH to collect logs and system information from remote nodes. - [Aerospike Shared-Memory Tool (ASMT)](https://aerospike.com/docs/database/tools/asmt.md): This document explains how the Aerospike Shared-Memory Tool (ASMT) enables warm restarts in Enterprise Edition by backing up shared memory segments to disk. It details the process for avoiding time-consuming cold starts and zombie records during maintenance, while outlining specific scenarios where a cold restart is preferable over using ASMT. - [Installing the Aerospike Shared-Memory Tool (ASMT)](https://aerospike.com/docs/database/tools/asmt/install.md): This document provides detailed instructions for acquiring and installing the Aerospike Shared-Memory Tool (ASMT). It specifies automated download URL patterns for Debian and RPM packages across various versions, architectures, and distributions, and includes the exact terminal commands required to install these packages using dpkg and rpm. - [Options for ASMT](https://aerospike.com/docs/database/tools/asmt/options.md): This document provides a comprehensive reference of the command-line flags available for the Aerospike ASMT utility. It details specific options for performing index backups, restores, CRC-32 corruption checks, and compression, while explaining mandatory parameters such as namespace selection and directory paths. This guide is essential for administrators managing shared memory indexes on the file system. - [Restoring Indexes with ASMT](https://aerospike.com/docs/database/tools/asmt/restore.md): This document explains how to use the Aerospike Shared Memory Tool (ASMT) to restore indexes from backup files, enabling a fast warm start. It covers prerequisites, specific command-line flags for namespaces and paths, and provides critical troubleshooting steps for removing failed shared-memory segments using ipcrm if the process is interrupted by an early daemon restart. - [Migration from legacy tools](https://aerospike.com/docs/database/tools/backup-and-restore/legacy-migration.md): This guide explains how to transition from legacy C-based asbackup and asrestore tools to the Go-based Aerospike Backup Control (absctl). It includes version prerequisites, OS compatibility details, and step-by-step upgrade instructions for Linux, Windows, and macOS. - [Backup and restore overview](https://aerospike.com/docs/database/tools/backup-and-restore/overview.md): This guide compares Aerospike's backup and restore tools—ABS, absctl, and legacy utilities—to help you select the best solution for your environment. It details key features like cloud storage support, compression, encryption, and full versus incremental backup architectures to ensure effective data protection. - [Download Aerospike tools](https://aerospike.com/docs/database/tools/install.md): This guide provides instructions for acquiring Aerospike tools packages (.rpm, .deb, and .pkg) for 64-bit Linux and macOS. It details manual download methods from the official website and explains how to automate downloads using specific URL patterns and naming conventions from the artifact repository. - [Deploying Aerospike Tools with Docker](https://aerospike.com/docs/database/tools/install/docker.md): This guide provides instructions for deploying and managing Aerospike tools using Docker containers. It features specific command-line examples for essential utilities like asadm, asinfo, AQL, asloglatency, asbackup, and asrestore, including how to use volume mounts and configuration flags. - [Install Tools on macOS](https://aerospike.com/docs/database/tools/install/mac.md): This guide provides instructions for installing Aerospike Tools on macOS 14 or later. It covers downloading the installation package, using pkgutil to remove older versions to avoid conflicts, and verifying specific command-line tools like asadm, aql, asinfo, asbackup, and asrestore. - [Install tools on Linux](https://aerospike.com/docs/database/tools/install/linux.md): This document provides detailed instructions for installing Aerospike Tools on supported Linux distributions including RHEL, Debian, and Ubuntu. It covers essential prerequisites, installation via tarball or native package managers like RPM and dpkg, and commands to verify the tool installation. - [Relocate tools on RHEL](https://aerospike.com/docs/database/tools/install/relocate.md): This guide details how to use the --relocate flag during Aerospike tools RPM installation on RHEL to change default paths like /opt, /usr, and /etc. It includes a command example and warns of potential issues such as broken symlinks, configuration file pathing for asadm and asinfo, and user creation errors. - [Aerospike tools requirements](https://aerospike.com/docs/database/tools/install/requirements.md): This document details the system requirements for installing Aerospike tools, specifying supported 64-bit Linux distributions and macOS versions. It provides specific guidance on Python 3 dependencies for tools like asloglatency, asadm, and asinfo, including legacy package requirements for older tool releases. - [Install Secret Agent](https://aerospike.com/docs/database/tools/secret-agent/install.md): This guide provides step-by-step instructions for installing Aerospike Secret Agent on Linux using package managers or via Docker containers. It covers deployment best practices, configuration examples, systemd service setup for non-root users, and a complete workflow for running Secret Agent alongside the Aerospike Database Enterprise Edition in Docker. - [Metrics](https://aerospike.com/docs/database/tools/secret-agent/metrics.md): This document explains how to expose Secret Agent metrics via Prometheus endpoints or a 10-second log ticker. It provides configuration examples for HTTP/HTTPS services, detailed tables of listener and secret manager metrics for AWS and GCP, instructions for adding custom labels, and the specific format used in log outputs. - [Aerospike Secret Agent](https://aerospike.com/docs/database/tools/secret-agent.md): This guide explains how Aerospike Secret Agent acts as a proxy to fetch sensitive values like TLS certificates and passwords from external managers such as AWS, GCP, or HashiCorp Vault. It details supported connection types including TCP, UDS, and HTTP/HTTPS, while listing specific configuration parameters that can be integrated using the `secrets:` prefix for enhanced security. - [Aerospike Secret Agent release notes](https://aerospike.com/docs/database/tools/secret-agent/release-notes.md): This document provides a chronological history of Aerospike Secret Agent releases, detailing version-specific updates from 1.0.0 to 1.3.0. It covers major feature additions like HashiCorp Vault support and REST interfaces, alongside critical security patches, bug fixes, and breaking changes regarding package naming. - [Configuration template](https://aerospike.com/docs/database/tools/secret-agent/template.md): This YAML template provides a comprehensive guide to configuring the Aerospike Secret Agent. It details all available options for service listeners—including TCP, UDS, HTTP, and HTTPS—and various secret managers like AWS, GCP, Vault, and local files. The document specifies mandatory fields and configuration requirements to ensure a valid setup. - [Aerospike Voyager](https://aerospike.com/docs/database/tools/voyager.md): This document introduces Aerospike Voyager, a free desktop application for macOS, Windows, and Linux used to visually explore, filter, and edit data in Aerospike Database. It covers features such as cluster connection management, visual browsing of namespaces and sets, expression-based querying, and an embedded MCP server for AI coding agents. - [Install Voyager](https://aerospike.com/docs/database/tools/voyager/install.md): This guide provides comprehensive instructions for installing, updating, and uninstalling Aerospike Voyager on macOS, Windows, and Linux. It details platform-specific installation methods like .dmg and .deb packages, outlines system prerequisites, and explains how to manage software updates or perform a factory reset. - [Release notes](https://aerospike.com/docs/database/tools/voyager/release-notes.md): This document provides the release notes for Aerospike Voyager 0.2.2, highlighting its debut as a preview version. Key features include a visual data browser, an AEL-supported filter builder, SDK code generation for record editing, and an embedded MCP server that allows AI coding agents to manage clusters directly. - [Voyager quickstart](https://aerospike.com/docs/database/tools/voyager/quickstart.md): This guide provides a step-by-step introduction to Aerospike Voyager, covering cluster connection, loading sample datasets, and browsing record data. It teaches users how to build filters using the visual builder or raw expressions and shows how to implement these filters in Java or Python SDKs using generated code snippets. - [Telemetry](https://aerospike.com/docs/database/tools/voyager/telemetry.md): This guide explains how Aerospike Voyager uses anonymous telemetry via PostHog to improve features without collecting PII. It covers the process for opting out of usage analytics, describes the specific types of metadata collected, and provides a comprehensive list of sensitive data—like credentials and record values—that are never tracked. - [Voyager troubleshooting](https://aerospike.com/docs/database/tools/voyager/troubleshooting.md): This guide provides solutions for common Aerospike Voyager issues, ranging from connection and TLS failures to MCP server and AI agent connectivity problems. It also covers data browsing troubleshooting, platform-specific warnings, and instructions for enabling debug logging to assist in bug reporting. - [Developing UDF Modules](https://aerospike.com/docs/database/advanced/udf/modules.md): This guide explains how to create and register Lua UDF modules in Aerospike, including naming constraints and security restrictions on the `io` and `os` libraries. It provides practical examples of module interdependence and demonstrates how to extend Lua functionality by compiling and integrating C functions as shared objects. - [Consistency modes](https://aerospike.com/docs/database/learn/architecture/clustering/consistency-modes.md): This document explains Aerospike's AP and Strong Consistency (SC) modes, detailing how each handles network partitions. It describes the technical mechanisms of SC mode, including node rosters, hybrid clocks with regimes, and rules for partition availability to prevent write loss. It also contrasts session consistency with global linearizability read policies. - [Clustering](https://aerospike.com/docs/database/learn/architecture/clustering.md): This guide details Aerospike's shared-nothing clustering architecture, explaining how heartbeat mechanisms and Paxos-based gossip voting enable self-healing and automatic data rebalancing. It describes the process of partition migration during node failures or additions and explains how the Aerospike client optimizes requests via automatic data location detection. - [Data distribution](https://aerospike.com/docs/database/learn/architecture/clustering/data-distribution.md): This document explains Aerospike's shared-nothing architecture, detailing how records are mapped to 4096 logical partitions using RIPEMD160 hashing. It covers the configuration of replication factors, the function of succession lists in node ownership, and provides a technical walkthrough of data movement during rolling restarts and cluster failures. - [Rack awareness](https://aerospike.com/docs/database/learn/architecture/clustering/rack-aware.md): This document explains Aerospike's rack awareness feature, which prevents data unavailability by distributing master and replica partitions across separate hardware failure groups or Availability Zones using `rack-id`. It covers the "active rack" designation for Database 7.2.0+, how replication factors interact with rack counts, and how clients can optimize latency by reading from the closest rack. - [Data model](https://aerospike.com/docs/database/learn/architecture/data-storage/data-model.md): This guide details the Aerospike schemaless data model, explaining the hierarchy of namespaces, records, sets, and bins. It covers physical storage options like NVMe and DRAM, record metadata such as TTL and generation counts, and how dynamic bin typing allows for flexible data structures without a predefined schema. - [Primary index](https://aerospike.com/docs/database/learn/architecture/data-storage/primary-index.md): This document explains how Aerospike's primary index uses metadata and a distributed hash table structure to ensure low-latency data access. It details the role of "sprigs" in reducing lock contention and traversal latency, while outlining storage options like NVMe SSD and Persistent Memory for Enterprise Edition users. - [Resilience](https://aerospike.com/docs/database/learn/architecture/data-storage/resilience.md): This document explains how Aerospike groups record writes into an 8MiB streaming write buffer to optimize disk I/O. It details the role of flush-size and max-write-cache in managing pending writes. Additionally, it outlines a tiered throttling circuit-breaker that prevents device overload by failing specific write types—such as UDFs, durable deletes, and replica writes—at defined thresholds. - [Secondary index](https://aerospike.com/docs/database/learn/architecture/data-storage/secondary-index.md): This document explains Aerospike's secondary indexes, covering both bin-based and expression indexing for high-performance queries. It details the System Metadata (SMD) workflow for index creation, the scatter-gather process for distributed queries, and storage options including shared memory, flash, and persistent memory. - [Configure Aerospike Prometheus Exporter](https://aerospike.com/docs/database/observe/monitor/configure/exporter.md): This document provides detailed instructions for configuring the `ape.toml` file, covering both the `[Agent]` and `[Aerospike]` sections. It explains how to set up TLS certificates, authentication, and network settings, while also detailing how to use regex-based allowlists and blocklists to filter specific Aerospike metrics and user statistics. - [Set index](https://aerospike.com/docs/database/learn/architecture/data-storage/set-index.md): This document explains how set indexes optimize membership queries in Aerospike, detailing the "1% rule" for efficiency and the memory cost of 16 bytes per record. It compares set indexes to legacy secondary index hacks and provides instructions on using `sindex-create` and `sindex-delete` commands introduced in version 8.1.2. - [Configure the Aerospike monitoring stack](https://aerospike.com/docs/database/observe/monitor/configure.md): This document provides high-level guidance on setting up the Aerospike monitoring stack. It directs users to specific procedures for configuring the Aerospike Prometheus Exporter via ape.toml, setting up Prometheus and AlertManager for metric scraping and alerting, and integrating Grafana with necessary datasources and dashboards. - [Configure Prometheus and AlertManager](https://aerospike.com/docs/database/observe/monitor/configure/prometheus.md): This guide provides step-by-step instructions for configuring a Prometheus server to scrape metrics from the Aerospike Prometheus Exporter and integrate it with AlertManager. It details how to set global parameters, implement pre-defined Aerospike alert rules via YAML configuration, and define specific exporter targets for monitoring. - [Install components separately](https://aerospike.com/docs/database/observe/monitor/install/components.md): This document provides step-by-step guidance for the individual installation of Aerospike monitoring stack components. It covers deploying the Aerospike Prometheus Exporter for database monitoring, setting up Prometheus and Alert Manager, and installing Grafana as the visualization layer. - [Install with Docker](https://aerospike.com/docs/database/observe/monitor/install/docker.md): This guide provides step-by-step instructions for deploying an Aerospike monitoring stack using Docker containers. It covers running the Prometheus Exporter, configuring a Prometheus scrape target via a YAML file, and launching Grafana on port 3003 to avoid conflicts with database ports. It also directs users to GitHub for importing pre-built monitoring dashboards. - [Deploying on a Kubernetes Cluster](https://aerospike.com/docs/database/observe/monitor/install/kubernetes.md): This document provides guidance on configuring the Aerospike monitoring stack within a Kubernetes environment. It directs users to the Aerospike Kubernetes Operator documentation for detailed instructions on deploying the Prometheus Exporter sidecar and other essential monitoring components. - [Configure Grafana](https://aerospike.com/docs/database/observe/monitor/configure/grafana.md): This document provides step-by-step instructions for configuring a Grafana server to monitor Aerospike. It covers editing the grafana.ini file to resolve port conflicts, installing the Prometheus Alertmanager plugin, and deploying official Aerospike monitoring dashboards from GitHub via the provisioning directory. - [Install Prometheus Exporter on Linux](https://aerospike.com/docs/database/observe/monitor/install/linux.md): This guide provides step-by-step instructions for installing the Aerospike Prometheus Exporter on Linux systems. It covers installation via RPM for Red Hat and DEB packages for Debian-derived distributions, as well as manual binary setup with systemd integration. Additionally, it details package naming conventions for various architectures including x86_64 and ARM64. - [Configure storage compression](https://aerospike.com/docs/database/manage/namespace/storage/compression.md): This guide explains how to implement lossless storage compression in Aerospike Enterprise Edition using LZ4, Snappy, or Zstandard algorithms across SSD, RAM, and PMem. It details the configuration of `compression` and `compression-level` directives via config files or asadm and describes how to monitor efficiency using the `device_compression_ratio` statistic. - [Start monitoring stack components](https://aerospike.com/docs/database/observe/monitor/install/start.md): This document provides step-by-step instructions for starting the Aerospike monitoring stack components. It covers running the Aerospike Prometheus Exporter, setting up Prometheus as a systemd service or via binary execution with specific configuration paths, and initiating the Grafana server to enable database observability. - [Configure namespace storage](https://aerospike.com/docs/database/manage/namespace/storage/config.md): This guide details the configuration of Aerospike namespace storage engines, including SSD, Intel Optane PMem, and in-memory options with or without persistence. It provides specific setup snippets, explains shadow device mirroring for cloud environments, and offers troubleshooting steps for managing low storage alerts and updating filesize parameters. - [Defragmentation](https://aerospike.com/docs/database/manage/namespace/storage/defrag.md): This guide details how Aerospike defragmentation compacts write-blocks to reclaim space from stale records. It covers critical configuration parameters such as the low water mark (`defrag-lwm-pct`), provides instructions for increasing the defrag rate using `asadm`, and explains how to monitor storage health through server logs and metrics. - [Provisioning a cluster](https://aerospike.com/docs/database/manage/planning/capacity/provisioning.md): This document provides concrete hardware provisioning examples for Aerospike clusters based on workload metrics like object count and throughput. It outlines CPU, RAM, and SSD requirements for flash-based and in-memory databases, explains persistence sizing rules for memory namespaces, and suggests specific Amazon EC2 instance families for cloud deployments. - [Secondary index capacity planning](https://aerospike.com/docs/database/manage/planning/capacity/secondary-indexes.md): This document provides technical guidelines for estimating the spatial cost of Aerospike secondary indexes. It details version-specific planning, including 14-byte entry costs and B-tree sparseness for Database 6.0+, and complex estimation formulas based on unique keys and record thresholds for Database 5.7 and earlier. It also covers memory allocation increments via sindex-stage-size and the impact of lists, maps, and GeoJSON data types. - [Capacity planning guide](https://aerospike.com/docs/database/manage/planning/capacity.md): This guide provides technical formulas to calculate Aerospike Database hardware requirements. It covers memory and disk needs for the primary index—including All Flash sprig calculations—set indexes, and per-record data storage overhead based on bin types and versions. It also addresses defragmentation planning and throughput estimations to ensure cluster stability. - [Advanced Flash device sizing](https://aerospike.com/docs/database/manage/planning/ssd/advanced-sizing.md): This technical guide explains how to use the Aerospike Certification Tool (ACT) to select Flash devices based on actual production workloads. It details a process for capturing storage histograms and defragmentation data from a live cluster to configure ACT, align IOSTAT results, and validate that candidate SSDs meet specific performance SLAs. - [Certify Flash devices (SSDs)](https://aerospike.com/docs/database/manage/planning/ssd/certification.md): This document provides detailed performance benchmarks for various Flash and SSD devices using the Aerospike Certification Tool (ACT). It evaluates read latency under sustained write loads based on a 67% read/33% write ratio with 1.5KB objects, covering NVMe, SATA/SAS, networked storage, and cloud instances from AWS and GCP to help users select hardware that meets specific latency SLAs. - [All Flash FAQ](https://aerospike.com/docs/database/manage/planning/ssd/faq.md): This document provides technical guidance on Aerospike's All Flash architecture, specifically focusing on Primary Index (PI) management. It details how to monitor index space usage via metrics and logs, the impact of partition-tree-sprigs on performance, and using `index-pressure` to track dirty pages in RAM. It also addresses mount sharing across namespaces and feature-key licensing requirements. - [LSI StorCLI (AKA MegaCLI)](https://aerospike.com/docs/database/manage/planning/ssd/lsi-megacli.md): This document explains how to optimize LSI RAID controllers for Aerospike using StorCLI (MegaCLI). It details the specific settings required to enable LSI MegaRAID FastPath™—including RAID 0, Write Through, No Read Ahead, and Direct IO—to significantly reduce latency. The guide provides performance test results and practical command-line examples for configuring virtual disks. - [Flash storage](https://aerospike.com/docs/database/manage/planning/ssd.md): This document details Aerospike's optimizations for Flash storage, such as using copy-on-write to ensure even wear and preferring raw block devices over RAID. It provides critical guidance on SSD over-provisioning, the use of the ACT benchmarking tool, and hardware configuration recommendations for NVMe and SATA drives to maximize throughput and minimize latency. - [Manage solid state storage devices](https://aerospike.com/docs/database/manage/planning/ssd/manage.md): This document provides detailed instructions for managing SSDs in Aerospike nodes, focusing on the critical process of zeroizing new and used devices to prevent data corruption. It explains how to configure drives using WWIDs in aerospike.conf and details when to use Fast Start or Cold Start based on storage type and hot-swap capabilities. - [SSD Set up](https://aerospike.com/docs/database/manage/planning/ssd/setup.md): This guide provides technical instructions for optimizing SSD and NVMe devices for Aerospike, emphasizing direct IO and the avoidance of RAID. It details critical setup steps including over-provisioning methods and partitioning strategies aligned with CPU core counts to increase parallelism. It also warns against sharing devices across namespaces and includes a practical fdisk example. - [SSD Over-Provisioning](https://aerospike.com/docs/database/manage/planning/ssd/over-provisioning.md): This guide explains how to over-provision SSDs to maintain write performance for Aerospike, recommending a 21% reserve. It provides detailed procedures using hdparm for Host Protected Area (HPA) configuration and fdisk or parted for partition-based methods, including RAID controller optimization and AWS EC2 instance specifics. - [Aerospike XDR Proxy](https://aerospike.com/docs/database/manage/xdr/proxy.md): This document provides an overview of the Aerospike XDR Proxy, which simplifies cross-region replication by using a single endpoint to resolve cloud networking and security challenges. It explains how the proxy utilizes the Java Client to transmit record updates, inserts, and deletions while noting critical considerations regarding record ordering. - [Install the XDR Proxy](https://aerospike.com/docs/database/manage/xdr/proxy/install.md): This guide provides detailed installation steps for the Aerospike XDR Proxy across multiple platforms. It covers Java 17 prerequisites and native package deployment for RHEL, Ubuntu, Debian, and Amazon Linux, alongside instructions for deploying via Helm charts on Kubernetes and running the proxy as a Docker container using custom configuration files. - [Aerospike XDR proxy release notes](https://aerospike.com/docs/database/manage/xdr/proxy/release-notes.md): This document provides a comprehensive version history of the Aerospike XDR proxy connector from v1.0.0 to v4.0.0. It details critical security patches, CVE fixes, and evolving Java runtime requirements, including the transition to Java 17 in v4.0.0. It allows users to track new features like Prometheus integration and ensure deployment stability through version updates. - [Prometheus Integration](https://aerospike.com/docs/database/manage/xdr/proxy/prometheus-integration.md): This document provides a direct reference for integrating Aerospike's XDR proxy with Prometheus. It points users toward the detailed technical documentation regarding the REST endpoint used to export and monitor system metrics via Prometheus. - [Install Aerospike Backup Control (absctl)](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/install.md): This guide provides step-by-step instructions for installing the Aerospike Backup Control (absctl) CLI tool. It covers multiple deployment options including pre-built binaries for Linux and macOS, running via Docker containers, and building from source code. Users will find specific commands to install the tool and verify its functionality before proceeding to backup or restore operations. - [Aerospike Backup Control quickstart](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/quickstart.md): This guide demonstrates a minimal end-to-end workflow for backing up and restoring Aerospike namespaces using the absctl CLI tool within Docker containers. It covers creating local backup directories, generating .asb files via `absctl backup`, and performing data recovery with `absctl restore` while verifying results through operation reports. - [Aerospike Backup Control release notes](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/release-notes.md): This document details the release of absctl 1.0.0, a unified CLI replacing legacy asbackup and asrestore tools. It covers key enhancements including native cloud storage support (S3, GCS, Azure), AZ-aware backups to reduce network costs, and improved partition-based scanning, while confirming backward compatibility with .asb files. - [Secret usage with backup and restore](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/secrets.md): This document explains how to integrate the Aerospike Secret Agent with absctl backup and restore to avoid storing passwords and TLS certificates locally. It details specific connection options, the `secrets[:resource]:key` syntax for arguments, and provides implementation examples using both CLI flags and YAML configuration files. - [Legacy Aerospike backup tool (asbackup)](https://aerospike.com/docs/database/tools/backup-and-restore/asbackup.md): This guide covers the legacy `asbackup` tool used to create backups of Aerospike Database clusters to local directories or Amazon S3. It specifies the default backup content, including keys, secondary index definitions, and UDF modules, while highlighting critical limitations such as required read privileges and zstd compression support. - [Estimate resources for Aerospike backup](https://aerospike.com/docs/database/tools/backup-and-restore/asbackup/resources.md): This guide provides technical formulas to estimate the resources required by the asbackup tool (v3.11.0+). It details how to calculate memory usage based on parallel threads, approximate disk space via record sampling with the --estimate flag, and determine the necessary number of file descriptors based on cluster size and output settings. - [Back up data to Amazon S3](https://aerospike.com/docs/database/tools/backup-and-restore/asbackup/s3.md): This guide explains how to use the asbackup tool to transfer Aerospike data to Amazon S3 using the s3:// prefix. It details critical configuration options such as region settings, asynchronous upload limits, and part size calculations. Additionally, it provides a comprehensive IAM policy example to ensure all necessary bucket permissions are in place for successful backups. - [Secret usage with backup and restore](https://aerospike.com/docs/database/tools/backup-and-restore/asbackup/secrets.md): This document explains how to integrate asbackup and asrestore with the Aerospike Secret Agent to avoid storing sensitive information locally. It details connection options, the specific secret argument format (secrets:resource:key), and provides examples for both command-line usage and TOML configuration files, including notes on Base64 encoding requirements. - [Run Aerospike backup](https://aerospike.com/docs/database/tools/backup-and-restore/asbackup/use.md): This document provides comprehensive instructions for using the `asbackup` tool to back up Aerospike namespaces. It details essential command-line options for connection, TLS security, zstd compression, and AES encryption. Additionally, it explains how to perform incremental backups using timestamps, filter expressions, and partition lists, as well as how to resume interrupted jobs via state files. - [Legacy Aerospike restore tool (asrestore)](https://aerospike.com/docs/database/tools/backup-and-restore/asrestore.md): This guide details the legacy asrestore CLI tool for restoring Aerospike backups created via asbackup. It explains key behaviors such as TTL preservation and cluster-agnostic distribution, and specifies the RBAC privileges needed to restore data, UDFs, and secondary indexes. The document also notes that asrestore is now deprecated in favor of absctl restore. - [Estimate resources for Aerospike restore](https://aerospike.com/docs/database/tools/backup-and-restore/asrestore/resources.md): This guide provides specific formulas to estimate memory usage and file descriptor requirements when running the `asrestore` tool. It details how flags like `--parallel`, `--batch-size`, and `--max-async-batches` impact resources, while distinguishing between batch write scenarios and individual record uploads to prevent system failures. - [Restore data from Amazon S3](https://aerospike.com/docs/database/tools/backup-and-restore/asrestore/s3.md): This guide explains how to use the `asrestore` tool to restore Aerospike backups stored in Amazon S3 buckets. It provides a practical command-line example, details the necessary AWS IAM permissions for bucket access, and lists specific configuration options like `--s3-region` and `--s3-max-async-downloads` to optimize the restoration process. - [Run Aerospike restore](https://aerospike.com/docs/database/tools/backup-and-restore/asrestore/use.md): This guide explains how to use `asrestore` to recover Aerospike backups, detailing connection settings, TLS configuration, and input methods including stdin piping. It provides critical technical details on write policies for duplicate keys, performance tuning via batching and throttling, and data selection filters for namespaces, sets, and bins. - [Validate backup files with asrestore](https://aerospike.com/docs/database/tools/backup-and-restore/asrestore/validate.md): This guide details using the `asrestore` tool's `--validate` mode to identify parsing errors within Aerospike backup files without requiring a database connection. It includes a step-by-step example showing how to intentionally corrupt a backup and use the validation flag to detect the error. Users will learn which input options are supported and the limitations of the tool in detecting non-parsing corruption. - [API usage examples](https://aerospike.com/docs/database/tools/backup-and-restore/backup-service/api-examples.md): This document provides practical examples of Aerospike Backup Service (ABS) REST API requests and responses. It details how to trigger on-demand full or incremental backups, perform direct or point-in-time restores, and retrieve service configurations for clusters, routines, and storage destinations. - [Change backup storage destination](https://aerospike.com/docs/database/tools/backup-and-restore/backup-service/change-storage.md): This guide provides step-by-step instructions for changing the storage destination of Aerospike Backup Service (ABS) routines. It details how to migrate existing data or start new backups, explains the role of metadata.yaml in baseline detection for incremental backups, and describes the API calls needed to reload configurations and verify successful migration. - [ABS configuration file examples](https://aerospike.com/docs/database/tools/backup-and-restore/backup-service/config-examples.md): This document provides detailed YAML examples and explanations for the Aerospike Backup Service (ABS) configuration file. It covers key sections including cluster connectivity, secret agent integration, various storage backends (S3, Azure, GCP, local), backup policies, and scheduling routines, while providing specific sample setups for Linux and Docker Compose environments. - [Aerospike Backup Service (ABS)](https://aerospike.com/docs/database/tools/backup-and-restore/backup-service.md): This document introduces the Aerospike Backup Service (ABS), a standalone tool for automating full and incremental backups through a REST API. It covers installation options across Linux, Kubernetes, and Docker Compose, as well as guidance on configuring backup policies via YAML files and accessing the OpenAPI specification. - [Install and test ABS](https://aerospike.com/docs/database/tools/backup-and-restore/backup-service/install.md): This guide provides step-by-step instructions for deploying the Aerospike Backup Service (ABS) across Linux distributions, Kubernetes clusters, and Docker Compose environments. It covers installation verification, default configuration updates, and a comprehensive walkthrough of testing ABS functionality using its REST API to manage backup routines and policies. - [ABS Monitoring](https://aerospike.com/docs/database/tools/backup-and-restore/backup-service/monitoring.md): This guide explains how to monitor Aerospike Backup Service (ABS) using Prometheus metrics and Grafana dashboards. It provides detailed application metrics, example PromQL queries for performance tracking, and pre-configured alert rules for job failures or delays. The document also covers process and Go runtime metrics and available HTTP endpoints to ensure optimal service health. - [Parallel backups](https://aerospike.com/docs/database/tools/backup-and-restore/backup-service/parallel-backup.md): This guide explains how to use multiple Aerospike Backup Service (ABS) instances to perform parallel backups by slicing clusters via node, rack, or partition lists. It provides YAML configuration examples and an end-to-end workflow for testing data generation, backup execution, and restoration. Additionally, it offers scaling guidelines to optimize scan bandwidth and writer concurrency. - [Aerospike Backup Service performance tuning](https://aerospike.com/docs/database/tools/backup-and-restore/backup-service/performance-tuning.md): Tune the Aerospike Backup Service process for throughput and efficiency. - [Configure TCP](https://aerospike.com/docs/database/tools/secret-agent/listener/tcp.md): This guide explains how to configure a TCP listener for Aerospike Secret Agent, which is necessary for cross-host deployments or when TLS encryption is required. It provides YAML configuration examples for setting up endpoints and implementing both one-way and mutual TLS authentication using PEM certificates. - [Aerospike Backup Service quickstart](https://aerospike.com/docs/database/tools/backup-and-restore/backup-service/quickstart.md): This guide provides a step-by-step walkthrough for deploying Aerospike Backup Service (ABS) in a local Docker Compose environment with MinIO storage. It covers triggering backup and restore operations via REST API and setting up a monitoring pipeline using Prometheus and Grafana to visualize job status and performance metrics. - [Configure HTTP and HTTPS](https://aerospike.com/docs/database/tools/secret-agent/listener/http.md): This guide explains how to configure HTTP and HTTPS listeners in Aerospike Secret Agent to expose REST APIs for secrets and Prometheus metrics. It details configuration parameters for endpoints, TLS settings, and custom URL base paths, while providing endpoint specifications and practical curl examples for various authentication scenarios. - [Configure UDS](https://aerospike.com/docs/database/tools/secret-agent/listener/uds.md): This guide details how to configure a Unix Domain Socket (UDS) listener within the Secret Agent service using the socket-path parameter. It covers configuration syntax, file system access requirements, and how Secret Agent manages socket file creation, permissions, and lifecycle during process execution. - [GCP Secret Manager](https://aerospike.com/docs/database/tools/secret-agent/secret-manager/gcp.md): This guide details how to configure Aerospike Secret Agent to retrieve secrets from GCP Secret Manager using attached service accounts, Application Default Credentials, or service account impersonation. It also provides practical instructions for accessing secrets across multiple GCP projects and managing different secret versions through YAML configuration files. - [AWS Secrets Manager](https://aerospike.com/docs/database/tools/secret-agent/secret-manager/aws.md): This guide details how to authenticate Aerospike Secret Agent with AWS Secrets Manager through three methods: IMDS, static credentials, and AssumeRole. It provides step-by-step instructions, sample YAML configuration files, and necessary IAM policies for each authentication approach. - [HashiCorp Vault](https://aerospike.com/docs/database/tools/secret-agent/secret-manager/vault.md): This guide explains how to configure Aerospike Secret Agent to fetch secrets from HashiCorp Vault's KV (V2) Secrets Engine. It covers three authentication methods—Token, Username and password, and TLS certificates—providing sample YAML configurations, step-by-step setup instructions, and a complete reference of configuration parameters. - [Browsing data](https://aerospike.com/docs/database/tools/voyager/guides/browsing-data.md): This guide explains how to navigate the Aerospike Voyager hierarchy from clusters down to individual records within sets. It details how to interpret record cards, including metadata chips and type badges, expand nested list or map structures, and perform record lookups using keys or digests. - [Connecting to clusters](https://aerospike.com/docs/database/tools/voyager/guides/connecting.md): This guide details the process of creating, configuring, and managing cluster connections within Aerospike Voyager. It covers essential setup steps such as entering credentials, configuring TLS/mTLS for secure communication, and using advanced settings like "services alternate" for complex network environments. Users also learn how to test connectivity and interpret connection status indicators. - [Editing records](https://aerospike.com/docs/database/tools/voyager/guides/editing-records.md): This guide explains how to create, modify, and delete records using the Aerospike Voyager data browser. It covers adding new records, editing scalars and complex JSON types, and managing destructive operations like truncating sets. You will also learn about supported data types and configuring write policies such as Durable Delete and Record Exists Action. - [Expressions and SDK code](https://aerospike.com/docs/database/tools/voyager/guides/expressions-and-sdk-code.md): This document details the workflow for moving filter expressions from Aerospike Voyager's visual builder directly into production SDK code without rewriting. It provides step-by-step instructions, code examples for Java and Python, and demonstrates how to use these expressions with Complex Data Types (CDT) like lists and maps. - [Filtering records](https://aerospike.com/docs/database/tools/voyager/guides/filtering-records.md): This guide details how to use Aerospike Voyager's dual filtering methods: a visual builder for simple field-based conditions and an expression editor for advanced queries. It provides syntax for complex tasks like CDT list/map access, record metadata filtering, and nested path traversal using the Aerospike Expression Language. - [Sample data](https://aerospike.com/docs/database/tools/voyager/guides/sample-data.md): Learn how to quickly load, explore, and delete pre-built sample datasets in Aerospike Voyager. The guide covers nine sets across Ad tech, E-commerce, and User data domains, providing hands-on ways to practice using the data browser, building visual filters, and inspecting complex nested data types like maps and lists. - [Settings and preferences](https://aerospike.com/docs/database/tools/voyager/guides/settings.md): Learn how to customize Aerospike Voyager by managing preferences across three main categories: General, Security & privacy, and Advanced. This guide details settings for application behavior, telemetry opt-out procedures, connection timeouts, TLS verification modes, and developer tools like debug logging and factory resets. - [MCP server setup](https://aerospike.com/docs/database/tools/voyager/mcp/setup.md): This guide provides instructions for enabling the Aerospike Voyager MCP server and connecting AI coding agents such as Cursor, VS Code, or Claude Desktop. It covers configuring token authentication, using JSON and CLI snippets for various editors, selecting between read-write and read-only access profiles, and testing the connection with sample prompts. - [MCP access profiles](https://aerospike.com/docs/database/tools/voyager/mcp/access-profiles.md): This document details how to use MCP access profiles in Aerospike Voyager to control the tools exposed to AI coding agents. It explains the differences between "full-access" and "read-only" profiles, lists specific allowed and blocked operations, and provides guidance on security considerations and when to switch between them for safe development or exploration. - [MCP server](https://aerospike.com/docs/database/tools/voyager/mcp.md): This document details how Aerospike Voyager's embedded MCP server allows AI coding agents to interact directly with clusters for browsing, querying, and data management. It explains available access profiles for security, transport configurations via Streamable HTTP, and setup guidance for supported agents like Claude Code and Cursor. - [MCP tool reference](https://aerospike.com/docs/database/tools/voyager/mcp/tool-reference.md): This document provides a comprehensive catalog of all tools exposed by Aerospike Voyager's MCP server for AI coding agents. It details tool categories like connection management, cluster browsing, and record operations, while explaining response formats, query pagination mechanics, supported bin types, and access profile restrictions. - [aerospike](https://aerospike.com/docs/database/advanced/udf/api/modules/aerospike.md): This document details the `aerospike` object's methods within UDFs, specifically `create()`, `update()`, `exists()`, and `remove()`. It provides implementation examples and a critical technical requirement for updating List or Map collection bins to ensure modifications are recognized by the database. - [logging](https://aerospike.com/docs/database/advanced/udf/api/modules/logging.md): This document details the logging API available to Aerospike UDFs, allowing developers to send messages to server logs using a printf-style format. It specifies four log levels—trace, debug, info, and warn—and provides guidance on using Lua's tostring() function to ensure data types are correctly handled during logging. - [bytes](https://aerospike.com/docs/database/advanced/udf/api/types/bytes.md): This document details the Aerospike bytes module for Lua UDFs, enabling efficient creation and manipulation of byte arrays similar to BLOBs. It covers functions for reading and writing strings and integers of varying widths with big and little endian support, as well as managing binary encoding types like Java or Python serialization. The guide emphasizes Lua's 1-indexed notation for buffer offsets. - [list](https://aerospike.com/docs/database/advanced/udf/api/types/list.md): This documentation explains the Aerospike Lua list module, providing a consistent interface for sequence management in UDFs. It details how to create Lists with specific capacities and use functions such as `append`, `prepend`, `insert`, `remove`, `take`, and `merge` to manipulate data. Additionally, it lists compatible types like integers, strings, bytes, maps, and nested lists. - [map](https://aerospike.com/docs/database/advanced/udf/api/types/map.md): This document provides the API reference for the Aerospike Lua Map type used in stream and record UDFs. It covers initializing maps with specific capacities, managing entries via functions like `map.remove()` and `map.size()`, and iterating through keys and values. Additionally, it explains how to perform shallow copies with `map.clone()` and merge two maps using a custom operator function. - [record](https://aerospike.com/docs/database/advanced/udf/api/types/record.md): This document details the Aerospike Record API used in UDFs to manipulate records as map-like structures. It provides a comprehensive reference for functions that retrieve or modify record metadata—such as TTL, generation, size, and bin names—and explains how to persist changes back to the database using aerospike:update(). - [stream](https://aerospike.com/docs/database/advanced/udf/api/types/stream.md): This document explains Aerospike's Stream API, which allows developers to process sequences of values within UDFs using Lua method syntax. It provides detailed specifications and code examples for lazy operations including filter(), map(), aggregate(), and reduce() to transform or summarize database records. - [Developing Record UDFs](https://aerospike.com/docs/database/advanced/udf/modules/record/develop.md): This guide explains how to implement single-record User-Defined Functions (UDFs) in Aerospike to create atomic operations and multi-operation transactions. It details critical guidelines on argument types, record locking, and TTL priority hierarchies. Practical examples demonstrate using Lua for string slicing, integrating Protobuf modules, and performing background data maintenance. - [Developing Stream UDFs](https://aerospike.com/docs/database/advanced/udf/modules/stream/develop.md): This guide explains how to create read-only Stream UDFs in Aerospike to perform aggregations on record sets. It details the implementation of filter, map, aggregate, and reduce operations, explaining the two-phase execution model between cluster nodes and the client. Additionally, it covers using Lua closures to pass dynamic arguments to these stream functions. - [Configure XDR Proxy](https://aerospike.com/docs/database/manage/xdr/proxy/config/aerospike.md): This technical guide outlines the Aerospike destination configuration for XDR Proxy, detailing parameters for seed nodes, credentials, and TLS security. It provides specific instructions on performance tuning, IP mapping for different clients, transaction timeouts, and the use of boolean particle types for database versions 5.6.0 and later. - [Configure the XDR Proxy](https://aerospike.com/docs/database/manage/xdr/proxy/config.md): This document details how to configure the Aerospike XDR Proxy via `/etc/aerospike-xdr-proxy/aerospike-xdr-proxy.yml`, covering service, aerospike destination, logging, and record-ordering sections. It specifies the need for change notification in the database setup and provides sample configurations for both XDR 5.0.0 wire protocol and HTTP/2 based connectors. - [Setting Java options for XDR Proxy](https://aerospike.com/docs/database/manage/xdr/proxy/config/java-options.md): This guide explains how to configure the JAVA_OPTS environment variable for Aerospike XDR connectors, including Kafka, Pulsar, and JMS. It provides step-by-step instructions for creating systemd override files and setting variables for non-systemd Docker containers to manage settings like Java maximum heap size and netty workdir. - [Load balancing](https://aerospike.com/docs/database/manage/xdr/proxy/config/load-balancing.md): This document explains how to deploy a load balancer in front of XDR Proxy instances to increase data replication throughput. It describes the limitation of TCP stickiness in standard XDR and details how the ESP outbound connector solves this by converting messages into HTTP requests for better distribution across nodes in cloud, Kubernetes, or bare-metal environments. - [Configure logging in XDR](https://aerospike.com/docs/database/manage/xdr/proxy/config/logging.md): This document provides detailed instructions for configuring the logging section of the aerospike-xdr-proxy.yml file. It covers available options such as log file paths, retention policies, ticker intervals, and output formats like JSON or simple. Additionally, it includes a YAML example demonstrating how to set specific log levels for components like the record parser and server. - [Message transformer for XDR Proxy](https://aerospike.com/docs/database/manage/xdr/proxy/config/message-transformer.md): This document explains how to develop and deploy custom Java-based message transformers for the Aerospike XDR Proxy to manipulate Change Notification Records. It covers implementing the InboundMessageTransformer interface, managing Maven dependencies, and configuring YAML parameters, while providing practical code examples for adding bins and performing selective record deletions using the AerospikeReader. - [Configure ordering of outbound records](https://aerospike.com/docs/database/manage/xdr/proxy/config/record-ordering.md): This guide explains how to use the `record-ordering` configuration to guarantee that records are dispatched in non-decreasing Last Update Time (LUT) order. It covers the LUT cache's memory footprint, TTL settings for stale record handling, and the architectural requirement of 1:1 XDR-to-connector mapping to ensure strict ordering across instances. - [Configure XDR Proxy service](https://aerospike.com/docs/database/manage/xdr/proxy/config/service.md): This document provides comprehensive instructions for configuring the Aerospike XDR Proxy service, focusing on network interfaces, listening ports, and incoming protocols like TCP and HTTP. It details how to implement secure connections via TLS, offering specific guidance on managing keystores, truststores, and PEM files. Configuration examples are included for clear-text, TLS-only, and hybrid setups. - [Back up data to cloud storage with absctl backup](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/backup/cloud-storage.md): This guide provides detailed instructions for using `absctl backup` to store Aerospike data in Amazon S3, Google Cloud Storage, and Azure Blob Storage. It covers required flags, authentication methods, IAM permissions, and a comprehensive reference of configuration options including storage classes and access tiers to optimize cost and retrieval speed. - [absctl backup](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/backup.md): This document explains how `absctl backup` serializes Aerospike records from defined namespaces and sets to local or cloud storage using YAML configuration. It details the default content captured—including keys, secondary indexes, and UDFs—while outlining critical limitations regarding RBAC privileges and Zstandard compression. - [Estimate resource usage for absctl backup](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/backup/resources.md): This document provides formulas to estimate the memory, disk space, and file descriptors required for `absctl backup` operations. It details how the `--parallel` flag affects resource consumption and explains how to tune server-side query thread settings like `query-threads-limit` to optimize performance and avoid bottlenecks. - [Run absctl backup](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/backup/use.md): This guide provides comprehensive instructions for using `absctl backup` to secure Aerospike Database data. It covers essential configuration for TLS, Zstandard compression, and AES encryption, while detailing advanced data selection methods via filter expressions, partition lists, and incremental time-stamps. Additionally, it explains how to implement resumable backups using state files for large-scale clusters. - [Restore data from cloud storage with absctl restore](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/restore/cloud-storage.md): This document explains how to use the absctl restore tool to recover Aerospike data from Amazon S3, Google Cloud Storage, and Azure Blob Storage. It covers required flags, authentication methods, and specific IAM permissions needed for each provider. A detailed options reference table provides technical settings for retry logic, timeouts, and managing archived data tiers. - [Estimate resources for absctl restore](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/restore/resources.md): This document provides technical guidance on allocating resources for the `absctl restore` tool to prevent failures like "too many open files." It includes specific formulas to approximate memory usage and file descriptor requirements based on configuration flags such as `--parallel`, `--batch-size`, and `--max-async-batches`. This helps administrators ensure system stability during data restoration. - [absctl restore](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/restore.md): This document explains how to use the `absctl restore` subcommand to recover Aerospike backups from local or cloud storage. It details critical considerations such as TTL preservation, cluster-agnostic distribution, and the specific RBAC privileges required for restoring UDFs and secondary indexes based on the database version. - [Run absctl restore](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/restore/use.md): This guide explains how to use the `absctl restore` tool to recover data from .asb files into an Aerospike cluster. It details critical configuration options for TLS security, connection timeouts, and input throttling, while explaining write policies like `--unique` and `--no-generation` to manage record conflicts during restoration. - [Validate backup files with absctl restore](https://aerospike.com/docs/database/tools/backup-and-restore/absctl/restore/validate.md): This guide explains how to use `absctl restore --validate` to detect corrupted or invalid backup files by reading and decoding them end-to-end. It details supported input sources like directories and S3 buckets while clarifying that database connectivity is not required. A practical example demonstrates creating a backup, manually corrupting it, and verifying the failure via validation output. - [Annotated Record UDF Example](https://aerospike.com/docs/database/advanced/udf/modules/record/examples/annotated.md): This document provides an annotated Lua code example for implementing Aerospike Record User Defined Functions (UDFs). It explains critical operations such as checking record existence, manipulating bin values, removing bins or entire records, and persisting changes using the `aerospike:update` method. It also demonstrates how to return complex data types like maps to the client. - [Background UDF Example](https://aerospike.com/docs/database/advanced/udf/modules/record/examples/background.md): This document provides a practical example of using an Aerospike background UDF written in Lua to identify and reset record TTLs. It demonstrates two implementation methods: utilizing a Java client with a predicate filter for efficiency, or embedding the filtering logic directly within the Lua function for use via AQL. - [Protobuf Module Example](https://aerospike.com/docs/database/advanced/udf/modules/record/examples/protobuf.md): This document provides a practical example of integrating the protobuf Lua rock with Aerospike UDFs. It demonstrates how to define a `.proto` message, generate a corresponding Lua module, and implement functions to serialize Protobuf data into records and parse it back, including steps for registering these modules via AQL. - [UDF Example – Statistics](https://aerospike.com/docs/database/advanced/udf/modules/record/examples/statistics.md): This document provides a practical Lua UDF example called `update_stats()` that maintains running statistics within an Aerospike record. It demonstrates how to initialize new records or update existing bins for MaxValue, MinValue, Sum, AveValue, and ValueCount. Additionally, it illustrates the use of Aerospike logging functions like trace(), warn(), and info() for debugging UDF execution. - [String Starts With Stream UDF Example](https://aerospike.com/docs/database/advanced/udf/modules/stream/examples/starts-with.md): This document provides a Lua implementation of the `recs_start_with` stream UDF, which filters records by checking if a specified bin's string value begins with a given prefix. It demonstrates the use of closures for filtering and includes a mapper function to convert Aerospike records into returnable map objects. - [Lua UDF – Word Count](https://aerospike.com/docs/database/advanced/udf/modules/stream/examples/word-count.md): This document demonstrates how to implement a Word Count algorithm using an Aerospike Lua Stream UDF. It details the use of `aggregate()` via a `page_words` function to count words per page and `reduce()` via `sum_words` with `map.merge` to combine results across partitions. It provides specific code examples for performing distributed word frequency analysis on book page records. - [Lua UDF Example – Simple Statistics](https://aerospike.com/docs/database/advanced/udf/modules/stream/examples/statistics.md): This document provides a practical Lua UDF example for performing statistical analysis on records within an Aerospike stream. It demonstrates how to implement `aggregate()` and `reduce()` operations to calculate metrics such as total, count, min, max, mean, and standard deviation directly on the server. - [Build a retail app with the Aerospike Java SDK and Voyager](https://aerospike.com/docs/database/get-started-with-aerospike-java-sdk-and-voyager.md): This tutorial guides developers through building the database layer of a Spring Boot retail application using the Aerospike Java SDK. It covers implementing object-mapped operations, AEL-based queries, and check-and-set updates for shopping carts, while demonstrating how to use Aerospike Voyager to inspect records and visually construct filter expressions. - [Configuration reference](https://aerospike.com/docs/database/reference/config.md): This document provides a comprehensive list of Aerospike Database configuration parameters categorized by context, including Logging, Namespace, Network, Security, Service, and XDR. Each entry details parameter types, default values, versioning history, and practical asinfo command examples for dynamic management. - [Info Command Reference](https://aerospike.com/docs/database/reference/info.md): This document provides a detailed reference for Aerospike info protocol commands used to access configuration and system statistics. It covers specific operations such as XDR management, cluster stability checks, histogram tracking, secondary index administration, and UDF module control. Each entry includes command syntax, parameter details, and raw output examples. - [Database known issues reference](https://aerospike.com/docs/database/reference/issues.md): Database known issues reference - [Database Log Reference](https://aerospike.com/docs/database/reference/logs.md): This document serves as a technical reference for Aerospike Database log messages, categorized by system context such as storage engines, clustering, and XDR. It provides specific message templates, severity levels, parameter definitions, and versioning information to assist administrators in diagnosing errors and monitoring cluster health. - [Metrics Reference](https://aerospike.com/docs/database/reference/metrics.md): This document provides a detailed technical reference for Aerospike database metrics across various contexts like Namespace, Node stats, Sets, Secondary Indexes, Users, and XDR. It includes backend-specific names for Prometheus and Datadog, measurement types, data types, and operational monitoring advice to assist in cluster performance analysis and health tracking. - [Tools known issues](https://aerospike.com/docs/database/tools/reference/issues.md): This document provides a detailed listing of known issues for Aerospike Tools, including bug summaries, introduction versions, fixes, and version impact lists. It serves as a technical reference to help users identify if their current tool versions—such as asadm, asbackup, or AQL—are affected by specific reported bugs or miscalculations. - [ABS Configuration Reference](https://aerospike.com/docs/database/tools/backup-and-restore/backup-service/config.md): A comprehensive technical reference for the `aerospike-backup-service.yml` file. It details configuration options for cluster connections, backup policies (compression, encryption, retention), cron-based routines, and restore requests. Additionally, it covers secret agent integration and specific settings for local, S3, Azure, and GCP storage providers. - [Database Release Notes](https://aerospike.com/docs/database/release.md): Release notes and version history for Database. Check this directory for version-specific changes and upgrade information. ## Cloud - [Billing](https://aerospike.com/docs/cloud/billing.md): This document outlines the current billing model for Aerospike Cloud. It specifies that pricing is handled via enterprise billing plans which are negotiated on a per-customer basis. - [Aerospike Cloud](https://aerospike.com/docs/cloud): Documentation for Aerospike Cloud, a fully managed database-as-a-service platform. - [Aerospike Cloud Quickstart](https://aerospike.com/docs/cloud/quickstart.md): This guide walks users through creating an Aerospike Cloud account and provisioning their first database cluster on AWS. It provides technical instructions for establishing VPC peering, updating route tables, associating private hosted zones for DNS resolution, and configuring security groups to enable secure client access via AQL. - [Welcome to Aerospike Cloud](https://aerospike.com/docs/cloud/overview.md): This document provides a high-level overview of Aerospike Cloud, a fully managed database-as-a-service. It details cloud and database-level resources, architectural design using VPC peering, and specific AWS feature availability for Aerospike 8.1 clusters. Additionally, it clarifies the pricing model and distinguishes this self-service platform from premium Managed Services. - [Configure Aerospike Clients](https://aerospike.com/docs/cloud/develop/client.md): This guide provides instructions for configuring Aerospike Cloud clients, focusing on TLS certificate retrieval and VPC peering requirements across various programming languages. It also details how to resolve the FAIL_FORBIDDEN write error by either removing record TTLs or enabling record expiration via the nsup-period setting in advanced configuration. - [Using Cloud APIs](https://aerospike.com/docs/cloud/manage-apis/cloud-api-use.md): This document provides instructions for programmatically managing Aerospike Cloud resources. It covers generating API keys within Team Settings and demonstrates how to use these credentials to obtain an OAuth2 bearer token for making authenticated API calls, such as retrieving VPC peerings. - [Public API limitations](https://aerospike.com/docs/cloud/manage-apis/limitations.md): This document outlines the current constraints of Aerospike Cloud Public APIs, specifically focusing on rate limiting and limited batch sizes for bulk operations. It provides essential guidance for developers to implement exponential backoff and pagination to ensure stable integrations and avoid API restrictions. - [Advanced configuration](https://aerospike.com/docs/cloud/manage/advanced-config.md): This document details how to tailor Aerospike Cloud clusters using advanced configuration settings. It outlines platform constraints like single namespaces and rack awareness while providing YAML/JSON examples for implementing record expiration (TTL), LRU cache behavior, and stop-writes mechanisms. It also covers secrets management for sensitive values and notes limitations compared to self-managed deployments. - [Backups](https://aerospike.com/docs/cloud/manage/backups.md): This document explains how Aerospike Cloud automatically backs up database clusters to external cloud storage, such as AWS S3. It details the specific backup schedules and retention periods for full (weekly/90 days) and incremental (daily/14 days) backups, while noting that restores must be requested via a support ticket. - [Manage Cloud account members](https://aerospike.com/docs/cloud/manage/cloud-members.md): This document explains how to invite and manage Aerospike Cloud organization members using the Access Manager. It details the specific permissions of CloudOwner and CloudAdmin roles, provides troubleshooting for authentication issues, and clarifies the critical distinction between Cloud members (resource managers) and Database users (data accessors). - [Create a database user](https://aerospike.com/docs/cloud/manage/database-users.md): This document provides step-by-step instructions for adding users to an Aerospike Cloud database cluster using either the Cloud Console or the Cloud API. It details required user fields, password constraints, and available RBAC roles. Additionally, it includes a sample curl request for programmatically creating credentials via the API endpoint. - [Node entitlements](https://aerospike.com/docs/cloud/manage/entitlements.md): This document explains that node entitlements limit the number of database nodes an Aerospike Cloud account can provision. It details the process for requesting these entitlements, including the necessary information like Organization ID and cloud region, and provides instructions on how to locate your Organization ID within the console. - [Provision an Aerospike Cloud database cluster](https://aerospike.com/docs/cloud/manage/create.md): This guide explains how to create a new Aerospike Cloud database cluster via the cloud console or REST API, including a sample POST request. It details prerequisites such as node entitlements and provides configuration tips regarding instance types, Strong Consistency requirements, and regional deployment for optimal performance. - [Managing Aerospike Cloud](https://aerospike.com/docs/cloud/manage.md): This document provides a roadmap for managing Aerospike Cloud organizations and database clusters. It details the essential setup process—including node entitlements, cluster creation, and VPC peering—while explaining how to manage database users, secrets, and API automation for cluster operations. - [Manage secrets](https://aerospike.com/docs/cloud/manage/secrets.md): This guide explains how to securely store and manage sensitive values in Aerospike Cloud using the Console or API. It provides step-by-step instructions for creating, deleting, and referencing secrets within database configurations, specifically demonstrating how to use the `auth-password-file` parameter for XDR authentication. - [Modify an Aerospike Cloud database cluster](https://aerospike.com/docs/cloud/manage/modify.md): This document provides step-by-step instructions for managing an Aerospike Cloud database cluster through the Cloud Console or REST APIs. It covers scaling node counts and instance types, tuning performance via advanced configurations, and decommissioning clusters to remove AWS resources, including specific API request examples using PATCH and DELETE methods. - [Configure AWS VPC peering](https://aerospike.com/docs/cloud/manage/vpc-peering.md): This guide details how to create a secure VPC peering connection between an AWS VPC and Aerospike Cloud to reduce latency and avoid the public internet. It includes technical instructions for route table updates, DNS association via Route 53, security group configuration, and troubleshooting connectivity issues like CIDR overlaps or routing failures. - [Cross-datacenter replication (XDR)](https://aerospike.com/docs/cloud/manage/xdr-setup.md): This guide provides a comprehensive walkthrough for setting up Cross-datacenter replication (XDR) in Aerospike Cloud. It covers supported topologies like active-passive and mesh, detailed steps for VPC peering and credential management, and the JSON configuration required to enable namespace or set-level data shipping between clusters. - [Cloud Public API metrics](https://aerospike.com/docs/cloud/observe/api-metrics.md): This document explains how to programmatically retrieve cluster metrics via the Cloud Public API to automate scaling actions. It includes a cautionary note regarding metric accuracy compared to the database metrics endpoint and provides a complete Bash script example that scales clusters when write throughput exceeds a defined threshold. - [Cloud Console metrics](https://aerospike.com/docs/cloud/observe/console-metrics.md): This document explains how to interpret the usage, latency, and transactions per second (TPS) gauges in the Aerospike Cloud Console. It details the underlying Prometheus metrics used for these calculations and warns that these tools are intended for quick health checks rather than full production monitoring or alerting. - [Aerospike Database metrics](https://aerospike.com/docs/cloud/observe/dp-metrics.md): This guide explains how to collect full per-node Prometheus metrics from Aerospike Cloud clusters via port 9145 over a peered AWS VPC. It provides specific Prometheus scrape configurations using `dns_sd_config` and details how to use the `cluster_name` label to differentiate between multiple clusters in Grafana dashboards. - [Aerospike Database logs](https://aerospike.com/docs/cloud/observe/dp-logs.md): This document provides instructions on accessing per-node server logs for Aerospike Cloud clusters stored in Amazon S3 buckets. It details how to grant access to AWS IAM roles via the Cloud API during cluster creation or update, retrieve the log bucket ARN, and use standard AWS tools to read the logs for troubleshooting and performance diagnosis. - [Observe Aerospike Cloud](https://aerospike.com/docs/cloud/observe/metrics.md): This document explains how to monitor Aerospike Cloud clusters using the Cloud Console, Public API, Prometheus database metrics, and system logs. It distinguishes between high-level scaling metrics and detailed production monitoring available via VPC peering on port 9145. Additionally, it references a tutorial for integrating Grafana Alloy and Grafana Cloud for advanced alerting. - [Supported regions and instance types](https://aerospike.com/docs/cloud/reference/instances.md): This document provides a comprehensive list of AWS regions and their corresponding availability zones supported by Aerospike Cloud. It includes a detailed mapping of compatible AWS instance families—such as storage-optimized i4i, memory-optimized r7g, and general purpose m5d types—to the specific regions where they are available for provisioning clusters. - [Aerospike Cloud limitations](https://aerospike.com/docs/cloud/reference/limitations.md): This reference guide outlines specific constraints in Aerospike Cloud, covering architecture limits like BYOA unavailability and sizing rules for nodes and zones. It also details namespace restrictions and immutable settings, such as replication factors and consistency models, to help users plan stable and performant cluster configurations. - [Operational guidelines](https://aerospike.com/docs/cloud/security/operational-guidelines.md): This guide provides operational best practices for Aerospike Cloud to ensure high availability and performance. It covers continuous monitoring via Prometheus, proactive cluster scaling, disaster recovery using XDR, and backup strategies. Additionally, it outlines essential security configurations including TLS and secure network connectivity like VPC peering. - [Security Practices](https://aerospike.com/docs/cloud/security/security-practices.md): This document distinguishes between Aerospike Cloud account members and database users, outlining specific access levels for each. It provides actionable security best practices, including the principle of least privilege and guidelines for using AWS VPC peering to ensure encrypted, private network connectivity to cluster endpoints. - [Aerospike Cloud Shared Responsibility Model](https://aerospike.com/docs/cloud/security/shared-responsibility.md): This document outlines the Shared Responsibility Model for Aerospike Cloud, detailing the specific security and operational duties of both Aerospike and the customer. It covers critical areas such as infrastructure management, network isolation, identity access, encryption (TLS/AES-256), and data ownership to ensure a secure and reliable database deployment. - [Operational guidelines](https://aerospike.com/docs/cloud/security/slas.md): This document provides operational guidelines to ensure high availability and performance for Aerospike Cloud deployments. It covers critical practices such as monitoring Prometheus metrics, proactively scaling clusters, configuring XDR for disaster recovery, and implementing secure network connectivity via VPC peering and TLS. - [Tutorial: Monitor Aerospike Cloud with Grafana](https://aerospike.com/docs/cloud/monitor-cloud-with-grafana.md): This tutorial guides users through deploying Grafana Alloy on AWS ECS Fargate to scrape Aerospike Prometheus Exporter metrics from port 9145. It explains how to visualize this data in Grafana Cloud using pre-built dashboards and configure alert rules for storage usage. Additionally, it covers utilizing the Cloud API to scale clusters based on these alerts. - [Cloud Release Notes](https://aerospike.com/docs/cloud/release.md): Release notes and version history for Cloud. Check this directory for version-specific changes and upgrade information. ## Graph - [Aerospike Graph Service](https://aerospike.com/docs/graph): Aerospike Graph Service. - [Quickstart: Aerospike Graph](https://aerospike.com/docs/graph/quick-start.md): This guide provides step-by-step instructions for setting up Aerospike Graph locally via Docker Compose and loading the Air Routes sample dataset. It covers installing the Gremlin Console, performing a bulk load of CSV files, and executing various Gremlin traversals to explore vertices and edges within the graph. - [Deploy Aerospike Graph Service with Docker](https://aerospike.com/docs/graph/deploy/docker.md): This guide provides detailed instructions for deploying Aerospike Graph Service (AGS) using Docker, covering both Standard and Slim image variants. It includes essential prerequisites like feature key requirements, database connectivity, and namespace TTL configurations. You will also learn how to manage AGS via environment variables, properties files, and log driver options. - [Deploy Aerospike Graph Service with Kubernetes](https://aerospike.com/docs/graph/deploy/kubernetes.md): This guide provides comprehensive instructions for deploying Aerospike Graph Service on minikube, Amazon EKS, and Google GKE. It covers essential database requirements, cluster provisioning via eksctl or gcloud, Helm-based installation, and post-deployment verification using the Gremlin Console to ensure successful graph traversals. - [Backup and restore](https://aerospike.com/docs/graph/manage/backup.md): This document explains that Aerospike Graph utilizes the underlying Aerospike database, enabling the use of standard backup and restore tools like asbackup. It emphasizes the necessity of a recovery plan for graph deployments and directs users to detailed technical documentation for implementation. - [Configuring AGS](https://aerospike.com/docs/graph/manage/configure.md): This guide explains how to configure Aerospike Graph Service (AGS) using either a properties file or Docker environment variables. It provides practical instructions for binding local files to the Docker image and lists essential configuration options like client host, port, and namespace settings. - [Cache management](https://aerospike.com/docs/graph/manage/cache.md): This document explains how to control Aerospike Graph Service (AGS) caching through TRANSACTIONAL and GLOBAL modes. It provides guidance on tuning cache weight for performance optimization, monitoring usage with admin services, and clearing stale data. Detailed Gremlin call examples and HTTP endpoints are provided for runtime management. - [HTTP endpoints](https://aerospike.com/docs/graph/manage/endpoints.md): This document details the various HTTP endpoints available in Aerospike Graph Service (AGS), including URL structures for multi-tenant environments. It covers administrative tasks such as managing metadata, indices, and caches, alongside monitoring services like Prometheus and health checks. - [Manage Aerospike Graph](https://aerospike.com/docs/graph/manage.md): This guide outlines how to manage Aerospike Graph Service (AGS) deployments in production environments. It details methods for configuring performance and multi-tenancy, managing the data lifecycle through backups, TTL, and cache control, and implementing security via RBAC, TLS, and audit logging. - [Multi-tenant graphs](https://aerospike.com/docs/graph/manage/multi-tenant.md): This guide explains how to set up multi-tenant graphs within a shared Aerospike namespace using the Aerospike Graph Service (AGS). It covers configuring graph and traversal names, naming requirements, and connection methods via Gremlin. It also details how to use RBAC to ensure logical isolation and security across different graphs. - [CSV format for source data files](https://aerospike.com/docs/graph/load/csv-format.md): This document details the specific CSV format requirements for bulk loading vertex and edge data into Aerospike Graph Service (AGS). It covers header syntax, property column configurations including type and cardinality, supported data types, and the mandatory directory structures for local or S3-based storage. - [Graph summary](https://aerospike.com/docs/graph/manage/summary.md): This document explains how to use Aerospike Graph Service (AGS) to retrieve approximate summary metadata for existing graphs, including vertex and edge counts by label. It provides Gremlin command examples to identify property keys and supernodes quickly through an asynchronous process that avoids scanning the entire graph. - [Enabling TTL (Time to Live)](https://aerospike.com/docs/graph/manage/ttl.md): This guide explains how to enable Time to Live (TTL) in Aerospike Graph Service by configuring the aerospike.graph.ttl.enabled option. It provides specific Gremlin traversal examples for assigning the ~ttl property to edges and vertices, while detailing how AGS uses secondary indexes to perform efficient background deletions. - [Bulk loading for distributed mode](https://aerospike.com/docs/graph/load/distributed.md): This guide details how to use the Aerospike Graph bulk loader in distributed mode via Apache Spark on AWS or GCP. It provides CLI procedures for EMR and Dataproc, configuration requirements for properties files, and an overview of job stages like vertex/edge insertion. It also covers incremental loading capabilities and available Spark command flags. - [Error handling for bulk data loading](https://aerospike.com/docs/graph/load/error-handling.md): This guide explains how to handle common CSV errors like duplicate vertex IDs, incorrectly typed data, and orphaned edges during bulk loading. It details how to configure fault tolerance limits using properties files and provides specific Gremlin `call` API commands for retrieving detailed error counts and row-level error reports. - [Incremental data loading](https://aerospike.com/docs/graph/load/incremental.md): This guide details how to incrementally add vertices, edges, and property updates to an existing Aerospike graph. It explains the vertex merging process using the mergeV step and provides specific implementation examples for both standalone Groovy commands and distributed Spark jobs. - [Bulk data loading](https://aerospike.com/docs/graph/load/overview.md): This guide details methods for importing data into Aerospike Graph, covering Gremlin steps, Standalone mode for small datasets, and Distributed mode for large-scale Spark processing. It compares key features such as CSV support, error handling, incremental loading, and recoverability to help you select the right approach for your dataset size. - [Restarting a data loading job after an error](https://aerospike.com/docs/graph/load/restart.md): This guide explains how to restart a bulk data loading job after an error occurs during a partially written stage. It details how to use the -resume flag for both bulk and incremental loads, as well as how to use the -clear_existing_data flag to start over from scratch. - [Bulk data loading for standalone processing](https://aerospike.com/docs/graph/load/standalone.md): This guide details how to use the Aerospike Graph bulk loader for standalone processing of small datasets via the Gremlin `call` API. It includes specific implementation steps for local, S3, and GCS storage backends, authentication methods, and instructions for monitoring job status and handling timeouts. - [Visualization with G.V()](https://aerospike.com/docs/graph/observe/gdotv.md): This document introduces G.V(), a specialized Gremlin IDE designed to work with Aerospike Graph Service (AGS) for visualizing connected datasets. It explains how graph visualization helps users understand data structures and gain deeper insights, while providing links to additional resources and official documentation. - [Version and configuration info](https://aerospike.com/docs/graph/observe/info.md): This document explains how to use specific Gremlin commands to access metadata for an existing graph database. It provides instructions for retrieving AGS and Aerospike Database versions, as well as extracting configuration details like Gremlin Server settings and graph properties using full or delta modes. - [Prometheus Exporter](https://aerospike.com/docs/graph/observe/metrics.md): This document explains how to use the Prometheus exporter for monitoring Aerospike Graph Service (AGS) via real-time metrics like JVM usage and average query times. It provides specific instructions on overriding default port and path settings using configuration options or environment variables. - [Terminate background queries](https://aerospike.com/docs/graph/observe/query-terminate.md): This document explains how to use the `aerospike.graph.admin.query.abort` Gremlin call step to manually terminate long-running background scans that may cause an Aerospike database to become unresponsive. It outlines the necessary ADMIN permissions and describes the return format, which provides counts of active queries found and successfully aborted. - [Query tracing](https://aerospike.com/docs/graph/observe/query-tracing.md): This guide explains how to use Query Tracing in Aerospike Graph Service (AGS) to diagnose and optimize slow Gremlin queries via Zipkin. It covers setting up a Zipkin environment, configuring AGS options like execution thresholds and sampling rates, and analyzing detailed query breakdowns to pinpoint performance bottlenecks. - [Generate usage statistics](https://aerospike.com/docs/graph/observe/usage-stats.md): This document explains how to use Gremlin console commands to retrieve usage statistics collected by the Aerospike Graph Service (AGS). It covers retrieving aggregate vCPU-hours and memory metrics, filtering data by a specific date, and provides a detailed breakdown of the raw instance-level statistics returned. - [Configuration options](https://aerospike.com/docs/graph/reference/config.md): This technical reference provides a complete list of configuration parameters for the Aerospike Graph Service (AGS). It covers essential settings for the Aerospike client, AGS service management, graph database tuning—including caching and indexing—and Aerospike Bulk Loader options. Additionally, it includes specific configurations for multi-tenant graph deployments. - [Aerospike Graph call steps](https://aerospike.com/docs/graph/reference/graph-call-steps.md): This technical reference provides detailed Gremlin g.call() command examples for managing Aerospike Graph services. It covers administrative tasks such as retrieving graph metadata, managing secondary indexes, performing bulk loads, configuring runtime settings, issuing RBAC JWTs, and controlling cache and background queries. - [Aerospike Graph architecture](https://aerospike.com/docs/graph/overview/architecture.md): This document outlines the three-layer architecture of Aerospike Graph, covering the application interface, stateless AGS compute layer, and Aerospike Database storage. It explains how Gremlin queries are processed via WebSockets to achieve high-performance, scalable graph traversals with sub-millisecond latency. - [TinkerPop feature support](https://aerospike.com/docs/graph/overview/tinkerpop.md): This document provides a comprehensive compatibility matrix detailing which TinkerPop features are supported in Aerospike Graph. It covers specific support levels for graph operations, vertex and edge functionalities, and various property types, including guidance on using multi-properties instead of arrays for vertex values. - [Tutorials for Graph](https://aerospike.com/docs/graph/overview/tutorials.md): This guide offers a structured learning path for Aerospike Graph development, ranging from foundational Gremlin basics in Java and Python to advanced implementation. It includes tutorials on visualizing transaction graphs, deploying AGS on AWS using Aerolab, and configuring end-to-end TLS security for production environments. - [Why Aerospike Graph](https://aerospike.com/docs/graph/overview/why-aerospike-graph): This document details why Aerospike Graph is ideal for large-scale workloads, highlighting its Hybrid Memory Architecture for predictable latency and independent scaling of compute and storage. It also covers the use of standard Gremlin queries, lower infrastructure costs via NVMe, and automated sharding to simplify operations. - [Query usage](https://aerospike.com/docs/graph/develop/query/basics.md): This guide explains how to perform mutation queries in Aerospike Graph using Gremlin, covering add, property, drop, and merge operations. It provides specific implementation details for mergeV and mergeE with on_create/on_match options, while also addressing performance impacts related to supernodes and query thread limits. - [Data type support](https://aerospike.com/docs/graph/develop/query/data-type-support.md): This document details the supported data types for vertex properties, metaproperties, and edge properties in Aerospike Graph. It explains indexing capabilities for various types, provides specific optimization advice regarding Double values versus scaled Longs, and includes practical Java code examples for implementation. - [The ~id field](https://aerospike.com/docs/graph/develop/query/id.md): This document explains the special ~id keyword in Gremlin used for direct vertex and edge lookups within Aerospike Graph Service. It details how users can define vertex IDs while edges are automatically generated by AGS, clarifies the T.id alias, and distinguishes between the ~id field and regular properties named 'id.' Practical Gremlin examples demonstrate ID creation, batch reads, and secondary index queries. - [Indexing](https://aerospike.com/docs/graph/develop/query/indexing.md): This guide explains how to create and manage vertex property and label secondary indexes using the Gremlin call API or configuration. It provides best practices for optimizing traversal performance through high-cardinality indexing and details how to control scan behavior to prevent inefficient full database scans. - [Multi-properties](https://aerospike.com/docs/graph/develop/query/multi-properties.md): Learn how to manage multiple values for a single property key in Aerospike Graph using TinkerPop's list and set cardinality. This guide covers defining, querying, and updating multi-properties, including the use of meta-properties for contextual data. It also details advanced set cardinality behaviors such as type compatibility rules and selection hierarchies. - [Query Threading](https://aerospike.com/docs/graph/develop/query/query-threading.md): This guide explains how to use Query Threading in Aerospike Graph Service to parallelize execution for complex, I/O-bound queries. It details the implementation of the aerospike.graph.parallelize parameter and provides configuration settings for optimizing batch reading and pagination across Aerospike nodes. - [Transactions in AGS](https://aerospike.com/docs/graph/develop/query/transactions.md): This guide explains how to handle data consistency and isolation for read-only and Gremlin mutation queries in AGS. It details configuration for Aerospike and TinkerPop transactions in strong consistency mode, provides Java examples for managing scopes, and outlines behavior under AP mode. - [Supernodes](https://aerospike.com/docs/graph/develop/query/supernodes.md): This guide defines supernodes in Aerospike Graph Service (AGS) and explains how storage configurations determine their threshold. It provides instructions on using the ~supernode flag for designation, optimizing traversals with property filters to avoid performance degradation, and managing bulk loading via sampling. - [User-supplied IDs](https://aerospike.com/docs/graph/develop/query/user-supplied-ids.md): This document explains how Aerospike Graph Service supports user-supplied IDs for vertices while requiring auto-generated IDs for edges and properties. It details the specific supported data types—Integer, Long, and String—and provides a practical Java code example demonstrating how to create and retrieve vertices using these various ID formats. - [Audit logging](https://aerospike.com/docs/graph/manage/security/audit.md): This document explains how to configure audit logging in Aerospike Graph Service to track write, delete, and call step executions. It outlines the prerequisite of enabling role-based access control and details how to use the aerospike.graph.audit.log.enabled configuration option to output user activity logs to the console. - [Security for Aerospike Graph](https://aerospike.com/docs/graph/manage/security.md): Learn how to secure Aerospike Graph Service using RBAC, TLS encryption, and audit logging. This guide details database-level and JWT-based access control, encryption for both client and backend connections, and methods for auditing graph mutations. It also highlights that audit logging requires graph-level RBAC for user identity association. - [RBAC for Aerospike Graph Service](https://aerospike.com/docs/graph/manage/security/rbac-graph): This document provides comprehensive instructions for implementing Role Based Access Control (RBAC) in Aerospike Graph Service using JWTs. It details configuration options, defines specific access levels like READ and ADMIN, explains multi-tenant graph role assignment, and demonstrates how to create and use tokens via Gremlin or HTTP connections. - [RBAC with Aerospike Database](https://aerospike.com/docs/graph/manage/security/rbac-aero.md): This document explains how to integrate Aerospike Graph Service (AGS) with an Aerospike Database deployment that has Role-based Access Control (RBAC) enabled. It details the specific configuration options required when starting the AGS Docker image and provides a practical command-line example for passing user credentials via environment variables. - [TLS setup for Aerospike Graph Service](https://aerospike.com/docs/graph/manage/security/tls.md): This document provides an overview of implementing Transport Layer Security (TLS) within Aerospike Graph Service (AGS). It outlines how TLS secures communication between Gremlin client applications and AGS, as well as the connection between AGS and the underlying Aerospike database. Users can access detailed configuration guides for both specific connection paths through this page. - [TLS between Gremlin and AGS](https://aerospike.com/docs/graph/manage/security/tls/tls-gremlin-ags.md): This guide provides step-by-step instructions for enabling TLS encryption between Gremlin clients and Aerospike Graph Service (AGS). It covers prerequisite certificate requirements, AGS property configuration, and specific Docker volume binding procedures for setups with or without a Certificate Authority. - [TLS between AGS and Aerospike DB](https://aerospike.com/docs/graph/manage/security/tls/tls-ags-asdb.md): This guide explains how to secure network traffic between Aerospike Graph Service (AGS) and an Aerospike database using TLS. It covers configuring the AGS properties file, preparing a certificate directory with PEM-encoded files, and running the AGS Docker image with specific volume mounts for certificates. - [Tutorial: Secure Aerospike Graph with TLS](https://aerospike.com/docs/graph/get-started-with-graph-and-tls.md): This tutorial provides step-by-step instructions for implementing end-to-end TLS encryption in Aerospike Graph Service. You will learn to generate self-signed certificates, secure Gremlin client WebSocket connections using wss://, and configure backend encryption between the graph service and the Aerospike Database cluster. - [Tutorial: Get started with Graph and AWS](https://aerospike.com/docs/graph/graph-and-aws-get-started.md): This tutorial guides you through performing distributed bulk loading of graph data into Aerospike Graph Service using AWS infrastructure. It covers configuring Aerolab on EC2, setting up Amazon S3 for staging, and leveraging Amazon EMR with Apache Spark to process and stream vertex and edge records efficiently. - [Tutorial: Graph and Java basics](https://aerospike.com/docs/graph/graph-and-java-basics.md): This tutorial demonstrates how to use the Gremlin Java driver to model a financial transaction network within Aerospike Graph Service. You will learn to create user and account vertices, execute traversal queries for fraud detection patterns like aggregation and filtering, and perform data modifications such as updating properties and deleting edges. - [Tutorial: Graph and Python basics](https://aerospike.com/docs/graph/graph-and-python-basics.md): This tutorial demonstrates how to build a financial transaction network using Python and the Aerospike Graph Service. You will learn to model users and accounts, execute Gremlin queries for fraud detection patterns, and perform data modifications like upserting vertices and pruning edges. - [Tutorial: Visualize your graph with G.V()](https://aerospike.com/docs/graph/visualize-your-graph-with-gdotv.md): This tutorial demonstrates how to use G.V(), an interactive Gremlin IDE, to visualize and explore Aerospike Graph Service data. You will learn to connect via WebSocket, execute queries, and transform results into interactive network diagrams where you can inspect properties and apply visual styling to vertex types like users and accounts. - [Graph Metrics Reference](https://aerospike.com/docs/graph/reference/metrics.md): This document provides a comprehensive reference for Aerospike Graph Service metrics used in Prometheus monitoring. It details specific metrics for the Gremlinserver (such as class cache performance and query evaluation), JVM internals (including memory pools, garbage collection, and thread states), and system process statistics like CPU usage and file descriptors. - [Graph Release Notes](https://aerospike.com/docs/graph/release.md): Release notes and version history for Graph. Check this directory for version-specific changes and upgrade information. ## Connectors - [Aerospike Connect](https://aerospike.com/docs/connectors/overview.md): This document provides an overview of the Aerospike Connect product line, which integrates the database with frameworks like Spark, Kafka, Pulsar, and JMS. It details capabilities for search via Elasticsearch, streaming data pipelines, parallel processing with Spark, and ANSI SQL analytics using Trino to enable high-scale, data-intensive applications. - [Connectors](https://aerospike.com/docs/connectors): Aerospike connectors integrate Aerospike with popular open-source frameworks, including Spark, Kafka, Pulsar, and JMS - [Aerospike Elasticsearch connector](https://aerospike.com/docs/connectors/elasticsearch.md): This document explains how the Aerospike Elasticsearch connector uses XDR and Change Notification services to stream data in near-real-time from Aerospike DB to Elasticsearch for advanced text search. It outlines key use cases like ML training sets and behavior analysis, and provides a detailed mapping table between RDBMS, Aerospike, and Elasticsearch models. - [Install Aerospike Elasticsearch connector](https://aerospike.com/docs/connectors/elasticsearch/install.md): This document provides step-by-step instructions for installing the Aerospike Elasticsearch connector on Linux (RHEL, Ubuntu, Debian, Amazon Linux), Docker, and Kubernetes via Helm charts. It covers essential prerequisites like Java Runtime Environment requirements and Aerospike change notification configuration. Users will find specific commands for package installation, systemd service management, and YAML configurations for Kubernetes deployments. - [Aerospike Connect for Elasticsearch release notes](https://aerospike.com/docs/connectors/elasticsearch/release-notes.md): This document provides a comprehensive chronological record of releases for Aerospike Connect for Elasticsearch from version 1.0.0 to 2.2.16. It details critical security vulnerability patches (CVEs), JVM requirements, architecture support for ARM64 and AMD64, and specific feature improvements such as batching configuration and logging enhancements. - [Aerospike connector compatibility with Elasticsearch server](https://aerospike.com/docs/connectors/elasticsearch/compatibility.md): This guide details Aerospike connector compatibility with Elasticsearch server versions. It specifies that while ES 7.11.x and later are supported, users of earlier versions must configure the `default-headers` in `es-client` to set the `Content-type` as `application/json` to resolve "406 Not Acceptable" errors. - [Security and authentication for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/security-and-authentication.md): This guide provides step-by-step instructions for creating the TLS Keystore required for Aerospike Connect for Elasticsearch. It covers generating new key pairs with the JDK keytool utility and combining existing PEM files into PKCS #12 format via OpenSSL, including how to handle intermediate certificate chains. - [Streaming from Aerospike](https://aerospike.com/docs/connectors/streaming.md): This document outlines the Aerospike Connect outbound connectors used to publish data reliably and scalably from Aerospike Database. It provides guidance on streaming data to Apache Kafka, JMS for legacy systems, Pulsar using the XDR protocol, and various systems capable of ingesting HTTP requests for event stream processing. - [Aerospike Connect for Spark](https://aerospike.com/docs/connectors/spark.md): This guide explains how the Aerospike Connect for Spark connector enables parallel data loading into Spark DataFrames using Java, Scala, or Python. It highlights features such as `aerolookup`, pushdown expressions, and AI/ML integration, while detailing critical limitations regarding SQL DDL statements and the requirement of Kafka for Structured Streaming readStream() operations. - [Configure Aerospike Connect for Spark](https://aerospike.com/docs/connectors/spark/configuration.md): This document provides a comprehensive reference for configuring the Aerospike Connect for Spark connector. It details parameters for reading and writing DataFrames, managing feature keys, and implementing flexible schema inference. Additionally, it covers performance tuning via batch sizes and partition factors, TLS authentication settings, and exponential backoff retry configurations. - [Install Aerospike Connect for Spark](https://aerospike.com/docs/connectors/spark/installation.md): This guide details the installation of Aerospike Connect for Spark, including compatibility requirements for Spark (3.0-3.5) and Java 8. It provides a comprehensive artifact matrix for various Scala versions and packaging types, with step-by-step instructions for deploying via JFrog Artifactory or manual JAR integration using spark-submit and Jupyter notebooks. - [Rate limiting for Aerospike Connect for Spark](https://aerospike.com/docs/connectors/spark/rate-limiting.md): This guide details how to implement rate limiting in Aerospike Connect for Spark using server-side quotas and application-level throttling via properties like `aerospike.write-rate`. It provides theoretical calculations for avoiding quota breaches during read/write operations and defines the shared responsibility model between database administrators and Spark developers. - [Aerospike Connect for Spark release notes](https://aerospike.com/docs/connectors/spark/release-notes.md): This document provides a comprehensive chronological record of Aerospike Connect for Spark releases from v1.0.0 to v5.0.2. It details specific Apache Spark and Aerospike Database compatibility, critical security vulnerabilities (CVEs), new feature introductions such as the aerolookup API, and known technical issues across versions. - [Troubleshoot Aerospike Connect for Spark](https://aerospike.com/docs/connectors/spark/troubleshooting.md): This guide provides solutions for common issues encountered when using Aerospike Connect for Spark, such as handling mixed data types via flexible-schema and managing sparse bins. It also details resolutions for specific runtime errors including Java version mismatches, socket timeouts, and AS_ERR_FORBIDDEN by adjusting partition factors and server thread limits. - [Support for secondary index](https://aerospike.com/docs/connectors/spark/spark-sindex.md): This document details how the Aerospike Connect for Spark leverages secondary indexes to reduce query latency in database versions 6.0+. It provides specific JSON configuration examples for implementing equal, range, and contains filters across NUMERIC and STRING data types, including support for scalar and collection types. - [Examples of querying Aerospike Database](https://aerospike.com/docs/connectors/trino/examples.md): This document provides practical examples for querying Aerospike data using the Trino CLI. It details how to use secondary indexes, perform federated queries, access CDTs with JSON functions, and execute insert operations. Additionally, it compares query execution plans with Cost-Based Optimization (CBO) enabled versus disabled to demonstrate performance gains. - [Configuration properties for Aerospike Connect for Trino](https://aerospike.com/docs/connectors/trino/config.md): This document details the configuration properties for Aerospike Connect for Trino defined in the aerospike.properties file. It covers basic cluster connectivity, security settings including TLS and authentication modes, performance tuning via connection pools and splits, and audit logging. Additionally, it explains error back-off mechanisms for handling rate quota violations. - [Aerospike Connect for Trino](https://aerospike.com/docs/connectors/trino.md): This guide explains how Aerospike Connect for Trino enables ANSI SQL queries and federated analytics across Aerospike clusters. It details the system topology, the use of secondary indexes to accelerate queries, and specific limitations like case-insensitive table naming. Additionally, it provides paths for deploying the connector on bare metal, VMs, or via Docker. - [Deploy Trino connector and Trino cluster](https://aerospike.com/docs/connectors/trino/install.md): This guide details the installation of the Aerospike Connect for Trino connector, covering prerequisites like Enterprise Edition versions and feature keys. It provides step-by-step instructions for JAR file placement, configuring catalog properties files, and mapping Aerospike namespaces and sets to Trino schemas and tables for analysis via BI tools. - [Architecture and data types for Aerospike and Trino](https://aerospike.com/docs/connectors/trino/mapping.md): This document provides a direct mapping between Aerospike and Trino architectures, translating concepts like namespaces to schemas and bins to columns. It details supported data type conversions—such as ListValue to JSON—and specifies version requirements for Boolean support to help users avoid casting errors. - [Aerospike Connect for Trino release notes](https://aerospike.com/docs/connectors/trino/release-notes.md): This document provides a comprehensive version history of Aerospike Connect for Trino, spanning from the initial PrestoSQL release to version 4.7.2. It details support for specific Trino versions (up to 480), upgrades to the Aerospike Java client, and critical security patches addressing CVEs. Users can track new features, bug fixes, and known issues to ensure environment compatibility. - [Specify Trino schemas](https://aerospike.com/docs/connectors/trino/table-defs.md): This guide details how to provide Trino with the schemas required to query schemaless Aerospike data, covering both default heuristic inference and manual JSON definitions. It includes a sample JSON schema structure and instructions for configuring the directory path in `aerospike.properties` or via Docker mounts to maintain accurate table mappings. - [SQL support for the Trino connector](https://aerospike.com/docs/connectors/trino/trino-sql.md): This document details how the Trino connector translates ANSI SQL into Aerospike commands using the Java client. It provides a mapping table between Aerospike's NoSQL data model and Trino's relational model, lists supported data type conversions (including JSON and HYPER_LOG_LOG), and enumerates compatible SQL statements such as SELECT and INSERT INTO. - [Configure batching for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure/batching.md): This guide explains how to optimize data transfer to Elasticsearch using the Bulk API by configuring batching triggers based on size, record count, or time intervals. It details specific configuration options and provides a YAML example demonstrating how to apply these settings globally or override them at the namespace and set levels. - [Configure bin transforms for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure/bin-transforms.md): This guide explains how to use the bin-transforms configuration in Aerospike Connect for Elasticsearch to control which bins are published and how they are named. It details the use of include/exclude filters, direct mapping via the map option, and string transformations like regex and case changes to align Aerospike record bins with desired attribute names. - [Configure bulk request for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure/bulk-request.md): This document details the `bulk-request-config` parameters within the `aerospike-elasticsearch-outbound.yaml` file. It provides specific configuration options for shard routing, refresh behavior, and timeouts, while explaining how to map Aerospike XDR write operations to Elasticsearch create, index, or update actions. - [Configure doc-id value for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure/doc-id.md): This document explains how to define the Elasticsearch document ID in the aerospike-elasticsearch-outbound.yaml configuration file. It details available source values—such as digest, user-key, and bin-value—and describes failure strategies like USE_DIGEST, FAIL, and IGNORE for handling cases where a doc-id cannot be generated from the specified source. - [Configure change notification for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure/change-notification.md): This document explains how to set up change notifications using Aerospike's Cross-Datacenter Replication (XDR) to sync record updates and deletions to Elasticsearch. It details prerequisites, such as Enterprise Edition requirements, and provides a step-by-step configuration guide for editing the aerospike.conf file to enable connector-based XDR blocks. - [Error codes for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure/error-codes.md): This document details how to use the `ignore-error-codes` section within the `aerospike-elasticsearch-outbound.yaml` configuration file. It explains that adding specific Elasticsearch error codes to this list allows them to be treated as successful operations, similar to a standard HTTP 200 response. - [Configure the Elasticsearch client for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure/es-client.md): This document provides detailed configuration parameters for the `es-client` section of the `aerospike-elasticsearch-outbound.yaml` file. It covers setting up on-prem or cloud clusters, configuring authentication methods (basic, token, API key), and tuning HTTP client settings including timeouts, proxies, and TLS configurations. - [Configure formats for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure/format.md): This guide explains how to configure the `format` section of the `aerospike-elasticsearch-outbound.yaml` file to manage data serialization. It details available record metadata fields and specifies that only 'custom' mode is supported, with options for JSON or FlatJSON payload formats. - [Configure Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure.md): This guide explains how to set up Aerospike Connect for Elasticsearch by configuring XDR change notifications and the `aerospike-elasticsearch-outbound.yml` file. It details configuration levels, specific sections like bin-transforms and routing, provides a comprehensive YAML example, and maps Aerospike records and bins to Elasticsearch documents and fields. - [Configure log output for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure/logging.md): This document details how to configure the `logging` section of the `aerospike-elasticsearch-outbound.yml` file. It covers settings for log file paths, rotation history, console output, and available formats like simple and JSON. Additionally, it provides a practical example of mapping specific logger names, such as record-parser and server, to their respective log levels. - [Configure namespaces for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure/namespaces.md): This document explains how to use the `namespaces` section of the `aerospike-elasticsearch-outbound.yaml` file to override bin transforms, routing modes, and serialization formats. It details the configuration hierarchy—prioritizing set, then namespace, then default settings—and provides a YAML example demonstrating how to skip specific sets or apply custom formatters. - [Configure ordering of outbound records](https://aerospike.com/docs/connectors/elasticsearch/configure/record-ordering.md): This guide details how to ensure outbound records are dispatched in non-decreasing order using a Last Update Time (LUT) cache. It explains the `record-ordering` configuration options, memory usage per entry, and the architectural requirement of 1:1 XDR mapping for guaranteed ordering across connector instances. - [Route records to ElasticSearch indexes](https://aerospike.com/docs/connectors/elasticsearch/configure/routing.md): This document details how to configure the `routing` section of the `aerospike-elasticsearch-outbound.yml` file to direct Aerospike records to Elasticsearch indexes. It explains static, skip, and dynamic routing modes (namespace, set, bin), along with options for transforming dynamically derived index names using regex, trimming, and case conversion. - [Configure change notification](https://aerospike.com/docs/connectors/streaming/common/change-notification.md): This guide explains how to enable Aerospike's change-notification system using XDR to stream database changes to external systems. It covers prerequisites for Enterprise Edition, feature-key requirements, and provides a practical example of configuring the xdr block in aerospike.conf to route record updates and deletions to connector nodes. - [Set Java options for outbound connectors](https://aerospike.com/docs/connectors/streaming/common/java-options.md): This guide explains how to set the JAVA_OPTS environment variable for Aerospike outbound connectors to manage settings like Java heap size and Netty work directories. It provides detailed procedures for creating systemd override files for specific connector services and using environment flags when deploying via Docker containers. - [Configure services for Aerospike Connect for Elasticsearch](https://aerospike.com/docs/connectors/elasticsearch/configure/service.md): This guide details how to configure the `service` section of the `aerospike-elasticsearch-outbound.yaml` file, covering network interfaces, ports, and protocols. It provides deep dives into TLS security—including keystore and PEM file configuration—and settings for the Management and Metrics API. Practical YAML examples are included for clear-text and encrypted deployment configurations. - [Common Considerations](https://aerospike.com/docs/connectors/streaming/common.md): This document serves as the introductory guide for common considerations when implementing Aerospike streaming connectors. It directs users to detailed pages within this section that outline shared requirements and best practices for various streaming integrations. - [Set up TLS keystores for Aerospike Connect](https://aerospike.com/docs/connectors/streaming/common/keystores.md): This document details how to set up TLS keystores in JKS or PKCS12 format for Aerospike Connect connectors. It provides specific command-line examples using the JDK keytool for new certificate generation and OpenSSL for importing existing PEM keys and CA certificate chains into a PKCS12 file. - [Management and metrics API](https://aerospike.com/docs/connectors/streaming/common/management-api.md): This document provides a technical reference for the Management and Metrics API used by Aerospike streaming connectors. It details REST endpoints for retrieving performance metrics—such as counters, timers, and gauges—as well as tools for configuring logging levels and monitoring real-time error windows across source and sink connectors. - [Outbound message transformer](https://aerospike.com/docs/connectors/streaming/common/outbound-message-transformer.md): This guide details the Aerospike Connect outbound plugin system for transforming XDR change notification records via Routing, Record, and Format/BatchFormat transformers. It covers custom Java development using the Outbound SDK, deployment requirements like JAR shading, and provides configuration parameters and code examples for various outbound destinations. - [Architecture for ESP outbound record ordering](https://aerospike.com/docs/connectors/streaming/esp/esp-record-ordering.md): This document details the recommended architecture for maintaining record ordering in Aerospike using a 1:1 deployment of ESP connectors to database instances via XDR. It explains how this setup prevents out-of-order delivery by ensuring only one version of a record is "in flight" and provides specific configuration examples and caveats regarding cluster rebalancing. - [Prometheus integration](https://aerospike.com/docs/connectors/streaming/common/prometheus-integration.md): This document explains how to configure the Prometheus REST endpoint (`manage/rest/v1/prometheus`) for Aerospike connectors. It provides a detailed list of available counters, gauges, histograms, and timers—including JVM performance and XDR record processing metrics—and lists Grafana JSON dashboard paths for outbound connectors. - [Install Event Stream Processing outbound connector](https://aerospike.com/docs/connectors/streaming/esp/inbound-install.md): This guide provides step-by-step instructions for deploying the Aerospike ESP outbound connector across Linux, Kubernetes, and Docker environments. It covers essential prerequisites like Java 17 and change notification settings, while detailing specific installation paths including RPM/DEB packages, Helm charts, and Docker image configuration. - [Aerospike Connect for Event Stream Processing (ESP) release notes](https://aerospike.com/docs/connectors/streaming/esp/release-notes.md): This document provides a comprehensive history of releases for Aerospike Connect for Event Stream Processing (ESP), from version 1.0.0 to 3.0.0. It details critical security vulnerability patches (CVEs), Java runtime requirements, and new features such as batching support and the Custom transformer API. - [Architecture for XDR proxy record ordering](https://aerospike.com/docs/connectors/streaming/esp/xdr-proxy-ordering.md): This document details the recommended architecture for preventing out-of-order record delivery when using XDR Proxy behind a load balancer via the ESP outbound connector. It explains how to deploy ESP connectors in a 1:1 ratio with Aerospike servers to ensure single-version "in flight" delivery, while noting potential latencies and caveats during cluster rebalancing. - [Aerospike Connect for event stream processing (ESP)](https://aerospike.com/docs/connectors/streaming/esp.md): This guide details how Aerospike Connect for ESP transforms Change Notifications over XDR into HTTP/1 or HTTP/2 requests to enable serverless processing via AWS Lambda and Google Cloud Functions. It covers key features like payload serialization, record ordering via LUT, and using HTTP load balancing to resolve TCP stickiness when streaming data to systems like Elasticsearch or Splunk. - [Kafka](https://aerospike.com/docs/connectors/streaming/kafka.md): This document provides an overview of streaming data between Aerospike Database Enterprise Edition and Apache Kafka using the Kafka Connect framework. It specifically introduces the inbound sink connector for moving data into Aerospike and the outbound source connector for streaming data from Aerospike to Kafka. - [Pulsar](https://aerospike.com/docs/connectors/streaming/pulsar.md): This document explains how to facilitate bidirectional data streaming between Apache Pulsar and Aerospike Database Enterprise Edition. It specifies that the Aerospike Pulsar inbound connector is used for streaming into the database, while the Pulsar connector handles streaming from the database to Pulsar. - [Key lookup with aerolookup](https://aerospike.com/docs/connectors/spark/tutorials/aerolookup.md): This tutorial explains how to use the `aerolookup` function to perform high-speed batch reads from Aerospike using Spark DataFrames. It covers API parameters for Scala and Python, provides a basic lookup example, and demonstrates a complex streaming pipeline that integrates database lookups with data aggregation and writes. - [Tutorials](https://aerospike.com/docs/connectors/spark/tutorials.md): This document provides a directory of tutorials for Aerospike Connect for Spark, including interactive Jupyter Notebooks for Scala and Python. It guides users through reading and writing DataFrames, implementing high-performance Structured Streaming with Kafka, and using aerolookup to efficiently load data subsets into Spark. - [Jupyter notebooks for Aerospike Connect for Spark](https://aerospike.com/docs/connectors/spark/tutorials/notebook.md): This document provides step-by-step instructions for setting up a Jupyter notebook environment on macOS to explore Aerospike Connect for Spark. It covers installing Python via pyenv, configuring the Scala kernel using spylon-kernel, and providing direct links to download and launch PySpark and Scala interactive notebooks. - [Read from and write to DataFrames](https://aerospike.com/docs/connectors/spark/tutorials/readwrite.md): This tutorial provides Scala examples for transferring data between Aerospike and Spark DataFrames. It covers writing by key or digest, configuring record TTLs, and implementing TLS encryption using truststores and keystores. Additionally, it explains how the connector infers schemas from sampled records to handle Aerospike's schema-less nature. - [Stream writes and reads with Aerospike and structured streaming](https://aerospike.com/docs/connectors/spark/tutorials/streaming.md): This tutorial provides practical examples for implementing streaming writes from Spark to an Aerospike sink using Scala. It also explains how to set up streaming reads by integrating the Aerospike Kafka Connector with Structured Spark Streaming to consume change notifications and persist processed data back into Aerospike. - [Deploy in distributed mode in Docker](https://aerospike.com/docs/connectors/trino/docker/distributed.md): This guide provides step-by-step instructions for deploying a production-ready distributed Trino cluster with the Aerospike connector using Docker. It details how to launch coordinator and worker nodes using either environment variables for rapid prototyping or an `aerospike.properties` file for advanced configuration, including necessary volume mounts for schemas and properties. - [Deploy Trino clusters and Trino connector in Docker](https://aerospike.com/docs/connectors/trino/docker.md): This guide provides step-by-step instructions for deploying Trino clusters and the Aerospike connector in Docker containers. It covers building custom images from GitHub, configuring properties via bind-mounts or environment variables, and choosing between standalone mode for rapid prototyping or distributed mode for production workloads. - [Environment variables supported in dockerized environments](https://aerospike.com/docs/connectors/trino/docker/env.md): This document lists the environment variables used to configure the Aerospike Trino connector when deployed via Docker. It provides a detailed mapping of these variables to their corresponding properties in the aerospike.properties file, along with a practical docker run example and configuration restrictions for multi-node clusters. - [Deploy in standalone mode in Docker](https://aerospike.com/docs/connectors/trino/docker/standalone.md): This document provides step-by-step instructions for deploying a single Trino node and Aerospike connector in Docker standalone mode for rapid prototyping. It details two configuration methods: using environment variables like AS_HOSTLIST or mounting an aerospike.properties file. Additionally, it explains how to mount custom Trino properties and JSON schema files into the container. - [Deploy in Starburst Enterprise Platform on AWS](https://aerospike.com/docs/connectors/trino/sep/aws.md): This guide details the deployment of the Aerospike Trino connector on Starburst Enterprise using AWS EC2 Ubuntu instances. It includes specific instructions for provisioning infrastructure, configuring system properties like jvm.config and node.properties, and installing the necessary JAR files to enable data access via SQL. - [Deploy in Starburst Enterprise Platform](https://aerospike.com/docs/connectors/trino/sep.md): This document provides guidance on deploying the Aerospike Trino connector within the Starburst Enterprise Platform for both AWS and bare metal environments. It specifically outlines which Starburst features are not supported, including Materialized Views, Caching Service, Atlas Integration, and certain Data Catalogs. - [Deploy in Starburst Enterprise Platform on bare metal](https://aerospike.com/docs/connectors/trino/sep/bare-metal.md): This guide provides detailed instructions for deploying the Aerospike Trino connector on bare-metal Starburst Enterprise environments. It covers prerequisite software, license setup, and specific configuration steps for files such as `node.properties` and `aerospike.properties`, concluding with how to start the service using the Python launcher. - [Dynamically increase and decrease the number of connector instances](https://aerospike.com/docs/connectors/streaming/common/configure.md): This guide explains how to use the asinfo command to dynamically scale Aerospike outbound streaming connectors for improved throughput and bottleneck prevention. It provides specific syntax for adding and removing instances in memory and details a June 2024 hotfix addressing connector scaling bugs in XDR configurations. - [Dynamically decrease the number of connector instances](https://aerospike.com/docs/connectors/streaming/common/configure/scaling-in.md): This guide explains how to use the asinfo command to dynamically remove connector instances from Aerospike's change notification system. It details the process of identifying active nodes via asadm and distinguishes between removing dynamic entries versus configuration-based ones. The document also warns about a specific XDR propagation bug fixed in June 2024 across several database versions. - [Dynamically increase the number of connector instances](https://aerospike.com/docs/connectors/streaming/common/configure/scaling-out.md): This document provides a step-by-step guide on dynamically adding connector instances to Aerospike's change-notification system using the asinfo command. It details version-specific syntax for databases before and after version 5.0.0, including configurations for TLS and HTTPS. Users can also learn how to verify the status of added nodes via the asadm "info xdr" command. - [Avro serialization format](https://aerospike.com/docs/connectors/streaming/common/formats/avro-serialization-format.md): This document explains how to serialize Aerospike data using the Avro format, detailing configuration options like `stringify-map-keys` for CDT maps. It provides comprehensive metadata definitions and specific schema examples for Map and Record types, including fixed schemas for keys and support for batched record outputs. - [Flat JSON format](https://aerospike.com/docs/connectors/streaming/common/formats/flat-json-serialization-format.md): This document specifies how Aerospike notification messages are represented as Flat JSON objects for record creation, updates, and deletions. It details the structure of record keys, specific message metadata fields like generation and last-update time, and provides examples of write/delete messages and batch serialization formats. - [Supported serialization formats for streaming from Aerospike](https://aerospike.com/docs/connectors/streaming/common/formats.md): This document lists the serialization formats used by Aerospike's outbound connectors to transform change-notification records for downstream applications. It covers standard options like JSON, MessagePack, and Avro, while specifically noting that the Kafka Avro format is exclusive to the Kafka outbound connector. - [JSON format for outbound](https://aerospike.com/docs/connectors/streaming/common/formats/json-serialization-format.md): This document details the JSON data serialization format for outbound messages in Aerospike Connect for Kafka. It defines the structure of write and delete messages, specifying how record keys, metadata, and bin values—including complex types like Lists, Maps, and GeoJSON—are represented. It also covers batching configurations with practical JSON examples for records and concatenated keys. - [Kafka Avro serialization format](https://aerospike.com/docs/connectors/streaming/common/formats/kafka-avro-serialization-format.md): This document details the Kafka Avro serialization format used by Aerospike Connector, including required properties and schema registry name strategies. It provides fixed JSON schemas for message metadata, deletes, and keys, along with comprehensive examples for configuring single-record and batched writes with optional metadata inclusion. - [MessagePack format for outbound](https://aerospike.com/docs/connectors/streaming/common/formats/messagepack-serialization-format.md): This document defines the binary MessagePack serialization format used by Aerospike Connect to transmit database change notifications. It details the exact array structures for WRITE and DELETE messages, including specific formats for record keys, bin types, and metadata like LUT and generation. It also covers batching configurations and version-specific breaking changes. - [Supported serialization formats for streaming from Aerospike](https://aerospike.com/docs/connectors/streaming/common/formats/overview.md): This document details the available outbound serialization formats used by Aerospike's streaming connectors to transform records for downstream consumption. It covers standard options like Avro, MessagePack, and two JSON variants, while specifying that Kafka Avro is exclusive to the Kafka connector. - [Integration with AWS Kinesis](https://aerospike.com/docs/connectors/streaming/esp/examples/aws-kinesis.md): This guide details how to integrate the Aerospike ESP Outbound Connector with AWS Kinesis Data Streams using API Gateway as a secure interface. It provides step-by-step instructions for AWS setup, mapping template configuration using `aerospike-digest` as a partition key, and complete YAML configuration examples. This allows users to establish reliable, real-time data streaming from Aerospike to AWS services. - [Configure batching for Aerospike Connect for Event Stream Processing](https://aerospike.com/docs/connectors/streaming/esp/configure/batching.md): This document explains how to group Change Notification Records into outbound HTTP messages using batching configurations. It details the max-bytes, max-records, and batch-interval options and provides a YAML example demonstrating how to apply or disable these settings hierarchically at the global, namespace, and set levels. - [Configure transformations on record bin names](https://aerospike.com/docs/connectors/streaming/esp/configure/bin-transforms.md): This document details how to use `bin-transforms` in Aerospike ESP to control which record bins are published and how they are named. It describes the precedence of `exclude` over `include`, explicit renaming via the `map` property, and dynamic transformations including regex patterns, casing changes, and whitespace trimming. - [Configure HTTP destinations for change notifications](https://aerospike.com/docs/connectors/streaming/esp/configure/destinations.md): This document provides detailed configuration options for Aerospike ESP HTTP destinations used for change notifications. It explains how to define destination URLs, manage TLS security with key and trust stores, configure health checks for load balancing, and customize HTTP headers and success status codes in the outbound YAML file. - [Specify serialization format of the data output](https://aerospike.com/docs/connectors/streaming/esp/configure/format.md): This document explains how to configure the `format` section of the Aerospike ESP outbound YAML file to define data serialization. It covers supported formats including XDR, JSON, Flat JSON, Avro, MessagePack, and custom code, detailing specific options like schema files and metadata keys. Additionally, it defines the available record metadata fields used during serialization. - [Configure Event Stream Processing outbound connector](https://aerospike.com/docs/connectors/streaming/esp/configure.md): This guide explains how to configure the Aerospike ESP outbound connector using the `aerospike-esp-outbound.yml` file, including required XDR and change notification settings. It details key configuration sections such as routing, destinations, and bin transforms, while explaining how to implement cascading configuration values from global defaults down to specific namespaces and sets. - [Configure log output](https://aerospike.com/docs/connectors/streaming/esp/configure/logging.md): This document explains how to manage logging for Aerospike ESP Outbound via the aerospike-esp-outbound.yml file. It details specific configuration options including log file paths, retention policies, and ticker intervals, as well as available output formats like JSON and simple. An example YAML snippet is provided to demonstrate setting different log levels for various components. - [Configure namespace settings](https://aerospike.com/docs/connectors/streaming/esp/configure/namespaces.md): This document explains how to override bin-name transformations, routing modes, and serialization formats within the aerospike-esp-outbound.yml file. It details the configuration precedence order—prioritizing set, then namespace, then default settings—and warns that records are skipped if no route is specified. - [Configure ordering of outbound records](https://aerospike.com/docs/connectors/streaming/esp/configure/record-ordering.md): This document explains how to use the record-ordering section in Aerospike ESP to ensure outbound records are dispatched in non-decreasing Last Update Time (LUT) order. It details the LUT cache mechanism for filtering stale records, RAM usage per entry, and the necessity of a 1:1 XDR-to-connector mapping to maintain ordering across instances. - [Configure alternate ports for change notifications](https://aerospike.com/docs/connectors/streaming/esp/configure/port-based-config.md): This document explains how to use the `port-based-config` section in Aerospike Event Stream Processing outbound YAML to set up alternate ports for change notifications. It details how to route data to multiple destinations by creating distinct XDR DCs per port and allows overriding global configurations for routing, format, bin-transforms, and namespaces. - [Configure routing to ESP destinations](https://aerospike.com/docs/connectors/streaming/esp/configure/routing.md): This guide explains how to configure the routing section of the aerospike-esp-outbound.yml file to control record delivery to ESP destinations. It details the configuration options and behavior for three modes—static-multi-destination, skip, and custom routing—and provides specific warnings regarding XDR acknowledgement logic when shipping records to multiple targets. - [Configure connector settings](https://aerospike.com/docs/connectors/streaming/esp/configure/service.md): This document provides detailed instructions for configuring the `service` section of the Aerospike ESP outbound connector's YAML file. It covers setting up listening ports, network interfaces, and protocols, as well as comprehensive TLS configuration including PEM and JKS keystores. Additionally, it explains how to configure the management API for querying metrics and logs. - [Stream from Aerospike to Java Message Service](https://aerospike.com/docs/connectors/streaming/jms/outbound.md): This document explains how the JMS outbound connector streams Aerospike Enterprise Edition change notifications to JMS brokers. It details supported events for record insertions, updates, and deletions, while outlining flexible routing modes based on static defaults, namespaces, sets, or specific bin values. - [Install Aerospike Connect to JMS](https://aerospike.com/docs/connectors/streaming/jms/outbound/install.md): This guide provides comprehensive installation instructions for the Aerospike Connect to JMS outbound connector on Linux, Kubernetes via Helm, and Docker. It details system prerequisites such as Java 17 requirements and OS compatibility, while offering specific configuration examples for deploying streaming services from Aerospike to JMS message brokers. - [Aerospike Connect for JMS Outbound release notes](https://aerospike.com/docs/connectors/streaming/jms/outbound/release-notes.md): This document provides a comprehensive version history for the Aerospike Connect for JMS Outbound connector, from version 1.0.0 to 4.2.16. It details critical Java runtime requirements (Java 11 or later, transitioning to Java 17), extensive security patches addressing numerous CVEs, and key feature additions such as batching support and XDR protocol compatibility. - [Deploy JMS inbound connector](https://aerospike.com/docs/connectors/streaming/jms/inbound/deploy-jms-inbound-connector.md): This guide provides step-by-step instructions for deploying the Aerospike JMS Inbound connector across supported Linux distributions, Kubernetes using Helm charts, and Docker containers. It covers essential prerequisites like Java runtime environments, package installation commands, feature-key configuration, and specific values.yaml settings for K8s deployments. - [Stream from Java Message Service to Aerospike](https://aerospike.com/docs/connectors/streaming/jms/inbound.md): This document details how to use the JMS inbound connector to stream data from Java Message Service brokers into Aerospike Database Enterprise Edition. It explains how messages are converted into records for insert, update, or delete operations and mentions the ability to add custom code for message manipulation. Additionally, it outlines connectivity constraints and acknowledgement behaviors. - [Use message transformer for Aerospike Connect to Java Message Service](https://aerospike.com/docs/connectors/streaming/jms/inbound/message-transformer-examples.md): This document provides practical Java implementations of InboundMessageTransformer for Aerospike Connect for JMS. It demonstrates how to perform complex Collection Data Type (CDT) operations on Lists and Maps, and how to use the AerospikeReader to execute database reads for conditional logic before performing put or operate actions. - [Aerospike Connect for JMS Inbound release notes](https://aerospike.com/docs/connectors/streaming/jms/inbound/release-notes.md): This document provides the comprehensive version history for Aerospike Connect for JMS Inbound, from its initial GA release to version 3.0.18. It details critical Java runtime requirements (Java 11 and 17), numerous security patches addressing CVEs, and functional enhancements such as Prometheus API integration and TLS context reloading. - [Aerospike Kafka sink (inbound) connector](https://aerospike.com/docs/connectors/streaming/kafka/inbound.md): This document explains how the Aerospike Kafka sink connector streams messages from Apache Kafka topics into an Aerospike cluster via inserts, updates, or deletes. It covers the ability to use custom code for record manipulation and notes critical limitations regarding data ordering guarantees due to Kafka's network flow. - [Deploy the Aerospike Kafka sink connector](https://aerospike.com/docs/connectors/streaming/kafka/inbound/deploy-kafka-inbound-connector.md): This document provides step-by-step instructions for deploying the Aerospike Kafka sink connector in both standalone and distributed modes. It details prerequisites, installation paths, and configuration methods using YAML, JSON, or JSON strings. Additionally, it includes a practical example of using the REST API to deploy and verify the connector. - [Examples of custom code to use Message Transformer](https://aerospike.com/docs/connectors/streaming/kafka/inbound/message-transformer-examples.md): This document provides three practical Java implementations of the InboundMessageTransformer for Aerospike Connect for Kafka. It demonstrates how to perform CDT operations on lists and maps, use the AerospikeReader for conditional database reads during transformation, and handle Kafka tombstone messages to execute record deletions in Aerospike. - [Modify an existing configuration of the Kafka sink connector](https://aerospike.com/docs/connectors/streaming/kafka/inbound/modifying-existing-configuration.md): This guide explains how to modify the Aerospike Kafka sink connector configuration file for both standalone and distributed modes. It covers killing and restarting JVM processes for standalone setups and using the Kafka Connect REST interface to push updates and verify changes across a distributed cluster. - [Ordering guarantees with Kafka sink connector](https://aerospike.com/docs/connectors/streaming/kafka/inbound/ordering-guarantees.md): This document explains how the Aerospike Kafka Sink Connector (v2.2.1+) maintains write order for records sharing the same Kafka key. It details the requirement for using a key-based partitioner and warns that no ordering guarantees exist across different or missing Kafka keys. - [Aerospike Connect for Kafka Inbound release notes](https://aerospike.com/docs/connectors/streaming/kafka/inbound/release-notes.md): This document provides a comprehensive chronological record of releases for the Aerospike Kafka Inbound (Sink) Connector from version 1.0.0 to 3.2.4. It details compatibility with Apache Kafka and Confluent Platform, Java runtime requirements, and critical security patches addressing various CVEs. Users can track feature additions like PKI authentication and TLS context reloading. - [Scale Kafka sink connectors](https://aerospike.com/docs/connectors/streaming/kafka/inbound/scaling.md): This guide explains how to increase data throughput from Kafka to Aerospike by scaling sink connectors in distributed mode. It provides step-by-step instructions on updating the `tasks.max` configuration via the REST API and launching additional workers using the `connect-distributed` command, including verification steps for both methods. - [Security and authentication](https://aerospike.com/docs/connectors/streaming/kafka/outbound/create-tls-keystores.md): This guide explains how to create the TLS keystores required for Aerospike Connect connectors to enable secure authentication. It provides step-by-step commands using the JDK `keytool` utility for new key pairs and OpenSSL for converting existing PEM files or certificate chains into PKCS12 format, while detailing differences between JKS and PKCS12 formats. - [Install the Aerospike Kafka Source Connector](https://aerospike.com/docs/connectors/streaming/kafka/outbound/install.md): This document provides comprehensive instructions for installing the Aerospike Kafka Source Connector to enable outbound streaming to Kafka clusters. It covers system prerequisites such as Java 11+ and change notification configuration, alongside detailed deployment steps for Linux distributions (.deb/.rpm), Kubernetes via Helm charts, and Docker containers. - [Prometheus integration](https://aerospike.com/docs/connectors/streaming/kafka/outbound/prometheus-integration.md): This guide explains how to enable and configure Prometheus integration for Aerospike Kafka outbound connectors via the `manage/rest/v1/prometheus` endpoint. It catalogs specific monitoring metrics—including request lag, payload size, and processing timers—categorized by metric type. Additionally, it provides the local file paths for JSON-based Grafana dashboards to facilitate visual performance monitoring. - [Aerospike Kafka source (outbound) connector](https://aerospike.com/docs/connectors/streaming/kafka/outbound.md): This guide explains how to stream record insertions, updates, and deletions from Aerospike Enterprise Edition to Apache Kafka using the outbound connector. It describes the transformation of proprietary wire protocol data into common serialization formats via XDR-based notifications. The text also clarifies handling for CDT types and warns about potential message re-ordering on the network. - [Aerospike Connect for Kafka Outbound release notes](https://aerospike.com/docs/connectors/streaming/kafka/outbound/release-notes.md): This document provides a detailed version history of the Aerospike Connect for Kafka Outbound connector from v1.0.0 to v5.3.16. It outlines critical security vulnerability patches (CVEs), Java 11+ runtime requirements, and support for ARM64/AMD64 architectures. It also tracks new features like batching and Prometheus integration, and notes the upcoming rename to `aerospike-source-connector`. - [Dynamically decrease the number of source connector instances](https://aerospike.com/docs/connectors/streaming/kafka/outbound/scaling-in.md): This document provides instructions on dynamically decreasing the number of source connector instances in an Aerospike cluster. It details the specific `asinfo` command for removal and explains how to identify active nodes using `asadm`. Additionally, it highlights a critical bug fix regarding XDR connector scaling released in June 2024 across several database versions. - [Dynamically increase the number of source connector instances](https://aerospike.com/docs/connectors/streaming/kafka/outbound/scaling-out.md): This guide provides step-by-step instructions for dynamically adding Aerospike Kafka source connector instances via the asinfo command. It details version-specific syntax for database versions before and after 5.0.0, including configurations for TLS and HTTPS, and explains how to verify the status of new nodes using the asadm info xdr command. - [Streaming from Aerospike to Pulsar](https://aerospike.com/docs/connectors/streaming/pulsar/outbound.md): This document explains how the Pulsar connector streams data from Aerospike Database Enterprise Edition to Apache Pulsar by transforming change notifications into common serialization formats. It details four message routing modes—Static, Namespace, Set, and Bin—and specifies that it supports record insertions, updates, and deletions. - [Install the Aerospike Pulsar Outbound Connector](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/install.md): This document provides comprehensive instructions for installing the Aerospike Pulsar Outbound Connector across various environments. It details prerequisites such as Java runtime requirements and change notification setup, while offering specific installation steps for Linux distributions, Kubernetes via Helm charts, and Docker deployments. - [Aerospike Connect for Pulsar Outbound release notes](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/release-notes.md): This document provides the comprehensive release history for Aerospike Connect for Pulsar Outbound from version 1.0.0 to 3.3.18. It details critical security vulnerability patches (CVEs), Java runtime requirements, and functional updates such as batching support, multi-architecture compatibility (ARM64 & AMD64), and Prometheus integration. - [Deploy the Pulsar inbound connector](https://aerospike.com/docs/connectors/streaming/pulsar/inbound/deploy-pulsar-inbound-connector.md): This guide provides step-by-step instructions to deploy the Aerospike Pulsar Inbound Connector as a Pulsar Function sink. It covers prerequisites like Java 11 and Apache Pulsar 2.7.1+, detailing how to place the .nar file, configure the yml file, and use the `pulsar-admin sinks create` command with specific flags to start the connector. - [Stream to Aerospike from Apache Pulsar](https://aerospike.com/docs/connectors/streaming/pulsar/inbound.md): This document explains how to use the Aerospike Pulsar inbound connector to stream data from Apache Pulsar clusters to Aerospike Database Enterprise Edition. It details the connector's implementation as a Pulsar IO sink supporting `struct` schemas and highlights options for custom record manipulation before persistence. - [Examples of custom code to use message transformer](https://aerospike.com/docs/connectors/streaming/pulsar/inbound/message-transformer-examples.md): This document provides Java code examples for implementing custom Inbound Message Transformers in Aerospike Connect for Pulsar. It demonstrates how to execute CDT List and Map operations on incoming data and how to use the `AerospikeReader` to perform database reads for conditional logic, such as deciding between a record put or an update operation. - [Modify an existing configuration of the Pulsar inbound connector](https://aerospike.com/docs/connectors/streaming/pulsar/inbound/modifying-existing-configuration.md): This document provides a step-by-step procedure to modify the configuration of a deployed Aerospike Pulsar Inbound Connector. It details how to view current settings using `pulsar-admin sinks get`, edit the `aerospike-pulsar-inbound.yml` file, and apply changes via the `pulsar-admin sinks update` command to ensure connector instances use the new parameters. - [Aerospike Connect for Pulsar Inbound release notes](https://aerospike.com/docs/connectors/streaming/pulsar/inbound/release-notes.md): This document provides the comprehensive release history for Aerospike Connect for Pulsar Inbound from version 1.0.0 to 2.1.4. It details critical security patches (CVEs), Java runtime requirements starting with v2.1.0, and functional improvements such as TLS context reloading and Boolean particle type support. - [Specify location of the feature key for Kafka inbound connector](https://aerospike.com/docs/connectors/streaming/kafka/inbound/configure/feature-key-file.md): This document explains how to configure the `feature-key-file` property within the `/etc/aerospike-kafka-inbound/aerospike-kafka-inbound.yml` file. It highlights that this option is deprecated as of version 2.2.0, because the `mesg-kafka-connector` feature key is now read directly from the Aerospike server. - [Configure the Kafka sink (inbound) connector](https://aerospike.com/docs/connectors/streaming/kafka/inbound/configure.md): This guide provides detailed instructions for configuring the Aerospike Kafka sink connector to stream data from Apache Kafka to an Aerospike database. It covers version-specific configuration options, including the deprecated feature-key-file, and provides YAML examples for mapping Kafka records to Aerospike namespaces, sets, keys, and bins. - [Configuring the inbound Kafka connections](https://aerospike.com/docs/connectors/streaming/kafka/inbound/configure/aerospike.md): This document provides a comprehensive guide to configuring the Aerospike section of the `aerospike-kafka-inbound.yml` file for Kafka inbound connectors. It details essential settings like seed nodes and cluster names, alongside optional configurations for TLS security, authentication credentials, and rack awareness. Additionally, it covers performance tuning, timeouts, and boolean particle types. - [Message Transformer for Aerospike Connect for Kafka](https://aerospike.com/docs/connectors/streaming/kafka/inbound/configure/message-transformer.md): This document explains how to develop a custom Message Transformer using the Java SDK to convert incoming Kafka messages into AerospikeRecordOperation objects. It covers implementation details like the InboundMessageTransformer interface, YAML configuration, and .jar deployment. Practical examples include performing CDT operations, integrating database reads, and handling Kafka tombstones for deletions. - [Specify Kafka topics](https://aerospike.com/docs/connectors/streaming/kafka/inbound/configure/topics.md): This guide details how to configure the topics section of the aerospike-kafka-inbound.yml file to consume Kafka messages. It covers specifying write/delete operations, mapping record keys and digests, and defining static or dynamic values for namespaces, sets, and TTLs. Additionally, it explains how to map message fields to single or multiple Aerospike bins. - [Configure batching for Aerospike Connect for JMS](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure/batching.md): This document details how to group Change Notification Records into outbound message batches for Aerospike Connect for JMS. It explains key parameters like max-bytes, max-records, and batch-interval, while providing a YAML example showing how to apply these settings at global, namespace, or set levels. - [Configure bin transforms for Aerospike Connect for JMS outbound](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure/bin-transforms.md): This guide explains how to use the bin-transforms section of the Aerospike JMS outbound configuration file. It details how to filter bins using include and exclude rules, create direct mappings between bins and attributes via the map option, and apply programmatic transforms like regex or uppercase to rename remaining bins. - [Configure delivery of messages](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure/delivery-mode.md): This document explains how to set the delivery-mode in the /etc/aerospike-jms-outbound/aerospike-jms-outbound.yml file. It details the difference between persistent mode, which ensures messages are logged to stable storage for reliability, and non-persistent mode, which offers faster performance without delivery guarantees. - [Configure message format for JMS outbound](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure/format.md): This guide explains how to configure the `format` section of the `/etc/aerospike-jms-outbound/aerospike-jms-outbound.yml` file. It details supported serialization modes—Avro, Flat JSON, JSON, MessagePack, and Custom—and defines the Aerospike record metadata fields available for output. - [Configure connection properties from the connector to a JMS message broker](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure/jms.md): This document explains how to configure the `jms` section of the Aerospike JMS outbound connector's YAML configuration file. It details connection properties such as factory names and session limits, specifies authentication methods for different brokers, and provides full YAML examples for IBM MQ, Solace, ActiveMQ Artemis, and RabbitMQ. - [Configure streaming from Aerospike to JMS](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure.md): This guide details how to configure the Aerospike-to-JMS outbound connector by setting up XDR change notifications and modifying the `aerospike-jms-outbound.yml` file. It explains key configuration sections like routing, bin transformations, and message formats, including how to apply cascading settings at the namespace and set levels. A complete YAML example for IBM MQ is provided. - [Configure namespaces for the JMS outbound connector](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure/namespaces.md): This document explains how to use the namespaces section of the aerospike-jms-outbound.yml file to override routing, formatting, and bin transformations. It details the configuration hierarchy where set-specific settings take precedence over namespace and default values, noting that records are skipped if route or format information is missing. - [Configure log output for the JMS outbound connector](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure/logging.md): This document explains how to configure the logging section of the Aerospike JMS outbound connector's YAML configuration file. It details available options for log paths, rotation settings, output formats like JSON, and custom log levels for specific packages. Additionally, it provides instructions on enabling error logging for the message-parser to troubleshoot parsing issues. - [Configure alternate ports for change notifications](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure/port-based-config.md): This document explains how to use the `port-based-config` section of the Aerospike JMS outbound configuration file to apply specific settings based on the incoming notification port. It details how to override global routing, format, bin-transforms, and namespaces for individual ports, allowing a single connector cluster to ship change notifications to multiple destinations via XDR. - [Configure ordering of outbound records](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure/record-ordering.md): This document explains how to ensure records are dispatched in non-decreasing LUT order via a RAM-based cache, skipping stale updates to optimize hot key handling. It details memory consumption per entry and the requirement for 1:1 XDR-to-connector mapping to maintain ordering across instances. Configuration settings like `lut-cache-ttl-seconds` are also covered. - [Configure routing to a JMS destination](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure/routing.md): This guide explains how to configure the routing section of the aerospike-jms-outbound.yml file to direct records to JMS destinations. It details six specific routing modes—static, skip, namespace, set, bin, and custom—and provides instructions on applying transforms like regex, trim, and case conversion to derive destination names from record metadata. - [Configure outbound connector services for JMS](https://aerospike.com/docs/connectors/streaming/jms/outbound/configure/service.md): This document provides a comprehensive guide to configuring the `service` section of the Aerospike JMS outbound connector's YAML file. It details parameters for ports, network interfaces, and IO threads, while offering in-depth instructions on implementing TLS security using JKS or PEM files. Additionally, it explains how to configure the Management API endpoint for querying metrics and logs. - [Configure connection properties from the connector to Aerospike Database](https://aerospike.com/docs/connectors/streaming/jms/inbound/configure/aerospike.md): This document provides detailed instructions for configuring the aerospike section of the aerospike-jms-inbound.yml file. It covers seed node setup, TLS security, authentication credentials, performance throttling via connection pools, and network settings like IP mapping and timeouts to ensure a stable connection between the JMS connector and Aerospike Database. - [Specify location of the feature key for JMS inbound connector](https://aerospike.com/docs/connectors/streaming/jms/inbound/configure/feature-key.md): This document explains how to use the `feature-key-file` property in the `/etc/aerospike-jms-inbound/aerospike-jms-inbound.yml` file to enable the `mesg-jms-connector` feature. It highlights that this property is deprecated as of version 2.0.0, as the feature key is now read directly from the Aerospike server. - [Configure streaming from JMS to Aerospike](https://aerospike.com/docs/connectors/streaming/jms/inbound/configure.md): This document provides a guide for setting up streaming from JMS to Aerospike by editing the `aerospike-jms-inbound.yml` config file. It details how to configure service settings, JMS queues and topics, connection properties for both the message broker and Aerospike database, as well as feature keys and logging. - [Set Java options for the JMS inbound connector](https://aerospike.com/docs/connectors/streaming/jms/inbound/configure/java-options.md): This guide provides step-by-step instructions for configuring the JAVA_OPTS environment variable for Aerospike's JMS inbound connector. It details how to create systemd override files via systemctl edit and how to set variables for non-systemd Docker containers, including specific examples for adjusting Java heap size and netty workdir. - [Configure log output for JMS inbound connector](https://aerospike.com/docs/connectors/streaming/jms/inbound/configure/logging.md): This document explains how to configure the logging section of the aerospike-jms-inbound.yml file. It details options for log file paths, retention policies, ticker intervals, and available formats like JSON or simple. Additionally, it provides specific guidance on capturing message parsing errors by adjusting the message-parser log level. - [Configure connection properties from the connector to a JMS message broker](https://aerospike.com/docs/connectors/streaming/jms/inbound/configure/jms.md): This document provides detailed instructions on configuring the `jms` section of the Aerospike inbound connector to connect to message brokers like IBM MQ, Solace, ActiveMQ Artemis, and RabbitMQ. It explains essential parameters such as connection factories and JNDI names, while detailing broker-specific authentication methods and how to use external configuration files for sensitive credentials. - [Message Transformer for Aerospike Connect for JMS](https://aerospike.com/docs/connectors/streaming/jms/inbound/configure/message-transformer.md): This document provides a technical guide for implementing custom Java code to transform incoming JMS messages into Aerospike records using the InboundMessageTransformer interface. It details Maven dependencies, configuration via aerospike-jms-inbound.yml, thread safety considerations, and deployment steps for bundling transformations as .jar files. - [Configure service settings for the JMS inbound connector](https://aerospike.com/docs/connectors/streaming/jms/inbound/configure/service.md): This guide provides detailed instructions for configuring the service section of the Aerospike JMS inbound connector's YAML file. It covers cluster naming, setting up the management REST API for metrics and logs, and implementing TLS security using various store types including PEM and JKS formats. - [Specify JMS queues and topics](https://aerospike.com/docs/connectors/streaming/jms/inbound/configure/topics.md): This document provides a comprehensive guide to configuring the queues and topics sections of the Aerospike JMS inbound connector's YAML file. It details how to distribute JMS sessions, define Aerospike write/delete operations, and map incoming message fields—including keys, bins, namespaces, and TTLs—to Aerospike records using parsing formats like JSON, MsgPack, and MapMessage. - [Avro serialization format for Aerospike Kafka source (outbound) connector](https://aerospike.com/docs/connectors/streaming/kafka/outbound/formats/avro-serialization-format.md): This guide explains the Avro serialization format for the Aerospike Kafka outbound connector, including configuration options and message metadata. It provides detailed specifications and examples for both Avro Map and Record schemas, specifically addressing how to handle numeric CDT map keys and fixed schemas for record keys. - [Flat JSON format for Aerospike Kafka source (outbound) connector](https://aerospike.com/docs/connectors/streaming/kafka/outbound/formats/flat-json-serialization-format.md): This document defines the Flat JSON serialization format for Aerospike Kafka outbound connector messages. It details the structure of record keys and message metadata—including generation, last-update time, and expiration—while providing concrete examples of how write and delete events are represented as JSON objects with bins at the top level. - [Supported serialization formats for Aerospike Kafka source (outbound) connector](https://aerospike.com/docs/connectors/streaming/kafka/outbound/formats.md): This document details the message serialization formats supported by the Aerospike Kafka source (outbound) connector. It lists available options such as Avro, Kafka Avro, Flat JSON, JSON, MessagePack, and custom user-defined formats used to transform records from Aerospike's change-notification system for downstream Kafka applications. - [JSON format for Aerospike Kafka source (outbound) connector](https://aerospike.com/docs/connectors/streaming/kafka/outbound/formats/json-serialization-format.md): This document defines the JSON serialization format used by the Aerospike Kafka Source (Outbound) Connector for record events. It details the structure of 'write' and 'delete' messages, including the four-element record key array and the representation of various bin data types like CDTs, blobs, and GeoJSON. Examples are provided to illustrate how these event objects are constructed. - [Configure batching for Aerospike Connect for Kafka](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/batching.md): This document explains how to configure batching for Aerospike Connect for Kafka to group Change Notification Records into outbound messages. It details parameters like max-bytes, max-records, and batch-interval, while providing a YAML example that shows how to apply these settings globally or override them at the namespace and set levels. - [MessagePack format for Aerospike Kafka source (outbound) connector](https://aerospike.com/docs/connectors/streaming/kafka/outbound/formats/messagepack-serialization-format.md): This document defines the MessagePack serialization format for Aerospike change notifications sent to Kafka. It details the array structures for WRITE and DELETE message types, including record keys, generation, expiry, and LUT. It also specifies the encoding for various bin data types (e.g., Map, List, GeoJSON) and notes breaking changes introduced in connector version 4.0.0. - [Kafka Avro serialization format for Aerospike Kafka source (outbound) connector](https://aerospike.com/docs/connectors/streaming/kafka/outbound/formats/kafka-avro-serialization-format.md): This document details the Kafka Avro serialization format for the Aerospike Kafka source (outbound) connector using KafkaAvroSerializer and a schema registry. It specifies configuration options, subject name strategies, and provides fixed schemas for metadata, delete operations, and Kafka keys, along with implementation examples. - [Configure bin transforms for Aerospike Connect for Kafka outbound](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/bin-transforms.md): This guide details the `bin-transforms` configuration for Aerospike Connect for Kafka outbound, explaining how to use `include` and `exclude` filters to control which bins are published. It also covers direct attribute mapping via the `map` option and programmatic renaming using transforms such as regex replacements, casing changes, and trimming. - [Configure change notifications for Aerospike 4.9 and earlier](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/change-notification-4x.md): This guide covers the legacy HTTP-based change notification system for Aerospike versions 4.9 and earlier. It explains the transport mechanism's impact on performance, the retransmission logic requiring "OK" responses, and provides a detailed configuration example including parameters such as `dc-type`, `http-version`, and `http-url`. - [Configure change notifications](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/change-notification.md): This guide explains how to set up Aerospike change notifications using the XDR system to stream record updates, inserts, and deletions to external systems like the Kafka Source Connector and XDR Proxy. It covers necessary prerequisites, including Enterprise Edition 4.4+ and specific feature keys, and provides a step-by-step procedure for configuring the `aerospike.conf` file with the `connector true` property. - [Configure message format for Kafka outbound](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/format.md): This document explains how to configure the `format` section of the `/etc/aerospike-kafka-outbound/aerospike-kafka-outbound.yml` file to define data serialization for Kafka outbound streams. It details supported formats including Avro, JSON, and MessagePack, while providing a comprehensive list of Aerospike record metadata fields available for output. - [Configure streaming from Aerospike to Kafka](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure.md): This guide explains how to configure Aerospike to Kafka streaming by setting up XDR change notifications and modifying the `aerospike-kafka-outbound.yml` configuration file. It details key sections like producer properties, bin transforms, and routing, while demonstrating how to apply cascading configuration values for specific namespaces and sets. - [Setting Java options for source connectors](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/java-options.md): This document provides detailed procedures for configuring the JAVA_OPTS environment variable for Aerospike source connectors, specifically focusing on the aerospike-kafka-outbound connector. It covers creating systemd override files for service-based deployments and using the -e flag for Docker instances to manage settings like Java maximum heap size and Netty workdir. - [Configure namespaces for the Kafka outbound connector](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/namespaces.md): This document explains how to configure the namespaces section of the Aerospike Kafka outbound connector's YAML configuration file. It details how to set bin transformations, routing modes, and serialization formats at both the namespace and set levels, including the order of precedence used to apply these settings. It also warns that records are skipped if routing or format information is missing. - [Configure log output for the Kafka outbound connector](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/logging.md): This document explains how to configure the `logging` section of the `/etc/aerospike-kafka-outbound/aerospike-kafka-outbound.yml` file. It details options for log rotation, console output, and formats (simple or JSON), while providing a practical example for assigning specific log levels to components like the record parser and Kafka clients. - [Configure alternate ports for change notifications](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/port-based-config.md): This document explains how to use the `port-based-config` section in the Aerospike Kafka outbound configuration file to apply specific settings based on the receiving port. It details how to override global routing, formatting, bin-transforms, and namespace configurations, enabling users to ship change notifications to multiple destinations using a single connector cluster via XDR. - [Configure Kafka producer properties](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/producer-props.md): This guide details how to configure the producer-props section of the Aerospike Kafka outbound connector using standard Kafka ProducerConfig properties. It provides specific configuration examples for basic setups, SASL authentication, and AWS MSK with IAM authentication, while noting that key and value serializers are automatically overwritten with BytesSerializer. - [Configure ordering of outbound records](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/record-ordering.md): This document explains how to enable and configure record ordering for Aerospike outbound connectors using a Last Update Time (LUT) cache. It details the mechanism for skipping stale records, memory consumption per entry, and the critical requirement of 1:1 XDR mapping to maintain ordering guarantees across stateless connector instances. - [Configure outbound connector services for Kafka](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/service.md): This document details how to configure the service section of the aerospike-kafka-outbound.yml file. It covers network settings, supported communication protocols (TCP, HTTP), and comprehensive TLS configuration using PEM or JKS stores. Additionally, it provides instructions for setting up the Management and Metrics API endpoint for monitoring outbound server logs and metrics. - [Configure routing to a Kafka destination](https://aerospike.com/docs/connectors/streaming/kafka/outbound/configure/routing.md): This guide explains how to configure the `routing` section of the Aerospike Kafka outbound connector configuration file. It covers static routing and dynamic routing based on record namespaces, sets, or bin values. Additionally, it details how to apply transformations like regex and case changes to dynamically derived topic names. - [Configure batching for Aerospike Connect for Pulsar](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure/batching.md): This document explains how to group Change Notification Records into batches before sending them to a Pulsar broker. It details key configuration options including max-bytes, max-records, and batch-interval, while providing a YAML example showing how to apply these settings globally or override them at the namespace and set levels. - [Configure bin transforms for Aerospike Connect for Pulsar outbound](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure/bin-transforms.md): This guide details how to configure `bin-transforms` for Aerospike Connect for Pulsar outbound to manage record bin names in published messages. It explains how to use `include` and `exclude` filters, explicit name mapping via the `map` property, and programmatic transformations such as regex replacements, case changes, and trimming. - [Configure Pulsar client properties for Pulsar outbound](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure/client-props.md): This document provides a detailed YAML example for configuring the `client-configuration` property of the Aerospike Pulsar outbound connector. It covers essential client settings including service URLs, authentication, timeout values, and TLS configurations required to properly initialize Producer instances connecting to Apache Pulsar. - [Configure message format for Pulsar outbound](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure/format.md): This document explains how to configure serialization for Aerospike data sent to Pulsar, supporting JSON, Flat JSON, Avro, MessagePack, and custom formats. It details specific settings such as map key stringification and provides a comprehensive list of available Aerospike record metadata fields like digest, generation, and expiry. - [Configure log output for the Pulsar outbound connector](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure/logging.md): This document explains how to configure the logging section of the aerospike-pulsar-outbound.yml file. It details options for specifying log file paths, enabling console output, managing retention history, and setting specific log levels (error, warn, info, debug, trace). It also covers available log formats, such as simple and JSON, providing a practical YAML configuration example. - [Configure streaming from Aerospike to Pulsar](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure.md): This document provides instructions for setting up outbound streaming from Aerospike to Apache Pulsar, covering necessary XDR and change notification requirements. It details the `/etc/aerospike-pulsar-outbound/aerospike-pulsar-outbound.yml` file, explaining how to configure routing, bin transformations, and message formats at the global, namespace, and set levels using cascading values. - [Configure alternate ports for change notifications](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure/port-based-config.md): This document explains how to use the port-based-config section of the Aerospike Pulsar outbound connector configuration file. It details how to override global routing, formatting, and namespace settings for specific ports, allowing a single connector cluster to ship change notifications to multiple destinations via XDR. - [Configure namespaces for the Pulsar outbound connector](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure/namespaces.md): This document explains how to configure namespaces and sets for the Aerospike Pulsar outbound connector, covering bin transforms, routing, and format settings. It outlines the configuration priority hierarchy (set > namespace > default) and warns that records will be skipped if mandatory routing or format information is missing. - [Configure ordering of outbound records](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure/record-ordering.md): This document explains how to enable and configure record ordering for Aerospike outbound connectors using a Last Update Time (LUT) cache. It details how the system prevents out-of-order writes by skipping stale records and provides guidance on managing memory via `lut-cache-ttl-seconds`. It also highlights the need for 1:1 XDR mapping to ensure global ordering across connector instances. - [Configure routing to a Pulsar destination](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure/routing.md): This document provides detailed configuration guidelines for routing Aerospike records to Pulsar topics. It covers six routing modes—static, skip, namespace, set, bin, and custom—and explains how to use transformations like regex, trim, and case conversion to dynamically derive the destination topic based on record attributes. - [Configure outbound connector services for Pulsar](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure/service.md): This document details the `service` section of the Aerospike Pulsar Outbound connector's YAML configuration file. It provides specific instructions for setting up listening ports, choosing communication protocols (TCP/HTTP), tuning IO threads, and implementing comprehensive TLS security using either JKS or PEM-formatted keystores and truststores. - [Configure Pulsar producer properties for Pulsar outbound](https://aerospike.com/docs/connectors/streaming/pulsar/outbound/configure/topic-wise-producer-props.md): This guide explains how to customize Pulsar producer settings for specific topics using the `topic-wise-producer-props` configuration map in Aerospike's Pulsar outbound connector. It describes how these properties are passed to the Producer Builder's `loadConf` method and provides a YAML example for configuring parameters like `sendTimeoutMs` and `producerName`. - [Configure properties of connections from the connector to Aerospike Database](https://aerospike.com/docs/connectors/streaming/pulsar/inbound/configure/aerospike.md): This guide explains how to configure the `aerospike` section of the `aerospike-pulsar-inbound.yml` file for connecting a Pulsar inbound connector to an Aerospike database. It details the setup of seed nodes, TLS security, authorization credentials, and performance parameters like connection limits and event loop size, alongside settings for timeouts and boolean particle types. - [Configure the Pulsar inbound connector](https://aerospike.com/docs/connectors/streaming/pulsar/inbound/configure.md): This document details the configuration options for the `aerospike-pulsar-inbound.yml` file, specifically the `aerospike` and `topics` subsections. It explains how to set up connection properties and define transformation mappings that translate Pulsar topics into Aerospike records, including configurations for namespaces, sets, keys, TTLs, and bins. - [Message Transformer for Aerospike Connect for Pulsar](https://aerospike.com/docs/connectors/streaming/pulsar/inbound/configure/message-transformer.md): This document explains how to develop and deploy a custom Java-based Message Transformer for Aerospike Connect for Pulsar. It details the implementation of the InboundMessageTransformer interface, usage of the Maven SDK, configuration via YAML files, and deployment steps to transform or filter incoming Pulsar messages before they are written to Aerospike. - [Specify Pulsar topics](https://aerospike.com/docs/connectors/streaming/pulsar/inbound/configure/topics.md): This guide explains how to configure the `topics` section of the `aerospike-pulsar-inbound.yml` file to consume Pulsar messages into Aerospike. It covers detailed mapping for namespaces, sets, and TTLs using static or dynamic modes, as well as configuring bin mappings (single vs multi-bin) and Aerospike operations like write/delete behaviors and record existence actions. - [JMS Metrics Reference](https://aerospike.com/docs/connectors/streaming/jms/metrics.md): This document provides a comprehensive reference for Aerospike JMS Connector metrics, categorized by inbound and outbound traffic. It details critical monitoring data including JVM health (CPU, memory, GC), active connection counts, and message processing success or error rates. Each entry includes the Prometheus name, measurement type, and associated labels for precise observability. - [Kafka Metrics Reference](https://aerospike.com/docs/connectors/streaming/kafka/metrics.md): This document provides a technical reference for monitoring the Aerospike Kafka Connector via Prometheus. It details specific gauge metrics for both inbound and outbound traffic, specifically tracking active or closed connections and requests that failed to be parsed or written to external systems like Kafka, JMS, or Pulsar. - [Pulsar Metrics Reference](https://aerospike.com/docs/connectors/streaming/pulsar/metrics.md): This document provides a technical reference of the metrics available for the Aerospike Pulsar Connector. It details inbound and outbound metrics for connections and requests, including their Prometheus names, measurement types (gauge), and descriptions to help users monitor XDR connectivity and parsing errors. - [ESP Metrics Reference](https://aerospike.com/docs/connectors/streaming/esp/metrics/esp.md): This document provides a comprehensive reference of outbound JVM metrics for the Aerospike ESP Connector. It details specific measurements for heap/non-heap memory, direct buffers, garbage collection, and CPU load, providing the corresponding Prometheus names and data types necessary for system monitoring and performance tuning. - [XDR-Proxy Metrics Reference](https://aerospike.com/docs/connectors/streaming/esp/metrics/xdr-proxy.md): This document provides a technical reference for monitoring the XDR-Proxy Connector via inbound and outbound metrics. It details specific gauge measurements for connections and request failures, including Prometheus naming conventions and labels. These metrics enable operators to track active connectivity and identify data that fails to write to external systems like Kafka, JMS, or Pulsar. ## Client Development - [Build with Aerospike](https://aerospike.com/docs/develop.md): This guide helps developers optimize their Aerospike integration by exploring client compatibility, connection tuning, and various data types including scalar, collection, and GeoJSON. It also details how to use expressions to filter records and extend transaction functionality for more powerful database operations. - [Client Matrix](https://aerospike.com/docs/develop/client-matrix.md): This document provides a detailed compatibility matrix for Aerospike clients and servers, outlining requirements for full feature support and minimum usable versions. It also includes language-specific technical notes, a summary of major server breaking changes, and comprehensive end-of-life (EOL) schedules for all officially supported client languages. - [Connection tuning guide](https://aerospike.com/docs/develop/connection-tuning-guide.md): This document details client-side and server-side parameters used to optimize Aerospike connection speed and reliability. It explains how to configure timeouts, retries, connection pooling, and circuit breakers to prevent issues like connection churn or thundering herds. The guide also includes practical troubleshooting for common performance problems. - [Aerospike client libraries](https://aerospike.com/docs/develop/client.md): This guide helps developers select the ideal Aerospike client by comparing the modern Developer SDK with classic clients. It highlights the Java and Python-based Developer SDK's fluent APIs and AEL query support, while providing documentation and API references for classic libraries in Go, C#, Node.js, Rust, C, and PHP. - [Geospatial index and query](https://aerospike.com/docs/develop/data-types/geospatial.md): This guide details Aerospike's geospatial capabilities, including GeoJSON storage for points and polygons using the S2 library. It provides implementation examples for creating Geo2DSphere indexes and performing queries like points-within-radius or region-contains-point. Users also learn to index elements within lists/maps and tune performance via configuration parameters. - [Scalar data types](https://aerospike.com/docs/develop/data-types/scalar.md): This document details Aerospike's scalar data types, including Integer, Double, String, Boolean, and Blob/Bytes. It outlines technical specifics like storage size, atomic operations (such as increment and append), and secondary index compatibility. The guide also explains how Java, C#, and Python clients handle language-specific serialized blobs. - [Leveraging collections](https://aerospike.com/docs/develop/data-modeling/collections.md): This guide details data modeling patterns using Aerospike Lists and Maps to consolidate related data into efficient records. It covers advanced techniques like composite keys for sorting, index persistence, and path expressions for querying list-of-structs. Additionally, it offers a comparison of collection types to help optimize performance based on access patterns. - [Naming conventions](https://aerospike.com/docs/develop/data-modeling/conventions.md): This guide outlines Aerospike naming conventions for bins, identifiers, and timestamps to maintain consistent data model contracts. It details strategies for the 15-character bin limit, guidance on choosing hashed versus cleartext identifiers based on repetition pressure, and standards for using epoch millisecond timestamps. - [Indexes](https://aerospike.com/docs/develop/data-modeling/indexes.md): This guide details Aerospike indexing strategies, including primary, secondary, set, and expression indexes. It explains how to choose index types based on query patterns, manage memory costs, and utilize advanced features like sparse indexing, nested CDT path expressions, and lookup tables for unique ID resolution. - [Data modeling](https://aerospike.com/docs/develop/data-modeling.md): This guide explains how to design Aerospike data models by prioritizing access patterns over normalization or embedding. It details key principles like optimizing record sizes (1–128 KiB) to minimize index overhead and using parallel batch reads instead of server-side joins to achieve low latency. - [Key design](https://aerospike.com/docs/develop/data-modeling/key-design.md): Learn how key design dictates partition ownership and access speed in Aerospike. This guide details patterns like entity-time slicing and hot-key sharding, discusses when to denormalize data, and provides technical strategies for managing record growth and minimizing read amplification using projection techniques. - [Modeling relationships](https://aerospike.com/docs/develop/data-modeling/relationships.md): This guide explains how to implement 1:1, 1:N, and N:M relationships in Aerospike without joins or foreign keys. It details patterns such as CDT consolidation, parent-held key lists, and bidirectional lists for N:M connections, while also providing advanced strategies for managing write contention and record overflow via shard-on-demand techniques. - [Expressions](https://aerospike.com/docs/develop/expressions.md): This guide covers Aerospike's strictly typed, functional expression language used for record filtering, secondary indexing, and XDR replication. It details the four primary expression types and explains how the two-phase execution model optimizes performance through metadata-first evaluation and trilean logic. Practical code examples in multiple languages are provided to demonstrate implementation. - [Record sizing](https://aerospike.com/docs/develop/data-modeling/record-sizing.md): This document provides guidance on optimizing Aerospike record sizes to balance the 64-byte primary index overhead with I/O performance. It details consolidation techniques using Lists and Maps, identifies the ideal 1–128 KiB size range, and offers decision frameworks for when to consolidate or split data based on TTL, access patterns, and write contention. - [Working with nested collection data types](https://aerospike.com/docs/develop/expressions/nesting.md): This guide demonstrates how to manipulate nested List and Map structures in Aerospike using CDT operations, expression composition, and path expressions. It provides multi-language examples for writing, reading, filtering, and creating secondary indexes on deeply nested values. Users will also learn how to perform efficient projected queries to extract specific elements from complex collections. - [Bin operations](https://aerospike.com/docs/develop/learn/bin-operations.md): This document explains how to use Aerospike's `operate` command to execute multiple sequential bin operations atomically and in isolation on a single record. It covers the in-memory execution model, support for various data types including collections, and provides practical code examples for Java, Python, Go, C, C#, and Node.js. - [Batched commands](https://aerospike.com/docs/develop/learn/batch.md): This guide explains how to use Aerospike's batched commands to group multiple record operations into single network trips, improving throughput and resource efficiency. It covers workflows, inlining, and filtering, while providing multi-language code examples for batch read, write, delete, exists, and operate operations. - [Building with Aerospike](https://aerospike.com/docs/develop/learn.md): This guide explores Aerospike's support for key-value and document store models, explaining how records, keys, and bins function. It details command types—including CRUD, bin operations, batching, and queries—and provides implementation best practices regarding schemaless data and atomicity. - [Metrics](https://aerospike.com/docs/develop/learn/metrics.md): This guide explains how to use Aerospike client metrics to monitor performance through dimensions like Cluster, Node, and Namespace. It covers the distinction between standard and extended metrics, provides a detailed list of available measurements including latency histograms, and outlines the specific schema used for metric log files. - [Single-record commands](https://aerospike.com/docs/develop/learn/single.md): This guide details Aerospike's single-record CRUD operations, including put, get, operate, touch, and delete commands. It explains key concepts like record identification via sets and namespaces, atomic multi-bin updates through the `operate` command, and provides practical code examples in Java, Python, Go, C, C#, and Node.js. - [The Circuit Breaker Pattern](https://aerospike.com/docs/develop/tutorials/circuit-breaker.md): This deep dive explains how Aerospike's built-in Circuit Breaker pattern prevents metastable failures caused by network-induced load amplification. It provides practical guidance on tuning the error rate threshold in Java clients to manage connection churn and logging overhead, ensuring high-performance system stability during transient outages. - [Tutorials](https://aerospike.com/docs/develop/tutorials.md): This document introduces Aerospike developer tutorials that combine database concepts with functional code snippets for Java, Python, and Spark APIs. It provides detailed guidance on setting up an interactive development environment using a Docker container containing Jupyter Notebooks, the Aerospike Database, and essential client libraries. - [Asynchronous API](https://aerospike.com/docs/develop/client/c/async.md): This tutorial guides developers through using the Aerospike C client's asynchronous event-driven interfaces with libev. It covers initializing event loops, managing connection limits to prevent resource exhaustion, and implementing high-throughput patterns like pipeline writes and async batch reads. The guide provides practical code examples for optimizing performance in single-record and batch operations. - [Benchmarks](https://aerospike.com/docs/develop/client/c/benchmarks.md): This document provides instructions for building and executing the Aerospike C client benchmark tool on Linux and macOS, including dependency requirements and submodule setup. It features practical command-line examples to simulate various workloads, such as adjusting read/write ratios, concurrency, object sizes, and latency distribution monitoring. - [Connecting](https://aerospike.com/docs/develop/client/c/connect.md): This document provides a technical guide for establishing connections to an Aerospike cluster using the C client library. It covers specific workflows for both plaintext and PKI TLS-encrypted connections, detailing how to configure hosts, CA certificates, and TLS names. A complete C implementation is included to demonstrate practical usage of these connection methods. - [Error handling](https://aerospike.com/docs/develop/client/c/error-handling.md): This document explains how to manage errors in the Aerospike C client by utilizing the as_error object during database operations. It details specific error metadata—including code, message, file, and line number—and provides a practical example of checking for non-AEROSPIKE_OK return statuses. - [Incompatible API changes](https://aerospike.com/docs/develop/client/c/incompatible.md): This document provides a chronological reference of non-backwards-compatible changes in the Aerospike C client API. It covers major updates like the transition from PredExp to Expressions, policy redefinitions, and CDT boolean handling. Detailed "Old" vs. "New" code examples are included for each version to assist developers with seamless migration and upgrades. - [Aerospike C Client](https://aerospike.com/docs/develop/client/c.md): This document introduces the Aerospike C Client, enabling developers to manage data within an Aerospike cluster through efficient CRUD operations. It covers advanced features such as secondary indexing with predicate logic, batch and scan processing, and event-loop-friendly asynchronous I/O for high-performance applications. - [Install the Aerospike client](https://aerospike.com/docs/develop/client/c/install.md): This guide provides detailed installation instructions for the Aerospike C client across multiple platforms including various Linux distributions, macOS, and Windows. It covers essential library prerequisites, event framework options like libuv or libev, package extraction, and specific commands for installing both development and runtime environments. - [Logging](https://aerospike.com/docs/develop/client/c/logging.md): This guide details how to manage logging in the Aerospike C client to debug cluster-related issues like node status changes and partition map errors. It provides practical code examples for implementing custom callbacks, disabling logs, and configuring hierarchical log levels ranging from ERROR to TRACE. - [Metrics](https://aerospike.com/docs/develop/client/c/metrics.md): This guide explains how to enable and interpret standard and extended metrics within the Aerospike C client. It covers programmatic configuration of cluster statistics, utilizing Dynamic Client Configuration for real-time updates, and setting up detailed latency histograms and transaction-level reporting via as_metrics_policy. - [Shared memory](https://aerospike.com/docs/develop/client/c/shm.md): This guide details how the Aerospike C client uses shared memory to optimize cluster tending in multi-process/single-threaded environments. It covers configuration fields like shm_key and shm_max_nodes, provides implementation examples, and explains operational procedures for managing segment takeovers and upgrades. - [Benchmarks](https://aerospike.com/docs/develop/client/csharp/benchmarks.md): This guide explains how to use the Aerospike C# benchmark tool to measure performance through data initialization and read/write operations. It provides step-by-step execution instructions using Visual Studio, details on seeding records for write throughput, and guidance on optimizing asynchronous command concurrency and thread counts. - [Best practices](https://aerospike.com/docs/develop/client/csharp/best-practices.md): This guide provides essential optimization techniques for the Aerospike C# client, covering topics like sharing client instances, managing connection limits, and efficient policy usage. It also details performance improvements through Replace mode and Operate() calls, alongside critical operational advice on logging, circuit breakers, and resource management. - [Connecting](https://aerospike.com/docs/develop/client/csharp/connect.md): This guide explains how to establish a connection to an Aerospike cluster using the C# AerospikeClient. It covers basic initialization with seed nodes, thread safety and connection pooling, configuring TLS secured connections (including PKI authentication), and properly closing the client connection. - [Supported data types](https://aerospike.com/docs/develop/client/csharp/data-types.md): This document lists all native Aerospike data types available via the C# client and explains how they map to internal storage formats. It covers cross-language type compatibility and provides recommendations for using modern serialization systems like MessagePack or Protocol Buffers in place of the deprecated BinaryFormatter. - [Error handling](https://aerospike.com/docs/develop/client/csharp/error-handling.md): This document explains how the Aerospike C# client handles database operation errors through the AerospikeException class. It details how to use the resultCode field for server-side causes and provides information on specific client-side error conditions like connection issues, timeouts, and query terminations. - [Incompatible API changes](https://aerospike.com/docs/develop/client/csharp/incompatible.md): This document provides a chronological reference of non-backwards-compatible API changes in the Aerospike C# client from version 3.1.0 to 7.0.0. It details critical breaking updates like the removal of BinaryFormatter for security, the migration from PredExp to Expressions, and recent shifts in boolean bin defaults. This guide helps developers manage upgrades and ensure application compatibility. - [Aerospike C# Client](https://aerospike.com/docs/develop/client/csharp.md): This document provides an overview of the Aerospike C# Client, detailing its core capabilities for managing data within an Aerospike cluster. It covers essential functions including record CRUD operations, secondary indexing with query filters, batch processing, and efficient non-blocking asynchronous I/O designed for high-throughput applications. - [Install the Aerospike client](https://aerospike.com/docs/develop/client/csharp/install.md): This document provides installation instructions for the Aerospike C# client using NuGet or source code from GitHub or the official website. It covers prerequisites like .NET 6+, explains how to manually reference Neo.Lua for aggregation queries, and details the various included projects such as unit tests, benchmarks, and WinForms demo applications. - [Logging](https://aerospike.com/docs/develop/client/csharp/logging.md): This document explains how to manage the Aerospike C# client's logging interface, including setting log levels and implementing custom callbacks with or without context. It provides a detailed reference of specific log messages categorized by cluster startup, tend processes, TLS connections, queries, and async command execution to facilitate effective debugging. - [Metrics](https://aerospike.com/docs/develop/client/csharp/metrics.md): This guide explains how to configure and access both standard and extended metrics in the Aerospike C# client. It details programmatic methods like ClusterStats, Dynamic Client Configuration for version 9.1.0+, and the use of MetricsPolicy to capture detailed latency histograms and command-level statistics. - [C# client policies](https://aerospike.com/docs/develop/client/csharp/policies.md): This guide details how to customize Aerospike C# client policies to optimize query performance and reliability. It covers connection pool management, timeout and retry settings, circuit breaker backoff behavior, and setting default policies for single-record and batch operations. It also includes configuration options for Collection Data Types like List and Map policies. - [Connecting](https://aerospike.com/docs/develop/client/php/connect.md): This guide provides step-by-step instructions for building and running the Aerospike Connection Manager Daemon (asld) for PHP clients. It details how to configure cluster policies using TOML files and outlines procedures for establishing secure connections via TLS and Public Key Infrastructure (PKI) authentication. - [Supported data types](https://aerospike.com/docs/develop/client/php/data-types.md): This document provides a complete overview of the various data types available when using the Aerospike PHP client. It covers everything from basic types like Integer and String to complex structures such as GeoJSON, List, Map, and HyperLogLog. - [Aerospike PHP Client](https://aerospike.com/docs/develop/client/php.md): This document provides an overview of the Aerospike PHP client's capabilities for managing data in a cluster. It covers essential features such as atomic and compound data operations, secondary index querying with predicate logic, batch/scan processing, and user-defined function (UDF) management. - [Install the Aerospike client](https://aerospike.com/docs/develop/client/php/install.md): This guide provides instructions for installing the Aerospike PHP client, which uses a Rust-based client and a Go connection manager. It details prerequisite setup, building from source via Makefiles or Cargo, and configuring asld.toml for server connections. It also includes practical code examples for establishing socket connections and managing record policies. - [Tutorial: Asynchronous API in Go](https://aerospike.com/docs/develop/client/go/async.md): This tutorial demonstrates how to implement asynchronous workflows in the Aerospike Go client using native goroutines and channels. It provides practical code examples for single async Get, Put, and Operate calls, as well as concurrent batch operations like BatchWrite, BatchGet, and BatchOperate, including guidance on tuning policy concurrency. - [Benchmarks](https://aerospike.com/docs/develop/client/go/benchmarks.md): This document provides instructions for building and using the Aerospike Go client benchmark tool to generate load and measure performance metrics. It includes practical examples for configuring read/write ratios, concurrency via goroutines, and object specifications, as well as how to interpret latency distribution reports. - [Best practices](https://aerospike.com/docs/develop/client/go/best-practices.md): This guide provides actionable best practices for the Aerospike Go client to optimize performance and reliability. It covers essential techniques like connection pool management, using PutBins for efficient data writes, warming up connections, and leveraging the Operate method for atomic batch operations. - [Supported data types](https://aerospike.com/docs/develop/client/go/data-types.md): This document lists the native Aerospike data types available to Go developers and explains how the library automatically maps Go types like int and []byte to internal formats. It also provides critical guidance on serializing complex structs using cross-language systems like MessagePack or Protocol Buffers for seamless interoperability. - [Connecting](https://aerospike.com/docs/develop/client/go/connect.md): This guide explains how to establish connections to an Aerospike cluster using the Go client via single or multiple seed nodes. It provides code examples for implementing TLS-secured connections with certificate pools and demonstrates how to properly clean up resources using the Close method. - [Error handling](https://aerospike.com/docs/develop/client/go/error-handling.md): This document details error handling procedures for the Aerospike Go client, specifically explaining the use of the AerospikeError type and its ResultCode() method. It also clarifies the distinction between server-side errors and internal client or standard library errors, including how io.Timeout errors are treated. - [Incompatible API changes](https://aerospike.com/docs/develop/client/go/incompatible.md): This document outlines non-backwards-compatible changes in the Aerospike Go client version 2.0.0. It details major shifts such as returning ErrKeyNotFound for missing keys, renames of Statement filters, and the removal of specific policy settings and deprecated methods. This serves as a critical reference for developers upgrading their Go implementations. - [Aerospike Go Client](https://aerospike.com/docs/develop/client/go.md): This document provides an overview of the Aerospike Go client's core capabilities for building high-performance applications. It covers essential features including atomic data operations, complex queries via secondary indexes, parallel batch and scan processes, and the management of user-defined functions (UDFs). - [Logging](https://aerospike.com/docs/develop/client/go/logging.md): This guide details how to implement logging in the Aerospike Go client for debugging and informational purposes. It covers setting up a custom *log.Logger instance and managing log verbosity through the SetLevel() method using predefined levels like DEBUG and INFO. - [Install the Aerospike client](https://aerospike.com/docs/develop/client/go/install.md): This guide provides comprehensive instructions for installing the Aerospike Go client, including minimum Go version requirements and supported operating systems. It also details how to fetch the library using `go get` and perform testing using Ginkgo and Gomega with race detection enabled. - [Metrics](https://aerospike.com/docs/develop/client/go/metrics.md): This guide explains how to use the two levels of metrics available in the Aerospike Go client: on-demand ClusterStats for connection usage and configurable Extended Metrics for command latency. It provides instructions for enabling extended metrics, configuring histogram policies like LatencyColumns and HistogramType, and lists specific command-based latency buckets. - [Go client policies](https://aerospike.com/docs/develop/client/go/policies.md): This guide explains how to customize Aerospike Go client policies for optimal query performance and reliability. It covers specific configurations including timeout settings, connection pool management through minimum and maximum connections per node, and circuit breaker functionality using error rate limits. - [Best practices](https://aerospike.com/docs/develop/client/java/best-practices.md): This guide outlines essential best practices for the Aerospike Java client, covering connection management, efficient policy reuse, and error handling via circuit breakers. It also provides specific implementation details for leveraging JDK 21 virtual threads to boost performance through optimized fanout patterns and ReentrantLock usage. - [Benchmarks](https://aerospike.com/docs/develop/client/java/benchmarks.md): This document provides comprehensive instructions for using the Aerospike Java client benchmark tool to evaluate database performance. It details how to build the application via Maven, explains various command-line arguments for configuring workloads and concurrency, and offers specific usage examples for synchronous and asynchronous benchmarking scenarios. - [Connecting](https://aerospike.com/docs/develop/client/java/connect.md): This guide provides detailed instructions for establishing connections to an Aerospike cluster using the Java client. It covers configuring single or multiple seed nodes, implementing user authentication, securing connections with TLS/PKI, enabling Zstandard compression, and managing client lifecycle through proper cleanup. - [Supported data types](https://aerospike.com/docs/develop/client/java/data-types.md): This guide outlines the native data types available in the Aerospike Java client, including Blobs, Strings, and Collections. It explains how the library handles automatic type conversion for cross-language compatibility and provides best practices for storing complex objects using serialization systems like Protocol Buffers or JSON. - [Error handling](https://aerospike.com/docs/develop/client/java/error-handling.md): This document details the various runtime exceptions thrown by the Aerospike Java client, such as Timeout, Connection, and CommandRejected. It provides a reference table for specific error types and includes a practical Java code example demonstrating how to implement effective try-catch blocks for robust error handling. - [Incompatible API changes](https://aerospike.com/docs/develop/client/java/incompatible.md): This document provides a detailed chronological reference of non-backwards-compatible changes within the Aerospike Java Client. It covers critical breaking updates including JDK compatibility requirements, security-driven removals of Java serialization, transitions from PredExp to Expressions, and significant policy redefinitions spanning from version 3.0.34 through 8.0.1. - [Aerospike Java client](https://aerospike.com/docs/develop/client/java.md): This document outlines the Aerospike Java client's high-performance capabilities, including CRUD operations and compound writes. It covers advanced features like secondary indexing with predicate logic, batch/scan processing, and non-blocking asynchronous I/O using NIO or Netty for reactive programming. - [Install the Aerospike client](https://aerospike.com/docs/develop/client/java/install.md): This guide provides instructions for installing the Aerospike Java client, including selecting between JDK 8 and JDK 21 packages to optimize performance via virtual threads. It details dependency configurations for various build managers, options for building from source, and how to integrate Bouncy Castle crypto or Netty support. - [Logging](https://aerospike.com/docs/develop/client/java/logging.md): This guide explains how to manage the Aerospike Java client's logging interface to debug cluster-related errors and node changes. It provides instructions for enabling standard stdout logging, implementing custom Log.Callback interfaces, disabling logs, and filtering messages by severity levels like INFO or DEBUG. - [Metrics](https://aerospike.com/docs/develop/client/java/metrics.md): This guide explains how to enable and configure standard and extended metrics in the Aerospike Java client via programmatic or dynamic methods. It covers accessing data through on-demand snapshots using getClusterStats() or log files, as well as setting custom identification labels. - [Managing mTLS with a Java client](https://aerospike.com/docs/develop/client/java/mtls.md): This guide explains how to configure mutual TLS (mTLS) for Aerospike Java clients, covering server-side configuration and certificate management. It provides detailed instructions for creating Java TrustStores and PKCS #12 KeyStores, implementing the necessary ClientPolicy in code, and using JVM arguments for secure connection and debugging. - [Java client policies](https://aerospike.com/docs/develop/client/java/policies.md): This guide details how to customize Aerospike Java client policies for optimal performance and reliability. It covers connection settings like timeouts and retries, session pool management including min/max connections and circuit breaker backoff, and setting defaults for single-record and batch operations. It also explains policy configurations for Collection Data Types (CDT). - [Select TLS Cipher Suites (Java)](https://aerospike.com/docs/develop/client/java/select-tls-ciphers.md): This guide explains how to specify TLS cipher suites in both Aerospike server configurations and Java applications using TlsPolicy to optimize security and performance. It includes detailed instructions on mapping IANA notation to OpenSSL, troubleshooting available ciphers with nmap or Java scripts, and debugging handshakes via JVM arguments. - [Benchmarks](https://aerospike.com/docs/develop/client/node/benchmarks.md): This document provides instructions for setting up and executing the Aerospike Node.js client benchmark tool to test cluster performance. It details configuration parameters via config.json—including read/write ratios, worker processes, and key ranges—and explains how to interpret TPS logs and latency histogram summaries. - [Connecting](https://aerospike.com/docs/develop/client/node/connect.md): This guide details how to establish connections using the Aerospike Node.js client, including module importation and client configuration. It provides specific implementation examples for standard authentication, TLS-secured connections, and PKI-based mutual authentication. Users will also learn how to apply data compression via write and read policies. - [Supported data types](https://aerospike.com/docs/develop/client/node/data-types.md): This document details the various data types supported by the Aerospike Node.js client, such as Boolean, GeoJSON, and Maps. It provides specific implementation guidance and JavaScript code examples for using 64-bit integers, NULL-terminated strings, and byte arrays (via Buffer or Uint8Array) for both keys and record bin values. - [Error handling](https://aerospike.com/docs/develop/client/node/error-handling.md): This document explains error handling for the Aerospike Node.js client, detailing the specific properties of the AerospikeError object such as code, message, func, file, and line. It provides a practical try/catch code example and directs users to the status module for managing server-side error codes. - [Incompatible API changes](https://aerospike.com/docs/develop/client/node/incompatible.md): This document serves as a technical reference for all non-backwards-compatible changes in the Aerospike Node.js client across multiple versions. It details unsupported operating systems and Node.js environments, deprecated functions with their replacements, and significant API shifts such as policy renames and callback signature modifications to assist developers during upgrades. - [Aerospike Node.js Client](https://aerospike.com/docs/develop/client/node.md): This document outlines the core functionalities of the Aerospike Node.js client, including atomic data operations, secondary indexing with filter expressions, and batch or scan capabilities. It also provides information on how to create, register, and execute user-defined functions (UDFs) within an Aerospike cluster. - [Install the Aerospike client](https://aerospike.com/docs/develop/client/node/install.md): This guide details how to install the Aerospike Node.js client using npm or by cloning the Git repository. It outlines specific OS-level prerequisites for various distributions like Ubuntu and RHEL, provides a code example for basic CRUD operations, and explains how to run tests and benchmarks. - [Logging](https://aerospike.com/docs/develop/client/node/logging.md): This guide explains how to manage logging in the Aerospike Node.js client to debug cluster errors. It covers setting initial log verbosity levels and file paths during configuration, as well as using the `client.updateLogging()` method to modify these settings dynamically at runtime. - [Metrics](https://aerospike.com/docs/develop/client/node/metrics.md): This guide explains how to enable and manage detailed metrics in the Aerospike Node.js client using Dynamic Client Configuration or a `MetricsPolicy`. It covers accessing data through on-demand snapshots or log files, setting custom identification labels, and configuring specific parameters like latency histograms and reporting intervals. - [Managing mTLS with the Node.js client](https://aerospike.com/docs/develop/client/node/mtls.md): This guide explains how to implement mutual TLS (mTLS) for Aerospike Database Enterprise Edition using a Node.js client. It covers certificate requirements, server-side aerospike.conf settings like tls-authenticate-client, and specific Node.js client configurations for CA files, client certificates, and host TLS names. - [Connecting](https://aerospike.com/docs/develop/client/python/connect.md): This guide explains how to establish a connection to an Aerospike cluster using the Python client API. It covers configuring hosts, policies, and user authentication, while providing specific code examples for implementing TLS-secured connections with certificate configuration. - [Supported data types](https://aerospike.com/docs/develop/client/python/data-types.md): This document provides a comprehensive list of all native data types compatible with the Aerospike Python client. It serves as a technical reference for developers to identify supported formats such as Key-ordered maps, GeoJSON, Strings, and more when structuring data. - [Error handling](https://aerospike.com/docs/develop/client/python/error-handling.md): This document explains how the Aerospike Python client manages errors through the AerospikeError exception and its subclasses. It details key attributes like error codes, messages, and file locations, while providing a practical code example for implementing robust try-except blocks in your applications. - [Aerospike Python Client](https://aerospike.com/docs/develop/client/python.md): This document outlines how to leverage the Aerospike Python client to perform CRUD operations, compound reads/writes, and secondary indexing. It also details advanced functionalities such as parallel batch processing, full-set scans, and the management of user-defined functions (UDFs). - [Install the Aerospike client](https://aerospike.com/docs/develop/client/python/install.md): This guide provides instructions for installing the Aerospike Python client using pip, including specific versioning requirements to ensure server compatibility. It outlines supported Python versions (3.10–3.14) and operating systems like macOS, Windows, and various Linux distributions. Additionally, it offers tips on avoiding permission issues during installation. - [Incompatible API changes](https://aerospike.com/docs/develop/client/python/incompatible.md): This document provides a chronological technical reference of all breaking API changes within the Aerospike Python client. It details critical updates including method renames, parameter shifts for TTL and timeouts, exception type modifications, and the removal of deprecated features like auto-serialization to assist developers with version upgrades. - [Python client policies](https://aerospike.com/docs/develop/client/python/policies.md): This guide details how to customize Aerospike Python client policies to optimize command performance and reliability. It provides specific instructions on configuring timeout settings, managing connection pool sizes per node, and implementing circuit breaker backoff behavior using error rate thresholds. - [Metrics](https://aerospike.com/docs/develop/client/python/metrics.md): This guide explains how to enable and configure standard and extended metrics in the Aerospike Python client via programmatic or dynamic methods. It details specific parameters like latency histograms and reporting intervals, provides a breakdown of cluster, node, and namespace metrics, and shows how to interpret the resulting log files for performance analysis. - [Connect to Aerospike](https://aerospike.com/docs/develop/client/sdk/connect.md): This guide details how to establish connections to an Aerospike cluster using the Java and Python Developer SDKs. It explains core concepts like Cluster vs. Session lifecycles, configuring authentication and TLS, tuning system settings, and troubleshooting common connection errors with practical code examples. - [Developer SDK](https://aerospike.com/docs/develop/client/sdk.md): This document introduces the Aerospike Developer SDK, highlighting its fluent Java and Python APIs and built-in Aerospike Expression Language (AEL) capabilities. It provides practical code examples for record operations like upserting and querying, while offering guidance for new users and those migrating from the classic client. - [Installation](https://aerospike.com/docs/develop/client/sdk/install.md): This guide provides comprehensive instructions for installing the Aerospike Developer SDK for Java and Python. It details minimum version requirements, dependency management via Maven, Gradle, and pip, verification steps with code examples, IDE configuration for IntelliJ, VS Code, and PyCharm, and troubleshooting common installation issues. - [Quickstart](https://aerospike.com/docs/develop/client/sdk/quickstart.md): This guide provides a hands-on introduction to the Aerospike Developer SDK for Java and Python developers. It walks through installing dependencies, establishing cluster connections, performing record upserts, reading by key, and executing AEL queries, providing complete code examples for immediate implementation. - [Best practices](https://aerospike.com/docs/develop/client/rust/best-practices.md): Learn to optimize Aerospike Rust client performance by reusing a single thread-safe Client instance across tasks. This guide details strategies for user-defined key storage, executing efficient batch operations with operate(), and using Replace mode for full-record overwrites to minimize overhead. - [Supported data types](https://aerospike.com/docs/develop/client/rust/data-types.md): This document lists all native data types supported by the Aerospike Rust client, such as Integers, Lists, and Maps. It explains the automatic mapping process between Rust types and Aerospike storage, including specific handling for u64 value limitations, floating-point formats, and string de-serialization. - [Connecting](https://aerospike.com/docs/develop/client/rust/connect.md): This document provides technical instructions for establishing connections to an Aerospike cluster via the Rust client. It covers configuring single or multiple seed nodes, implementing TLS with mutual authentication, managing the connection lifecycle, and includes a complete end-to-end code example for record creation. - [Error handling](https://aerospike.com/docs/develop/client/rust/error-handling.md): This document details how to manage errors in the Aerospike Rust client using the aerospike::Error enum. It provides practical guidance on pattern matching server-side errors, handling individual failures within asynchronous streams, and integrating with popular crates like anyhow and thiserror. - [Incompatible API changes](https://aerospike.com/docs/develop/client/rust/incompatible.md): This document details non-backwards-compatible API changes for the Aerospike Rust client, focusing on the major v2.0.0 rewrite which introduces an async runtime, unified query/scan APIs, and a new error model. It also covers the transition from predicate expressions to Aerospike Expressions introduced in version 1.0.0. - [Overview: Aerospike Rust client](https://aerospike.com/docs/develop/client/rust.md): This document provides an overview of the Aerospike Rust client, highlighting its async-first design using Tokio and advanced BatchOperationAPI support. It details recent improvements to policies, expression builders, and CDT type support, while outlining a roadmap for features like ACID transactions and strong consistency. - [Install the Aerospike Rust client](https://aerospike.com/docs/develop/client/rust/install.md): This guide provides detailed instructions for installing the Aerospike Rust client using Cargo or building from source. It covers minimum Rust version requirements and explains how to configure dependencies for both Tokio and async-std runtimes, supporting both modern Async and legacy Sync APIs. - [Logging](https://aerospike.com/docs/develop/client/rust/logging.md): This guide explains how to implement logging in the Aerospike Rust client by utilizing the standard log crate facade. It provides practical steps for adding dependencies like env_logger and demonstrates how to control specific module log levels using the RUST_LOG environment variable. - [Collection data types](https://aerospike.com/docs/develop/data-types/collections.md): This document explains Aerospike's Collection Data Types (CDTs), such as Lists and Maps, which act as schema-free containers for scalar or nested elements. It details CDT operations for in-place modification and expressions for record filtering. Additionally, it covers path expressions like selectByPath and modifyByPath for advanced multi-element selection within nested structures. - [Context for operations on nested elements](https://aerospike.com/docs/develop/data-types/collections/context.md): This guide explains how to navigate deeply nested List and Map structures in Aerospike using CDT contexts and element selectors. It covers targeting specific elements by index, rank, or key, creating missing paths via MAP_KEY_CREATE, and utilizing advanced path expressions for multi-element selection and filtering across various language clients. - [Order and compare collection elements](https://aerospike.com/docs/develop/data-types/collections/ordering.md): This document outlines the specific element ordering rules for Aerospike List and Map collections based on a defined type hierarchy from NIL to INF. It explains how various data types like strings, integers, and nested collections are compared. Furthermore, it provides guidance on using wildcards and intervals for advanced list and map comparison operations. - [Path expressions usage examples](https://aerospike.com/docs/develop/expressions/path/advanced.md): This guide provides advanced Aerospike path expression examples for manipulating nested maps and lists. It demonstrates techniques like using LoopVars, applying SelectFlags such as MAP_KEY and NO_FAIL, performing in-place updates with modifyByPath, and deleting elements via removeResult. It also covers complex filter combinations and robust error handling strategies. - [Path expressions](https://aerospike.com/docs/develop/expressions/path.md): This guide explains Aerospike's path expression functionality for traversing and modifying nested Collection Data Types (CDTs). It covers selectByPath and modifyByPath operations, context-based navigation with allChildrenWithFilter, loop variables, and provides practical multi-language code examples using a JSONPath bookstore dataset. - [Frequently asked questions](https://aerospike.com/docs/develop/expressions/path/faq.md): This FAQ provides technical guidance on Aerospike path expressions, detailing the use of selectFlags such as MATCHING_TREE and NO_FAIL. It clarifies how to work with Maps and Lists and offers specific implementation details regarding the limitations and chaining of mapKeysIn and andFilter in nested document queries. - [Performance](https://aerospike.com/docs/develop/expressions/path/performance.md): This guide details optimization strategies for Aerospike path expressions, specifically comparing three methods for efficient IN-list filtering on map keys. It also provides guidance on general performance factors like nesting depth, batch inlining policies for large records, and CDT element limits to ensure high-speed data retrieval. - [Quickstart: Path expressions](https://aerospike.com/docs/develop/expressions/path/quickstart.md): This quickstart guide teaches developers how to use Aerospike path expressions to query and filter nested maps and lists. Using a detailed e-commerce catalog example, it provides multi-language code implementations to demonstrate granular filtering at both product and variant levels while preserving the data hierarchy. - [Troubleshooting](https://aerospike.com/docs/develop/expressions/path/troubleshooting.md): This guide identifies common Aerospike path expression errors, such as OP_NOT_APPLICABLE, PARAMETER_ERROR, and operation timeouts. It provides specific causes for these issues—ranging from type mismatches to deeply nested CDT structures—along with actionable solutions to help developers resolve query and traversal problems efficiently. - [Dynamic Client Configuration](https://aerospike.com/docs/develop/learn/dynamic-client-config.md): This document details how to implement real-time Aerospike client configuration updates using a local YAML file. It covers the setup process via environment variables, explains static versus dynamic parameters, and provides usage scenarios for adjusting connection policies and metrics. This enables SREs to improve operational agility and incident recovery without application restarts. - [Dynamic Client Configuration Quickstart](https://aerospike.com/docs/develop/learn/dynamic-client-config/quickstart.md): This quickstart guides infrastructure teams through setting up dynamic Aerospike client configurations using YAML files and enabling granular observability metrics. It demonstrates how to apply real-time changes to settings like timeouts and retries under load, allowing for performance fine-tuning without code modifications or application restarts. - [Complete YAML schema](https://aerospike.com/docs/develop/learn/dynamic-client-config/yaml.md): This technical reference outlines the complete YAML schema for Aerospike's Dynamic Client Configuration. It provides a detailed breakdown of static startup parameters and dynamic runtime settings, including client connectivity, command policies for reads, writes, queries, scans, batch operations, and metrics collection. - [Queries](https://aerospike.com/docs/develop/learn/queries.md): This guide details how to execute foreground read-only queries and asynchronous background update queries in Aerospike using primary and secondary indexes. It covers advanced features like filter expressions, projection, and pagination, while explaining how to optimize performance by choosing between short and long query execution modes. - [Projection](https://aerospike.com/docs/develop/learn/queries/projection.md): This document explains Aerospike's bin and operation projection techniques for queries, enabling efficient data retrieval through path expressions and CDT operations. It highlights how to use server-side computations to reduce latency by replacing the two-phase query-then-batch pattern with a single unified API call. Detailed multi-language code examples are provided for implementing these advanced projections. - [Primary index queries](https://aerospike.com/docs/develop/learn/queries/primary-index.md): This guide covers executing foreground read-only queries and background record-modifying queries against the Aerospike primary index. It demonstrates advanced techniques such as bin projection, metadata-based filter expressions, single-partition querying, and in-place map operations to remove expired segments. Comprehensive code examples are included for Java, Python, Go, C, C#, and Node.js. - [Secondary index queries](https://aerospike.com/docs/develop/learn/queries/secondary-index.md): This guide covers Aerospike secondary index queries, detailing foreground, aggregation, and background query types. It explains how to implement index filters and record filter expressions using various data types, CDT contexts, and expression indexes. The document provides multi-language code examples for creating indexes and executing complex read and write operations. - [Aerospike Interactive Tutorial: Tweetaspike](https://aerospike.com/docs/develop/tutorials/applications/tweetaspike.md): This interactive Jupyter notebook tutorial uses the Tweetaspike Java application to demonstrate core Aerospike database operations. It covers essential patterns like CRUD, secondary index querying, and batch reads, alongside advanced techniques such as Lua User Defined Functions (UDFs) and Compare-and-Swap (CAS). The guide provides practical code examples for managing user profiles and tweet data models. - [Aerospike Interactive Tutorial: Advanced Collection Data Types](https://aerospike.com/docs/develop/tutorials/cdt/advanced-cdt-java.md): This interactive Jupyter notebook tutorial teaches Java developers how to master advanced Collection Data Types in Aerospike. It covers using contexts (CTXs) for nested Lists and Maps, exploring various return type options like RANK and REVERSE_INDEX, and applying sophisticated write policies such as NO_FAIL and PARTIAL to shape command behavior. - [Aerospike Interactive Tutorial: CDT Indexing](https://aerospike.com/docs/develop/tutorials/cdt/cdt-indexing-java.md): This interactive Java tutorial demonstrates Aerospike's CDT indexing capabilities for versions 6.1.0+. It provides practical code examples for performing equality and range queries on nested Lists, Maps, and JSON documents using secondary indexes. Users learn to index specific elements by rank, key, or position to optimize complex data retrieval. - [Aerospike Interactive Tutorial: Reading and Updating Lists](https://aerospike.com/docs/develop/tutorials/cdt/working-with-lists-java.md): This interactive tutorial teaches developers how to use the Aerospike Java client to manage list-based data structures. It covers advanced server-side operations including reading elements by index, rank, or value range, as well as updating lists through appending, incrementing, and sorting with specific flags like dropping duplicates. - [Aerospike Interactive Tutorial: Reading and Updating Maps](https://aerospike.com/docs/develop/tutorials/cdt/working-with-maps-java.md): This interactive Jupyter notebook tutorial guides Java developers through performing CRUD operations on Aerospike maps. It specifically details server-side read methods like retrieving elements by rank or key range, as well as update operations such as adding new entries, removing keys, and managing map order using MapPolicy objects. - [Aerospike Interactive Tutorial: Local In-Memory Cache](https://aerospike.com/docs/develop/tutorials/cache/local-cache.md): This interactive Jupyter notebook tutorial demonstrates how to implement a local in-memory cache in front of an Aerospike database using Python. It provides a practical cache interface and uses a mathematical model to analyze performance gains based on hit ratios and speed ratios, helping users identify the most effective scenarios for caching. - [Aerospike Tutorial: Look-Aside Cache for MongoDB](https://aerospike.com/docs/develop/tutorials/cache/look-aside-cache-mongo-python.md): This Jupyter notebook tutorial demonstrates how to implement a look-aside caching pattern using Python with Aerospike and MongoDB. It provides practical code examples for connecting to both databases and implementing logic to retrieve data from the cache or fall back to MongoDB on a cache miss. - [Aerospike Tutorial: Look-Aside Cache for MongoDB](https://aerospike.com/docs/develop/tutorials/cache/look-aside-cache-mongo-java.md): This Java-based Jupyter notebook tutorial demonstrates how to implement a look-aside cache pattern using Aerospike as the caching layer and MongoDB as the primary datastore. It provides complete code examples for configuring both clients, populating MongoDB, and executing the cache-aside logic to optimize data retrieval performance. - [Aerospike Interactive Tutorial: Intro to Data Modeling](https://aerospike.com/docs/develop/tutorials/data-modeling/intro-to-data-modeling-java.md): This interactive Java tutorial provides a hands-on guide to Aerospike data modeling, covering core elements like namespaces, sets, records, bins, and collection types. Through practical code examples and architectural guidance, it teaches users how to align application object models with Aerospike's high-performance structure for optimal scalability. - [Aerospike Interactive Tutorial: Modeling With Maps](https://aerospike.com/docs/develop/tutorials/data-modeling/modeling-with-maps-java.md): This interactive Jupyter notebook tutorial teaches developers how to model complex data using Aerospike Maps with Java. It provides practical examples of key/value ordering, index and rank operations, and managing nested subcontexts for efficient server-side processing. The guide also compares Bins versus Maps to help optimize storage efficiency and performance. - [Aerospike Interactive Tutorial: Basic Operations](https://aerospike.com/docs/develop/tutorials/intro/basic-operations-python.md): This interactive Jupyter notebook tutorial demonstrates fundamental CRUD operations in Aerospike using the Python client. Users will learn about record structures, metadata management, bin-specific actions like incrementing and appending, batch reading, and performing multiple atomic operations on a single record via the `operate` API. - [Aerospike Interactive Tutorial: Modeling With Lists](https://aerospike.com/docs/develop/tutorials/data-modeling/modeling-with-lists-java.md): This interactive Jupyter notebook tutorial teaches developers how to use the Aerospike Java client for advanced list modeling. It covers ordered vs. unordered lists, rank operations on mixed data types, and interval queries using tuples. Practical examples like IoT sensor readings and a sports leaderboard demonstrate real-world application. - [Aerospike Interactive Tutorial: Hello, World!](https://aerospike.com/docs/develop/tutorials/intro/hello-world-java.md): This interactive Jupyter notebook tutorial guides developers through getting started with the Aerospike Java client. It covers essential operations including client initialization, understanding record keys via namespaces and sets, writing data using bins, and reading records back from the database. The guide also provides a complete Java boilerplate code example for practical use. - [Aerospike Tutorial: Java Object Mapper](https://aerospike.com/docs/develop/tutorials/data-modeling/object-mapper-java.md): This tutorial provides a hands-on guide to the Aerospike Java Object Mapper, teaching developers how to use annotations for efficient data persistence. It explores mapping Java types to Aerospike bins, implementing embedded objects via Maps or Lists, and managing complex object relationships through references and nested graphs. - [Aerospike Interactive Tutorial: Hello, World!](https://aerospike.com/docs/develop/tutorials/intro/hello-world-python.md): This interactive Jupyter notebook tutorial provides a hands-on guide to using the Aerospike Python client. It covers essential tasks including configuring client connections, understanding primary key structures, writing schema-less records, and retrieving data along with its associated metadata like TTL and record generation. - [Aerospike Interactive Tutorial: Intro to Transactions](https://aerospike.com/docs/develop/tutorials/intro/intro-to-transactions-java.md): This interactive Jupyter notebook tutorial guides Java developers through executing atomic multi-operation transactions on single Aerospike records via the `operate` API. It provides practical examples for manipulating simple and complex data types like Lists, Maps, GeoJSON, and HyperLogLogs, while demonstrating how to use write policies for conditional logic. - [Aerospike Interactive Tutorial: Implementing Read-Write Transactions with R-M-W Pattern](https://aerospike.com/docs/develop/tutorials/intro/read-modify-write-python.md): This tutorial explains how to implement the Read-Modify-Write (R-M-W) pattern in Aerospike using Python to ensure atomicity and isolation for single-record transactions. It demonstrates how concurrency causes lost writes and provides a robust solution using conditional writes with generation checks and exponential backoff retries. - [Aerospike Interactive Tutorial: Readme and Tips](https://aerospike.com/docs/develop/tutorials/intro/readme-tips.md): This tutorial provides practical tips for working with Aerospike interactive Jupyter notebooks. It covers executing shell commands via magic commands, examining server logs, managing database records with the aql tool, and monitoring cluster state using the asadm utility. - [Aerospike Interactive Tutorial: Simple Put-Get Example](https://aerospike.com/docs/develop/tutorials/intro/simple-put-get-java.md): This interactive Jupyter notebook tutorial guides Java developers through performing simple put and get operations in Aerospike. It covers dependency management via Maven POM and provides both full class implementations and streamlined code snippets to facilitate quick integration of the Aerospike client. - [Aerospike Interactive Tutorial: Simple Put-Get Example](https://aerospike.com/docs/develop/tutorials/intro/simple-put-get-python.md): This tutorial provides practical Python code examples for performing basic put and get operations in an Aerospike cluster. It covers client configuration, defining keys via namespace, set, and user key tuples, writing schemaless records with bins, and retrieving record metadata like TTL and generation. - [Background filter query](https://aerospike.com/docs/develop/tutorials/operations/background-ops.md): This guide demonstrates how to execute background filter queries in Aerospike for non-time-sensitive maintenance tasks like data cleanup. It includes code examples in Java, Go, and Python for creating expressions based on record metadata or data, performing operations like bin deletion or math, and managing long-running jobs via task IDs and the asadm tool. - [Aerospike Interactive Tutorial: Batched commands in Aerospike](https://aerospike.com/docs/develop/tutorials/operations/batch-ops-java.md): This interactive Java tutorial demonstrates expanded Aerospike batch capabilities, including multi-key write, UDF execution, and delete operations. Through practical code examples, it covers synchronous APIs for multi-key commands and general batched commands, alongside advanced features like command/filter expressions and inline processing. - [Aerospike Interactive Tutorial: Understanding Asynchronous Operations](https://aerospike.com/docs/develop/tutorials/operations/async-ops-java.md): This interactive Java tutorial explores Aerospike's asynchronous execution model, detailing the use of event loops, listeners, and throttling to achieve high throughput. Through practical code examples, users learn to implement single record CRUD, batch operations, and complex nested async calls like scan-and-update patterns. - [Aerospike Interactive Tutorial: Understanding Expressions](https://aerospike.com/docs/develop/tutorials/operations/expressions-java.md): This interactive Java tutorial explores Aerospike expressions, focusing on Filter and Operation Expressions for efficient data selection and server-side read/write capabilities. It covers syntax patterns like Polish notation, variable scoping with `let` and `def`, and conditional evaluation using `cond`. Practical examples demonstrate how to optimize performance by reducing R-M-W cycles. - [Aerospike Interactive Tutorial: Queries in Python](https://aerospike.com/docs/develop/tutorials/queries/query-python.md): This interactive Jupyter notebook tutorial demonstrates how to execute Aerospike queries using the Python client. It covers connecting to a cluster, creating integer secondary indexes, projecting specific bins with select(), applying predicates like between() or equals(), and processing query results via the foreach() API. - [Splitting Large Data Sets for Parallel Processing of Queries](https://aerospike.com/docs/develop/tutorials/queries/query-splits-java.md): This Jupyter notebook tutorial teaches how to implement multiple schemes for dividing large Aerospike datasets into equal splits for parallel processing in Java. It provides a comprehensive test framework to analyze performance variations across worker counts, chunk sizes, and query/filter options using both sync and async modes. - [Aerospike Interactive Tutorial: Query and UDF](https://aerospike.com/docs/develop/tutorials/queries/query-udf-java.md): This interactive Jupyter notebook tutorial demonstrates how to integrate Aerospike queries with User Defined Functions (UDFs) using the Java client. It provides two practical implementation patterns: performing server-side data aggregation via a sum function and executing conditional record updates by combining secondary index filters, predicate expressions, and UDFs. - [Processing Query Results as a Stream of Records](https://aerospike.com/docs/develop/tutorials/queries/query-streams-java.md): This Java tutorial demonstrates how to process Aerospike query results as record streams using synchronous and asynchronous methods. It provides specific implementation details for paginating through results, partitioning queries for parallel processing, and resuming execution at a later time using partition cursors across secondary, set, and primary indexes. - [Aerospike Tutorial: Simple Load and Store with Aerospike Data on Spark](https://aerospike.com/docs/develop/tutorials/spark/simple-load-store.md): This Jupyter notebook tutorial demonstrates how to use the Aerospike Spark Connector to move data between Aerospike Database and Apache Spark. It covers creating sample datasets, saving data with specific keys, loading via schema inference or explicit schemas, and optimizing performance using pushdown expressions and secondary indexes. - [Aerospike Tutorial: Aerospike Connect for Spark for Python](https://aerospike.com/docs/develop/tutorials/spark/spark-connector-python.md): This Jupyter notebook tutorial demonstrates how to use the Aerospike Connect for Spark connector with Python. It covers schema inference, working with Collection Data Types (CDT), performing efficient batch get queries via primary keys or digests, implementing expression pushdown, and utilizing advanced features like aerolookup. - [Aerospike Tutorial: Aerospike Connect for Spark for Scala](https://aerospike.com/docs/develop/tutorials/spark/spark-connector-scala.md): This Scala-based tutorial demonstrates how to use the Aerospike Connect for Spark connector for data ingestion and retrieval. It covers schema inference, handling complex collection data types, and executing optimized SparkSQL queries using primary keys to trigger batch gets. Users also learn efficient sampling techniques to minimize data movement between Aerospike and Spark clusters. - [Aerospike Interactive Tutorial: SQL Operations: Aggregates Part 1](https://aerospike.com/docs/develop/tutorials/sql/sql-aggregates-part-1-java.md): This interactive Java tutorial demonstrates how to implement SQL aggregate queries in Aerospike via stream User Defined Functions (UDFs). It covers the execution model of operators like Filter, Map, and Reduce, providing practical examples for simple aggregates—SUM, COUNT, MIN, MAX—and complex computations like AVERAGE and RANGE using the Aggregate operator. - [Aerospike Interactive Tutorial: SQL Operations: Aggregates Part 2](https://aerospike.com/docs/develop/tutorials/sql/sql-aggregates-part-2-java.md): This interactive Java tutorial demonstrates how to implement advanced SQL aggregate operations in Aerospike using Lua-based User Defined Functions (UDFs). It covers practical patterns for stream partitioning with GROUP BY, including HAVING and ORDER BY clauses, alongside DISTINCT, LIMIT, and TOP N queries. The guide also explains the two-phase execution model involving both server nodes and the client. - [Aerospike Interactive Tutorial: SQL Operations: SELECT](https://aerospike.com/docs/develop/tutorials/sql/sql-select-java.md): This interactive Java tutorial demonstrates how to implement SQL SELECT operations in Aerospike, mapping relational concepts to namespaces, sets, and bins. It covers single/batch record retrieval, existence checks, and predicate-based searches using secondary indexes or expression filters. Users also learn to execute computed fields via server-side User Defined Functions (UDFs). - [Aerospike Interactive Tutorial: SQL Operations: CREATE, UPDATE, DELETE](https://aerospike.com/docs/develop/tutorials/sql/sql-update-java.md): This interactive Jupyter notebook tutorial demonstrates how to implement SQL-style CREATE, UPDATE, and DELETE operations in Aerospike using the Java client. It covers namespace, set, and index management, alongside single-record multi-ops and complex multi-record updates via bin lists or User Defined Functions (UDFs). - [Logs](https://aerospike.com/docs/develop/client/c/best-practices/log.md): This document guides users on enabling Aerospike C client logging to monitor cluster status, node changes, and errors via the background tend thread. It also explains how to implement a circuit breaker using max_error_rate and error_rate_window to automatically manage requests during node failures. - [Policies](https://aerospike.com/docs/develop/client/c/best-practices/policies.md): This guide explains how the Aerospike C client uses policies to control database operation behavior. It covers setting default policies via configuration, understanding the fallback mechanism for undefined or NULL values, and implementing per-operation overrides using specific policy initialization functions. - [Records](https://aerospike.com/docs/develop/client/c/best-practices/records.md): This guide details how to manage Aerospike C client records, covering initialization methods for stack and heap allocation. It explains techniques for accessing and setting various bin types, managing memory with refcounts, traversing bins via iterators or callbacks, and understanding how read commands populate record data. - [Asynchronous API](https://aerospike.com/docs/develop/client/csharp/async.md): This tutorial demonstrates how to use the Aerospike C# AsyncClient for efficient, non-blocking record operations using libev and event-driven interfaces. It includes a practical code example covering connection setup, writing data with WriteListener, and reading records via RecordListener. The guide also explains managing application synchronization to ensure asynchronous commands complete before closing connections. - [Asynchronous API](https://aerospike.com/docs/develop/client/java/async.md): This tutorial explains how to implement asynchronous, event-driven interfaces in the Aerospike Java client for improved thread efficiency. It covers setting up event loops and listeners, providing a full Java example of how to write large sets of records asynchronously using Netty or NIO. - [Asynchronous operations](https://aerospike.com/docs/develop/client/node/best-practices/operations.md): This document explains how to implement asynchronous database operations in the Aerospike Node.js client using modern async/await patterns, Promise chaining, or legacy callbacks. It provides practical code examples for CRUD operations and details best practices for error handling and ensuring proper connection closure. - [Logs](https://aerospike.com/docs/develop/client/node/best-practices/log.md): This document explains how to enable Aerospike Node.js client logs to monitor cluster status changes, such as node additions or removals. It also provides technical details on implementing a circuit breaker using max error rate and window configurations to manage node failures and handle request retries effectively. - [Asynchronous API](https://aerospike.com/docs/develop/client/node/async.md): This guide demonstrates how to perform asynchronous database operations in the Aerospike Node.js client using both callbacks and Promises. It provides a practical code example for writing large datasets with controlled concurrency via p-limit, while also noting support for async Batch, Delete, and Scan commands. - [Policies](https://aerospike.com/docs/develop/client/node/best-practices/policies.md): This document explains how the Aerospike Node.js client utilizes policies to control database operations such as reads and writes. It details the hierarchy of policy application—from defaults to command-level overrides—and describes how to use Replace mode in WritePolicy to optimize performance when updating all record bins. - [Records](https://aerospike.com/docs/develop/client/node/best-practices/records.md): This document explains the composition of Aerospike records and provides essential guidance for Node.js developers. It details why using strictly string keys for maps is necessary to prevent automatic type conversion errors caused by JavaScript object limitations. - [Key validation](https://aerospike.com/docs/develop/client/python/usage/key-validation.md): This guide explains how to use the "validate_keys" setting in the Aerospike Python client to prevent errors caused by invalid dictionary keys. It covers how to validate client configuration, command policies, and record metadata dictionaries using practical code examples that demonstrate error handling via ParamError exceptions. - [Behaviors](https://aerospike.com/docs/develop/client/sdk/concepts/behaviors.md): This guide explains how to use Aerospike Behaviors to manage timeouts, retries, and consistency levels across Java and Python SDKs. It details pre-built profiles like READ_FAST, custom behavior derivation, and the multiple sessions pattern for per-operation tuning. Additionally, it provides practical retry strategies and a decision tree for choosing the right configuration. - [Behaviors and selectors](https://aerospike.com/docs/develop/client/sdk/concepts/behaviors-and-selectors.md): This guide details the Aerospike SDK's Behavior and Selector model for configuring operational settings like timeouts, retries, and consistency modes. It explains how to derive custom behaviors in Java and Python and describes setting resolution through selector cascades and inheritance. The document also provides specific references for read, write, batch, and query-based operations. - [Best practices](https://aerospike.com/docs/develop/client/sdk/concepts/best-practices.md): This guide provides production-ready best practices for the Aerospike Developer SDK in Java and Python. It details essential patterns for cluster sharing, session management for diverse workloads, connection pool sizing, and robust error handling. Developers can use these recommendations and monitoring checklists to ensure high performance and reliability in production environments. - [Connection management](https://aerospike.com/docs/develop/client/sdk/concepts/connections.md): This guide explains the Aerospike SDK's connection architecture, covering automated cluster discovery via seed hosts and connection pooling mechanics. It details how the client handles node failures and provides specific instructions for monitoring connection health in both Java and Python environments. - [Decoupled configuration](https://aerospike.com/docs/develop/client/sdk/concepts/configuration.md): This document explains the Aerospike Developer SDK's decoupled configuration model, which separates cluster connection details managed by operators from operational behaviors controlled by developers. It provides implementation examples in Java and Python, covers external YAML configuration, and outlines configuration precedence rules. - [CDT (Collection data type) operations](https://aerospike.com/docs/develop/client/sdk/concepts/cdt-operations.md): This guide details how to use Aerospike's CDT operations to read, write, and remove elements within Map and List bins using Java and Python SDKs. It covers advanced features like range-based selections, nested structure navigation, and performing multiple operations in a single server call to avoid read-modify-write cycles. - [Consistency models](https://aerospike.com/docs/develop/client/sdk/concepts/consistency.md): This document compares Aerospike’s AP (Available, Partition-tolerant) and SC (Strong Consistency) modes, detailing their trade-offs in availability, latency, and durability. It provides practical guidance through use case recommendations, a comparison table, Java/Python SDK code examples, and server-side namespace configuration requirements. - [Data model](https://aerospike.com/docs/develop/client/sdk/concepts/data-model.md): This guide details Aerospike’s hierarchical data model, explaining how namespaces, sets, records, and bins organize information. It covers technical concepts like key digests, generation counts for optimistic locking, and complex nested bin types. Developers will also learn to use the DataSet and RecordId SDK abstractions with practical Java and Python code examples and modeling best practices. - [Error handling](https://aerospike.com/docs/develop/client/sdk/concepts/error-handling.md): This guide details three execution modes for error handling in Aerospike's Java and Python SDKs: Default, In-stream errors, and Error callbacks. It provides code examples for single-key and batch operations, explains how to inspect RecordResult objects, and shows how to isolate failed records using the failures() method. - [Error handling](https://aerospike.com/docs/develop/client/sdk/concepts/errors.md): This guide details how to handle errors in the Aerospike Developer SDK using Java and Python. It covers exception hierarchies, common error types like GenerationException and TimeoutException, and provides practical code examples for recovery. Users will also find insights on retryable vs. non-retryable errors and best practices for robust implementation. - [Understanding the fluent API](https://aerospike.com/docs/develop/client/sdk/concepts/fluent-api.md): This guide explores the design philosophy of the Aerospike Developer SDK, focusing on its fluent interface pattern. It compares verbose classic client implementations with readable, chainable code examples in Java and Python while explaining key principles like immutability, discoverability, and terminal operations for effective development. - [Migrating from classic client](https://aerospike.com/docs/develop/client/sdk/concepts/migration.md): This guide assists developers in transitioning from the Aerospike classic client to the Developer SDK. It details conceptual changes in connection models and record references while providing side-by-side code mappings for CRUD operations in both Java and Python. Additionally, it outlines migration strategies and lists currently unsupported features. - [Understanding the SDK API](https://aerospike.com/docs/develop/client/sdk/concepts/sdk-api.md): This guide explains the design philosophy of the Aerospike Developer SDK, focusing on its fluent interface and method chaining patterns. Through Java and Python examples, it compares the new SDK to the classic client, demonstrating how builders improve readability and discoverability for complex operations like data insertion and cluster configuration. - [Secondary indexes](https://aerospike.com/docs/develop/client/sdk/concepts/secondary-indexes.md): This guide explains how to implement secondary indexes in Aerospike using the Java and Python Developer SDKs. It details index types, provides best practices for use cases, and includes complete code examples for creating and querying indexes via AEL predicates. Developers will also find critical performance considerations regarding memory usage and write latency. - [Cache-aside pattern](https://aerospike.com/docs/develop/client/sdk/recipes/cache-aside.md): This recipe demonstrates how to implement the cache-aside (lazy-loading) pattern using Aerospike to reduce database load. It provides complete, production-ready code implementations in both Java and Python, along with practical usage examples and an overview of various cache invalidation strategies like TTL and write-through. - [Rate limiting](https://aerospike.com/docs/develop/client/sdk/recipes/rate-limiting.md): This recipe demonstrates how to implement distributed rate limiting using Aerospike’s atomic increment operations and TTL for automatic window resets. It provides complete, ready-to-use implementations in Java and Python, ensuring race-condition-free coordination across multiple application servers with sub-millisecond latency. - [Session store](https://aerospike.com/docs/develop/client/sdk/recipes/session-store.md): Learn to implement a high-performance session store for web applications using Aerospike's Developer SDK. This guide provides complete Java and Python code examples for managing user sessions with sub-millisecond reads, automatic TTL-based expiration, and efficient session extensions using the touch operation. - [Advanced TLS configuration](https://aerospike.com/docs/develop/client/sdk/reference/advanced-tls.md): This guide provides advanced TLS configuration details for Aerospike, including cipher suite selection and OpenSSL vs IANA naming mappings. It features practical implementation examples for Java and Python clients, troubleshooting steps for common handshake errors, and performance optimization strategies like session resumption and hardware-specific cipher choices. - [Benchmark tool](https://aerospike.com/docs/develop/client/sdk/reference/benchmark.md): This guide details how to build and execute the Aerospike Developer SDK benchmark tool for Java and Python. It includes a full CLI reference, example workloads like read-heavy or batch operations, and actionable advice on interpreting latency metrics and tuning configurations to resolve performance bottlenecks. - [Common issues](https://aerospike.com/docs/develop/client/sdk/reference/common-issues.md): This guide helps developers troubleshoot common Aerospike Developer SDK issues, including connection failures on localhost, cluster discovery problems, and empty DSL query results. It also offers solutions for performance bottlenecks like high read latency, providing specific causes and actionable steps to resolve them. - [Version compatibility](https://aerospike.com/docs/develop/client/sdk/reference/compatibility.md): This document provides a compatibility matrix between Aerospike Developer SDK versions and Aerospike Server versions, including required Java and Python environments. It also details feature availability by server version and offers code snippets for verifying client and cluster versions in both Java and Python. - [Error codes](https://aerospike.com/docs/develop/client/sdk/reference/error-codes.md): This document is intended to provide a complete reference of all Aerospike Developer SDK error codes and their specific meanings. Although the page is currently under construction, it will serve as a key resource for developers troubleshooting errors within the SDK. - [Known issues (preview)](https://aerospike.com/docs/develop/client/sdk/reference/known-issues.md): This document details specific limitations within the Aerospike Developer SDK preview release, such as restricted AEL surface area, a 5000-record batch size limit, and lack of UDF support. It provides workarounds for these constraints and instructions on how to report new issues via GitHub for Java and Python. - [Upgrade guide](https://aerospike.com/docs/develop/client/sdk/reference/upgrade-guide.md): This guide provides instructions for upgrading between Aerospike Developer SDK versions, including specific paths like the 0.9.x to 1.0.x transition for Java and Python. It also outlines deprecation policies, compatibility requirements with the Aerospike Server, and migration steps from the classic client. - [Async operations](https://aerospike.com/docs/develop/client/sdk/usage/async.md): This guide demonstrates how to implement high-throughput, non-blocking database access using the Aerospike Developer SDK in Java and Python. It provides code examples for asynchronous reads, writes, batch operations, and streaming queries, including advanced patterns like async pipelines and parallel execution with virtual threads or asyncio. - [Batch operations](https://aerospike.com/docs/develop/client/sdk/usage/batch.md): This guide demonstrates how to optimize Aerospike performance using batch operations for reading, writing, upserting, and deleting multiple records in a single request. It provides practical implementation examples in both Java and Python, covering advanced scenarios like mixed operation types, bin projection, and handling partial failures. - [Create records](https://aerospike.com/docs/develop/client/sdk/usage/create.md): This guide provides comprehensive instructions for creating records in Aerospike using the Java and Python Developer SDKs. It covers fundamental operations like insert and upsert, managing time-to-live (TTL) settings, working with complex data types such as lists and maps, and implementing batch creation for improved efficiency. - [Delete records](https://aerospike.com/docs/develop/client/sdk/usage/delete.md): This guide provides comprehensive instructions on removing records from Aerospike using the Developer SDK in both Java and Python. It covers essential techniques such as simple deletions, conditional deletes via generation checks, durable deletions, batch processing, soft delete patterns, and automatic expiration using TTL. - [Configure logging](https://aerospike.com/docs/develop/client/sdk/usage/logging.md): This guide explains how to enable and configure client-side logging for the Aerospike Java and Python SDKs. It provides recommended log levels for production and development, instructions for disabling logs or implementing custom handlers, and a reference list of cluster events and error messages to assist in troubleshooting. - [Enable metrics](https://aerospike.com/docs/develop/client/sdk/usage/metrics.md): This guide explains how to monitor Aerospike client performance by implementing metrics within Java and Python applications. It covers standard and extended metrics like latency and connection pools, providing specific code examples for manual instrumentation and integration with monitoring ecosystems such as Prometheus, Grafana, and Datadog. - [Query records](https://aerospike.com/docs/develop/client/sdk/usage/query.md): This guide explains how to use the Aerospike Expression Language (AEL) to find and filter records through the Java and Python Developer SDKs. It details comparison, logical, and membership operators, while demonstrating how to select specific bins, limit results, and stream large datasets efficiently with complete code examples. - [Read records](https://aerospike.com/docs/develop/client/sdk/usage/read.md): This guide details how to retrieve records using the Aerospike Developer SDK in Java and Python. It covers essential operations like fetching specific bins for performance, handling missing records, accessing metadata such as TTL and generation, and performing existence checks. Practical code examples demonstrate type-safe bin reading and basic batch operation concepts. - [Use transactions](https://aerospike.com/docs/develop/client/sdk/usage/transactions.md): This guide demonstrates how to execute multi-record transactions in Aerospike with ACID guarantees using Java and Python SDKs. It covers essential topics including Strong Consistency requirements, commit/abort mechanics, retry patterns for transient failures, and handling in-doubt states. The document also outlines transaction limitations and best practices for optimizing performance. - [Update records](https://aerospike.com/docs/develop/client/sdk/usage/update.md): Learn to modify existing Aerospike records using Java and Python Developer SDKs through various techniques. This document details updating specific bins, atomic numeric increments, string manipulation, and in-place updates for Collection Data Types (CDTs). It also covers record metadata management via "touch," bin removal, and implementing optimistic locking with generation checks to prevent conflicts. - [Examples for List operations](https://aerospike.com/docs/develop/data-types/collections/list/examples.md): This document provides practical code examples for implementing Aerospike list use cases such as queues and time series containers. It explains modeling many-to-one relationships and demonstrates atomic enqueue/dequeue operations alongside retrieving data via value ranges. Implementation samples are available in Java, Python, C, Go, C#, and Node.js. - [List indexing and querying](https://aerospike.com/docs/develop/data-types/collections/list/index-and-query.md): This guide details how to define secondary indexes on Aerospike list bins at any depth for various data types. It provides asadm commands for index creation and complete code examples for querying across multiple client libraries like Java, Python, and Go. The document also explains key behaviors regarding scalar vs. list value indexing. - [List](https://aerospike.com/docs/develop/data-types/collections/list.md): This document details the Aerospike List data type, explaining the functional differences between unordered and ordered subtypes. It covers essential terminology including index, value, and rank, alongside a comprehensive API reference for element manipulation. Users will also find development tips on performance optimization, such as using persisted indexes for ordered lists. - [List performance](https://aerospike.com/docs/develop/data-types/collections/list/performance.md): This document provides a worst-case Big O runtime performance analysis for Aerospike list operations. It compares unordered lists, ordered lists, and ordered lists with persisted indices to help developers balance CPU usage against storage capacity. The guide includes detailed complexity tables for read, modify, and set type operations along with implementation notes. - [Map operations examples](https://aerospike.com/docs/develop/data-types/collections/map/examples.md): This guide provides practical code examples for Aerospike map operations across multiple languages like Java, Python, and Go. It demonstrates modeling complex use cases such as event history containers using millisecond timestamps or unique UUIDs. Scenarios include retrieving data by value patterns, counting events, trimming maps via index ranges, and performing interval-based queries. - [Map indexes and querying](https://aerospike.com/docs/develop/data-types/collections/map/index-and-query.md): This guide explains how to define secondary indexes on Aerospike map keys and values for numeric, string, and GeoJSON data types. It provides multi-language code examples for executing equality and range queries, while detailing indexing depth capabilities and known limitations like duplicate record returns during range queries. - [Map](https://aerospike.com/docs/develop/data-types/collections/map.md): This guide details the Aerospike Map data type, covering its three subtypes—Unordered, K-ordered, and KV-ordered—and their unique indexing behaviors. It provides essential terminology like key, index, and rank, alongside a complete list of API operations for element manipulation. Users will also find tips on performance optimization using PERSIST_INDEX and details on known limitations. - [Map performance](https://aerospike.com/docs/develop/data-types/collections/map/performance.md): This document provides a detailed worst-case Big O runtime complexity analysis for various Aerospike map operations, including modification, reading, and type settings. It compares performance across four distinct configurations—unordered, ordered, persisted offset index, and persisted full index—to help developers balance CPU efficiency against storage capacity. - [Aerospike Tutorial: Model Serving with Aerospike Feature Store](https://aerospike.com/docs/develop/tutorials/applications/feature-store/model-serving.md): This tutorial demonstrates how to use Aerospike as a feature store for machine learning model serving using the Aerospike Python client. It guides you through loading a pre-trained Random Forest model, retrieving precomputed features, and building a Flask web service to provide real-time predictions based on transaction IDs. - [Aerospike Tutorial: Feature Store with Aerospike](https://aerospike.com/docs/develop/tutorials/applications/feature-store/feature-engineering.md): This Jupyter notebook tutorial demonstrates how to implement a Machine Learning feature store using Aerospike and the Aerospike Spark Connector. It covers data modeling for Feature Groups, Features, and Entities, and provides practical feature engineering examples using credit card fraud and simulated salary datasets. - [Aerospike Tutorial: Model Training with Aerospike Feature Store](https://aerospike.com/docs/develop/tutorials/applications/feature-store/model-training.md): This tutorial demonstrates how to use Aerospike as a feature store for machine learning training using PySpark and the Aerospike Spark Connector. It covers implementing object models for features and datasets, utilizing pushdown expressions for optimized querying, and training/evaluating Logistic Regression and Random Forest models on credit card transaction data. - [Create](https://aerospike.com/docs/develop/client/c/usage/atomic/create.md): This document provides a practical usage guide for the aerospike_key_put() operation within the Aerospike C client API. It details how to initialize records and keys, perform writes, manage resource cleanup, and customize write behavior through policies such as existence checks, timeouts, Read-Modify-Write patterns, and TTL settings. - [Delete](https://aerospike.com/docs/develop/client/c/usage/atomic/delete.md): This guide demonstrates how to remove data from Aerospike using the C client. It provides specific code examples for initializing a key with as_key_init_str() and executing the deletion through aerospike_key_remove(), including basic error handling. - [Bin operations](https://aerospike.com/docs/develop/client/c/usage/atomic/multi.md): This guide details how to execute multiple bin modifications, such as read, write, increment, and append, within a single atomic command using the Aerospike C client. It includes practical code examples for common patterns like increment-and-read, touching records to manage TTL, and performing complex operations on map and list bins. - [Read](https://aerospike.com/docs/develop/client/c/usage/atomic/read.md): This guide details how to perform read operations using the Aerospike C client, covering methods for fetching all bins, selecting specific bin arrays, and verifying record existence through metadata. It includes practical code examples for key initialization, bin traversal, and managing command timeouts via read policies. - [Batched commands](https://aerospike.com/docs/develop/client/c/usage/multi/batch.md): This guide explains how to implement efficient multi-record reads in the Aerospike C client using batched commands. It covers initializing as_batch objects, configuring keys, and utilizing aerospike_batch_get for full records or aerospike_batch_exists for metadata. Additionally, it details result processing via callback functions and managing concurrent execution. - [Transactions](https://aerospike.com/docs/develop/client/c/usage/multi/transactions.md): This document provides a practical C code example demonstrating how to execute CRUD operations within an Aerospike transaction. It covers initializing transactions, performing batch writes, reading, and deleting records while managing commit errors and abort scenarios. Additionally, it highlights specific requirements like strong-consistency namespaces and the use of durable deletes for record removal. - [Asynchronous connect](https://aerospike.com/docs/develop/client/csharp/async/connect.md): This guide explains how to initialize the Aerospike C# AsyncClient using a seed node for automatic cluster discovery. It details how the client manages node health via maintenance threads, handles network disturbances by re-pinging nodes, and utilizes thread-safe connection pooling for efficient performance. - [Asynchronous write](https://aerospike.com/docs/develop/client/csharp/async/write.md): This document demonstrates how to use the Aerospike C# AsyncClient to execute asynchronous write operations. It provides code examples for implementing a custom WriteHandler listener to manage success and failure events, including how to chain a subsequent read operation within the OnSuccess callback. - [Asynchronous read](https://aerospike.com/docs/develop/client/csharp/async/read.md): This guide demonstrates how to use the Aerospike C# client to asynchronously read a single record by implementing the RecordListener interface. It provides a practical code example of a RecordHandler class that manages OnSuccess and OnFailure callbacks to retrieve bin values and notify parent processes upon completion. - [Create](https://aerospike.com/docs/develop/client/csharp/usage/atomic/create.md): This guide demonstrates how to create records in Aerospike using the C# client. It covers configuring WritePolicy settings like sendKey, defining record keys, and populating various bin types including integers, dictionaries, and GeoJSON coordinates, providing a complete code example for implementation. - [Expressions - C#](https://aerospike.com/docs/develop/client/csharp/usage/atomic/expressions.md): This guide details how to use Aerospike's strongly typed expression language in the C# client for single record commands. It provides practical implementation patterns for both filter expressions—used during reads and writes—and operation expressions, which enable atomic value computations. The documentation includes complete code examples for filtering and computing values within maps, lists, and bins. - [Delete](https://aerospike.com/docs/develop/client/csharp/usage/atomic/delete.md): This guide provides instructions for deleting records using the Aerospike C# client. It covers setting up connections, applying write policies, and explains how to use durable deletes to prevent zombie records during cold restarts, complete with a full code example. - [Bin operations](https://aerospike.com/docs/develop/client/csharp/usage/atomic/multi.md): This document provides a guide for executing atomic bin operations in Aerospike using the C# client API. It demonstrates how to use the `operate` method for both single and multiple operations, such as updating maps or incrementing values, within a single transaction. The guide also explains how to interpret returned results from complex multi-operation calls. - [Read](https://aerospike.com/docs/develop/client/csharp/usage/atomic/read.md): This guide demonstrates how to use the Aerospike C# client to retrieve data through various read operations. It includes code examples for setting up hosts and keys, configuring custom policies like socket timeouts, and performing tasks such as checking record existence, reading metadata, or fetching full records and specific bins. - [Batched commands](https://aerospike.com/docs/develop/client/csharp/usage/multi/batch.md): This guide demonstrates how to use the Aerospike C# client to execute batched commands, including reads, writes, deletes, and complex multi-operation requests. It provides practical code examples for implementing batch policies, using expression-based operations, and processing heterogeneous lists of batch records in a single request. - [Update](https://aerospike.com/docs/develop/client/csharp/usage/atomic/update.md): This guide provides instructions on performing atomic updates using the Aerospike C# client. It covers configuring WritePolicies via RecordExistsAction, performing type-specific operations like integer addition, replacing entire records, and deleting specific bins by setting them to null. - [Transactions](https://aerospike.com/docs/develop/client/csharp/usage/multi/transactions.md): This guide demonstrates how to implement CRUD operations and multi-record transactions using the Aerospike C# client. It provides practical code examples for updating nested maps via MapOperation and managing multi-record transactions (MRT) with durable deletes, ensuring data consistency in complex workflows. - [Aggregations](https://aerospike.com/docs/develop/client/csharp/usage/udf/aggregations.md): This document provides a technical guide on implementing aggregations in the Aerospike C# client using Stream User Defined Functions (UDFs). It includes a Lua code example for a count function, explains how to map and reduce data streams, and demonstrates how to execute secondary index queries to retrieve aggregated results. - [Apply a UDF](https://aerospike.com/docs/develop/client/csharp/usage/udf/apply.md): This guide provides practical C# examples for executing Aerospike Record UDFs. It demonstrates how to call functions with single or multiple arguments on individual records, perform efficient batch operations on sets of keys, and run background queries using filter expressions to apply UDFs across matching records. - [Manage UDFs](https://aerospike.com/docs/develop/client/csharp/usage/udf/manage.md): This guide demonstrates how to manage User-Defined Functions (UDFs) in Aerospike using the C# client. It provides specific code examples for registering Lua packages, removing obsolete functions, and updating UDFs by clearing the server cache via the client or asadm. - [Aggregations](https://aerospike.com/docs/develop/client/c/usage/udf/aggregations.md): This document explains how to aggregate Aerospike query results by integrating C client queries with Lua Stream UDFs. It provides step-by-step instructions for defining queries, writing Lua functions utilizing map and reduce operations, registering UDFs, and executing the aggregation using aerospike_query_foreach(). - [Apply a UDF](https://aerospike.com/docs/develop/client/c/usage/udf/apply.md): This guide details how to apply User Defined Functions (UDFs) using the Aerospike C client, covering both single-record application with aerospike_key_apply() and mass record transformations via background scans. It includes specific Lua UDF implementations and C code examples for managing parameters, executing scans, and monitoring progress. - [Manage UDFs](https://aerospike.com/docs/develop/client/c/usage/udf/manage.md): This guide explains how to use the Aerospike C client to register, update, and remove Lua-based User Defined Function (UDF) modules. It provides practical code examples for reading script files into `as_bytes` objects and demonstrates the usage of `aerospike_udf_put()` and `aerospike_udf_remove()`. - [Create](https://aerospike.com/docs/develop/client/php/usage/atomic/create.md): This guide provides a practical PHP example for creating new records in an Aerospike database using the put method. It demonstrates connecting via a socket, defining keys with namespaces and sets, and storing various bin types such as integers, strings, floats, and complex nested arrays. - [Delete](https://aerospike.com/docs/develop/client/php/usage/atomic/delete.md): This guide provides a practical PHP code example demonstrating the use of the Aerospike client's delete method. It walks through connecting to the database, creating a complex record with various bin types—including integers, strings, floats, and nested arrays—and successfully deleting that specific key using a WritePolicy. - [Read](https://aerospike.com/docs/develop/client/php/usage/atomic/read.md): This document provides a practical PHP code example demonstrating how to interact with an Aerospike database. It covers establishing a connection, defining keys and complex bins containing various data types—including nested arrays and associative maps—and performing write and read operations using the put and get methods. - [Update](https://aerospike.com/docs/develop/client/php/usage/atomic/update.md): This guide provides a practical PHP code example for creating and modifying Aerospike records. It demonstrates how to initialize a connection, define keys, and work with diverse bin data types like nested lists and maps, while specifically illustrating atomic updates using the prepend and append methods. - [Manage UDFs](https://aerospike.com/docs/develop/client/php/usage/udf/manage.md): This guide provides a practical PHP implementation for managing User-Defined Functions (UDFs) in Aerospike. It covers registering Lua scripts via the client, executing functions to perform complex record updates, and listing all available UDFs to manage your database logic effectively. - [Batched commands](https://aerospike.com/docs/develop/client/php/usage/multi/batch.md): This document provides a practical PHP code example for implementing multiple batched operations in Aerospike. It demonstrates how to configure BatchWrite with filter expressions alongside BatchRead and BatchDelete commands, all executed within a single batch request via the client. - [Map operations](https://aerospike.com/docs/develop/client/go/usage/cdt.md): This guide explains how to perform server-side Collection Data Type (CDT) operations on maps and lists using the Aerospike Go client. It provides practical code examples for the Operate() method, clarifies how OpResults are returned based on bin usage, and details Map and List policy configurations. - [Best practices and tips](https://aerospike.com/docs/develop/client/go/usage/cdt/best-practices.md): This guide outlines best practices for using Complex Data Types (CDT) in the Aerospike Go client, focusing on performance optimizations like server-side operations and batching. It also provides practical code examples for performing necessary type assertions on various operation results, including maps, lists, and primitives. - [Quick reference](https://aerospike.com/docs/develop/client/go/usage/cdt/reference.md): This document provides a quick reference guide for Aerospike Go client Complex Data Type (CDT) operations. It summarizes key Map and List operations like Put, Get, Append, and Pop, alongside their respective return types such as VALUE, KEY, and INDEX. Additionally, it lists essential context helper functions used to navigate nested CDT structures. - [Create](https://aerospike.com/docs/develop/client/go/usage/document/create.md): This guide demonstrates how to create document records in Aerospike using the Go client by leveraging JSON and Collection Data Types. It provides a complete code walkthrough, including marshaling JSON into maps and lists, writing data via PutBins, and reading it back for verification. - [Read](https://aerospike.com/docs/develop/client/go/usage/document/read.md): This guide demonstrates how to manage JSON documents in Aerospike using the Go client by leveraging Collection Data Types like maps and lists. It provides a complete code example covering JSON marshaling, writing records with PutBins, and retrieving data through Get operations. - [Update](https://aerospike.com/docs/develop/client/go/usage/document/update.md): This guide provides a practical walkthrough for updating complex JSON-like documents in Aerospike using the Go client. It demonstrates how to use the Operate method with MapPutOp, leveraging CtxMapKey and CtxListIndex to navigate and modify specific fields within nested Collection Data Types (CDTs) like maps and lists. - [Batched commands](https://aerospike.com/docs/develop/client/go/usage/multi/batch.md): This guide provides practical examples for implementing batched operations using the Aerospike Go client, covering BatchExists, BatchGet, BatchOperate, and BatchDelete. It details how to combine diverse requests—such as updates, deletes, and complex operation expressions—into single batch executions to optimize performance. - [Create](https://aerospike.com/docs/develop/client/go/usage/atomic/create.md): This guide demonstrates how to create records in an Aerospike database using the Go client. It provides step-by-step examples for configuring write policies, constructing keys with namespaces and sets, and writing complex data structures like maps, lists, and GeoJSON via the PutBins method. - [Delete](https://aerospike.com/docs/develop/client/go/usage/atomic/delete.md): This guide demonstrates how to use the Aerospike Go client to delete records through both default and durable delete methods. It explains how to configure write policies to implement durable deletes, which prevent zombie records during cold restarts, and provides a complete code example for implementation. - [Expressions - Go](https://aerospike.com/docs/develop/client/go/usage/atomic/expressions.md): This guide explains how to use Aerospike's functional DSL via the Go client to perform single record commands using expressions. It details the implementation of filter expressions for reads and writes, alongside operation expressions for atomic bin manipulations. Practical Go code examples are provided for both filtering records and computing values during operations. - [Bin operations](https://aerospike.com/docs/develop/client/go/usage/atomic/multi.md): This guide demonstrates how to use the Aerospike Go client's `operate` method for atomic bin operations. It covers executing single operations, combining multiple reads and writes into a single transaction, and details how results are returned and grouped by bin name. - [Read](https://aerospike.com/docs/develop/client/go/usage/atomic/read.md): This guide demonstrates how to perform various read operations using the Aerospike Go client, such as checking record existence, retrieving metadata via GetHeader, and fetching full or specific bins with Get. It also covers configuring custom read policies like socket timeouts and provides a complete, runnable code example for implementation. - [Aggregations](https://aerospike.com/docs/develop/client/go/usage/udf/aggregations.md): This guide demonstrates how to use Stream UDFs to perform aggregations on query results within the Aerospike Go client. It includes a complete example of defining Lua functions for mapping and reducing data, setting local UDF paths, and executing aggregate queries using secondary index filters to return computed values. - [Update](https://aerospike.com/docs/develop/client/go/usage/atomic/update.md): This guide explains how to update Aerospike records using the Go client, focusing on configuring write policies like UPDATE_ONLY and REPLACE_ONLY. It provides practical code examples for updating bins with PutBins, performing type-specific atomic operations with AddBins, replacing entire records, and deleting specific bins by setting them to null. - [Apply a UDF](https://aerospike.com/docs/develop/client/go/usage/udf/apply.md): This guide provides practical examples for executing Record User Defined Functions (UDFs) with the Aerospike Go client. It covers three primary use cases: applying a UDF to a single record with one or more arguments, performing batch execution on multiple keys, and running background queries using filter expressions to process entire sets. - [Manage UDFs](https://aerospike.com/docs/develop/client/go/usage/udf/manage.md): This guide demonstrates how to manage User-Defined Functions (UDFs) in Aerospike using the Go client and asadm tool. It provides practical code examples for registering Lua packages, removing existing UDFs, and performing updates by clearing the server-side UDF cache. - [Create Event Loops](https://aerospike.com/docs/develop/client/java/async/eventloop.md): This guide details how to implement event loops for the Aerospike Java async client using either Netty (NIO/EPOLL) or lightweight direct NIO. It explains how to use EventPolicy to manage command throttling and prevent socket exhaustion, providing practical code examples for each approach. - [Asynchronous connect](https://aerospike.com/docs/develop/client/java/async/connect.md): This document explains how to establish and manage asynchronous connections in the Aerospike Java client using event loops. It provides specific guidance on cluster seeding, proper shutdown procedures, and connection tuning via parameters like maxCommandsInProcess and asyncMinConnsPerNode to optimize performance. - [Asynchronous read](https://aerospike.com/docs/develop/client/java/async/read.md): This guide explains how to perform asynchronous read operations in the Aerospike Java client using the get method. It details the implementation of an EventLoop and a RecordListener to manage onSuccess and onFailure callbacks, providing complete Java code examples for both initiating reads and handling completion results. - [Scan with async touch](https://aerospike.com/docs/develop/client/java/async/scantouch.md): This document provides a Java code example for executing asynchronous touch commands on every record returned from a full Aerospike cluster scan. It demonstrates how to use synchronous scans combined with custom throttling to prevent async queue overload and event loop blocking, featuring implementations of ScanCallback and WriteListener. - [Asynchronous write](https://aerospike.com/docs/develop/client/java/async/write.md): This guide explains how to implement asynchronous writes in the Aerospike Java client using the put() method with EventLoop and WriteListener arguments. It provides practical code examples for handling success and failure callbacks, as well as instructions for integrating Netty event loops into your application. - [Spring Data](https://aerospike.com/docs/develop/client/java/object-mapping/spring-data.md): This document introduces the Spring Data Aerospike library for mapping Java POJOs to the Aerospike database. It details support for both synchronous and reactive programming models and provides a curated list of tutorials covering CRUD operations, secondary indexes, optimistic locking, and reactive repositories. - [Create](https://aerospike.com/docs/develop/client/java/usage/document/create.md): This guide demonstrates how to create JSON document records in Aerospike using the Java client by converting JSON strings into Java Maps via Gson. It covers setting up a WritePolicy, storing complex data as Collection Data Types (CDTs), and provides a complete code example for implementing these operations efficiently. - [Read](https://aerospike.com/docs/develop/client/java/usage/document/read.md): This guide demonstrates how to use the Aerospike Java client to read JSON document records stored as Collection Data Types. It walks through converting JSON data with Gson, writing it to a bin, and performing targeted reads using ListOperation to access specific elements within a list. - [Secondary index query](https://aerospike.com/docs/develop/client/java/usage/document/sindex.md): This guide demonstrates how to perform secondary index queries in the Aerospike Java client using two different strategies. It provides full code examples for extracting target values into separate bins during insertion versus querying nested document fields directly via complex expressions. Users can learn to set up, write, query, and clean up indexes within a programmatic workflow. - [Update](https://aerospike.com/docs/develop/client/java/usage/document/update.md): This document explains how to perform targeted updates on Aerospike JSON documents using the Java client. It walks through creating a record containing a list of sightings and demonstrates how to use MapOperation with specific context paths (CTX) to update deeply nested values within Collection Data Types. - [Create](https://aerospike.com/docs/develop/client/java/usage/atomic/create.md): This guide provides a practical walkthrough for creating records in Aerospike using the Java client. It demonstrates how to configure WritePolicy, define keys with namespaces and sets, and construct bins to store diverse data types including Maps, Lists, and GeoJSON coordinates. - [Delete](https://aerospike.com/docs/develop/client/java/usage/atomic/delete.md): This guide demonstrates how to perform record deletions using the Aerospike Java client. It explains the differences between default deletions and durable deletes, specifically how to use WritePolicy to prevent zombie records during cold restarts, and provides complete code examples for implementation. - [Expressions - Java](https://aerospike.com/docs/develop/client/java/usage/atomic/expressions.md): This document provides a technical guide on implementing Aerospike's strongly typed expression language using the Java client. It covers record filtering expressions for conditional reads and writes, alongside operation expressions for atomic computations like reading or writing computed values to bins. Detailed code examples demonstrate complex manipulations involving maps and lists. - [Bin operations](https://aerospike.com/docs/develop/client/java/usage/atomic/multi.md): This guide explains how to use the Aerospike Java client to perform atomic bin operations using the `operate` method. It covers executing single operations like map policy updates and combining multiple actions—such as puts, gets, and CDT modifications—into a single transaction. Additionally, it details how results are returned and grouped by bin name within the resulting record. - [Read](https://aerospike.com/docs/develop/client/java/usage/atomic/read.md): This guide demonstrates how to use the Aerospike Java client to perform different types of read operations. It includes practical code examples for checking record existence, retrieving metadata with getHeader(), and fetching either full records or specific bins using the get method, along with configuring custom read policies. - [Update](https://aerospike.com/docs/develop/client/java/usage/atomic/update.md): This guide details how to perform record updates using the Aerospike Java client, including configuring WritePolicy and RecordExistsAction. It provides practical examples for updating bins with new values, performing type-specific operations like integer addition, replacing entire records, and deleting specific bins by setting them to null. - [Batched commands](https://aerospike.com/docs/develop/client/java/usage/multi/batch.md): This guide demonstrates how to optimize performance using batched commands in the Aerospike Java client. It covers batch reads, writes, and deletes, while providing detailed examples of advanced techniques like applying filter expressions and combining diverse operations—such as BatchRead, BatchWrite, and BatchDelete—into a single request. - [Transactions](https://aerospike.com/docs/develop/client/java/usage/multi/transactions.md): This guide demonstrates how to perform CRUD operations using the Aerospike Java client within a transaction context. It provides a complete code example involving complex Map and List operations on a "sightings" bin, while also detailing robust error handling for version mismatches and in-doubt commit statuses. - [Aggregations](https://aerospike.com/docs/develop/client/java/usage/udf/aggregations.md): This guide demonstrates how to use the Aerospike Java client to execute aggregations on query results via Stream UDFs. It includes a detailed example of a Lua "count" function using map and reduce operations, instructions for configuring local UDF paths, and code for running secondary index range queries. - [Apply a UDF](https://aerospike.com/docs/develop/client/java/usage/udf/apply.md): This guide demonstrates how to apply Record UDFs using the Aerospike Java client through three primary methods: single record execution with varying arguments, batch operations for multiple keys, and background queries utilizing filter expressions. It includes practical code examples for each use case to help developers implement custom logic directly on the server. - [Manage UDFs](https://aerospike.com/docs/develop/client/java/usage/udf/manage.md): This guide demonstrates how to manage the lifecycle of Lua-based User-Defined Functions (UDFs) in Aerospike via the Java client and asadm tool. It covers registration, removal, and update procedures, including specific methods for clearing the UDF cache to ensure changes take effect. - [The Node.js cluster module](https://aerospike.com/docs/develop/client/node/async/cluster.md): This guide explains how to leverage the Node.js cluster module with Aerospike to maximize multi-core performance. It covers managing worker connections, using shared memory to optimize cluster status polling, and provides a full implementation example of a clustered HTTP server. - [Create](https://aerospike.com/docs/develop/client/node/usage/document/create.md): This guide provides a comprehensive walkthrough for creating document records in Aerospike using the Node.js client. It details how to establish connections, prepare JSON data, and execute writes using the `put` method with specific write policies. The documentation also includes a complete code example and guidance on managing secondary indexes via asadm. - [Read](https://aerospike.com/docs/develop/client/node/usage/document/read.md): This document provides a technical guide on performing read operations for Collection Data Types (CDTs) in the Aerospike Node.js client. It specifically demonstrates how to use the `operate` method with map helpers to extract a single value from a nested list of maps, such as retrieving an employee's name by index. - [Update](https://aerospike.com/docs/develop/client/node/usage/document/update.md): This guide demonstrates how to use the Aerospike Node.js client to update specific fields within JSON documents and Collection Data Types (CDT). It provides a practical example of updating a map entry at a specific index within a list using `putItems` and context-based indexing. - [Create](https://aerospike.com/docs/develop/client/node/usage/atomic/create.md): This guide demonstrates how to perform single record writes in Aerospike using the Node.js client. It covers setting up connection boilerplate, configuring write policies, creating keys with specific namespaces and sets, and structuring complex data types like Maps and GeoJSON for use in bins via the client.put method. - [Delete](https://aerospike.com/docs/develop/client/node/usage/atomic/delete.md): This guide demonstrates how to delete single records in an Aerospike database using the Node.js client. It covers the use of the remove() method with default policies, explains the risks of record resurrection during cold restarts, and provides implementation details for performing durable deletes via write policies. A complete code example is included for quick integration. - [Expressions - Node.js](https://aerospike.com/docs/develop/client/node/usage/atomic/expressions.md): This guide details the implementation of Aerospike expressions in the Node.js client for single record commands. It covers using filter expressions within read and write policies, as well as performing atomic read and write operation expressions via the `operate` method, complete with practical code examples. - [Bin operations](https://aerospike.com/docs/develop/client/node/usage/atomic/multi.md): This document provides a guide for performing atomic bin operations using the Aerospike Node.js client's operate method. It demonstrates how to execute single actions or combine multiple operations, like writes and map modifications, into a single transaction. Users will also learn about the specific return value behavior when grouping results by bin name. - [Read](https://aerospike.com/docs/develop/client/node/usage/atomic/read.md): This guide demonstrates how to perform single record reads using the Aerospike Node.js client. It covers various methods including existence checks, retrieving metadata, fetching whole records, and selecting specific bins, while also showing how to apply custom read policies like socket timeouts. A complete code example is provided for implementation. - [Update](https://aerospike.com/docs/develop/client/node/usage/atomic/update.md): This guide demonstrates how to perform single record updates in Aerospike using the Node.js client. It covers configuring write policies like UPDATE or REPLACE, performing type-specific operations with `incr`, updating bins via `put`, deleting specific bins by setting them to null, and replacing entire records. - [Batched commands](https://aerospike.com/docs/develop/client/node/usage/multi/batch.md): This guide details how to implement efficient batched operations using the Aerospike Node.js client, covering batch reads, writes, existence checks, and removals. It provides practical code examples for executing complex, multi-operation batches that combine different request types in a single call, along with instructions on configuring policies and filter expressions. - [Transactions](https://aerospike.com/docs/develop/client/node/usage/multi/transactions.md): This guide demonstrates how to implement transactions in the Aerospike Node.js client by executing create, update, read, and delete operations. It provides a complete JavaScript example showing how to associate transaction objects with write, read, and remove policies, including handling commit and abort logic. - [Aggregations](https://aerospike.com/docs/develop/client/node/usage/udf/aggregations.md): This guide explains how to use Stream User Defined Functions (UDFs) to perform aggregations on Aerospike query results via the Node.js client. It covers implementing map and reduce logic in Lua, configuring the modlua path for local UDF modules, and executing secondary index queries using the .apply() method with complete code examples. - [Apply a UDF](https://aerospike.com/docs/develop/client/node/usage/udf/apply.md): This guide demonstrates how to execute Record UDFs using the Aerospike Node.js client through various methods. It provides practical code examples for applying functions to single records with multiple arguments, performing batch operations on multiple keys, and running background queries filtered by specific expressions. - [Manage UDFs](https://aerospike.com/docs/develop/client/node/usage/udf/manage.md): This guide demonstrates how to manage Lua-based User-Defined Functions in Aerospike using the Node.js client and asadm. It covers the full lifecycle of a UDF—including registration, removal, and updating via a remove-and-re-add process—as well as methods for clearing the UDF cache to ensure consistency. - [Create](https://aerospike.com/docs/develop/client/python/usage/atomic/create.md): This guide demonstrates how to use the Aerospike Python client to create records with complex data types like Maps and GeoJSON. It covers setting up connections, defining record keys, configuring custom write policies such as POLICY_KEY_SEND, and provides a complete code example for implementing the put method. - [Delete](https://aerospike.com/docs/develop/client/python/usage/atomic/delete.md): This guide demonstrates how to use the Aerospike Python client to remove records using both default and durable delete policies. It explains the mechanics of record removal, the risks of zombie records during cold restarts, and provides complete code examples for implementing durable deletes with tombstones. - [Expressions - Python](https://aerospike.com/docs/develop/client/python/usage/atomic/expressions.md): This technical guide demonstrates how to implement Aerospike expressions within the Python client for single-record commands. It covers both filter expressions for conditional reads and writes, and operation expressions for atomic bin computations, providing practical code examples using the aerospike_helpers library. - [Bin operations](https://aerospike.com/docs/develop/client/python/usage/atomic/multi.md): This guide demonstrates how to use the Aerospike Python client's operate() method to perform atomic single or multiple bin operations in a single transaction. It covers specific operations like writing, reading, and incrementing values, as well as applying map policies and interpreting returned results grouped by bin name. - [Read](https://aerospike.com/docs/develop/client/python/usage/atomic/read.md): This guide provides practical examples for performing various read operations with the Aerospike Python client. It covers setting custom read policies, checking record existence, retrieving full records, and selecting specific bins or metadata using the exists, get, and select methods. - [Update](https://aerospike.com/docs/develop/client/python/usage/atomic/update.md): This document details various methods for updating Aerospike records via the Python client, including configuring write policies like POLICY_EXISTS_UPDATE. It provides practical code examples for adding new bins, performing type-specific operations like integer increments, replacing existing records, and deleting specific bins by setting them to null. - [Batched commands](https://aerospike.com/docs/develop/client/python/usage/multi/batch.md): This guide demonstrates how to use the Aerospike Python client for efficient batched commands, including batch reads, writes, and multi-operation requests. It covers scenarios like checking existence, performing map operations, and applying expression-based logic. It also shows how to execute complex batches that combine different operation types across multiple keys in a single request. - [Transactions](https://aerospike.com/docs/develop/client/python/usage/multi/transactions.md): This guide demonstrates how to implement atomic CRUD operations—including create, batch updates, reads, and durable deletes—using the Aerospike Python client's transaction API. It provides complete code examples for initializing transactions, managing commit status, and handling specific error scenarios like roll-forward abandonment. - [Create](https://aerospike.com/docs/develop/client/python/usage/document/create.md): This guide provides a step-by-step walkthrough for creating document records in Aerospike using the Python client. It details how to establish connections, prepare JSON data as maps, and use write policies via the `client.put` method, concluding with a comprehensive code block for immediate implementation. - [Read](https://aerospike.com/docs/develop/client/python/usage/document/read.md): This guide demonstrates how to read complex JSON-like document records using the Aerospike Python client. It specifically covers working with Collection Data Types (CDT) by showing how to use `client.operate` and `map_operations` to retrieve specific nested fields from within a list of maps. The example provides complete code for setting up, writing, and querying deeply nested data. - [Secondary index query](https://aerospike.com/docs/develop/client/python/usage/document/sindex.md): This guide provides practical Python examples for executing secondary index queries in Aerospike. It demonstrates two specific methods: indexing a dedicated bin during record insertion and using map value indexes to query directly within document bins. Each example includes complete code for data setup, index creation, predicate-based querying, and cleanup. - [Update](https://aerospike.com/docs/develop/client/python/usage/document/update.md): This guide demonstrates how to update complex JSON documents in Aerospike using the Python client's Collection Data Types (CDT). It provides a complete workflow for creating records and performing targeted updates on nested elements within lists and maps using `cdt_ctx` and `map_operations` via the `client.operate` method. - [AEL reference](https://aerospike.com/docs/develop/client/sdk/concepts/ael/ael-reference.md): This comprehensive guide provides a complete reference for Aerospike Expression Language (AEL), covering syntax for record paths, CDT patterns, and logical operators. It details how to implement AEL in Java and Python SDKs for filtering, reading with selectFrom, and writing via upsertFrom or updateFrom operations. The document includes technical specifics on metadata functions, path access, and control structures like 'when' clauses. - [Aggregations](https://aerospike.com/docs/develop/client/python/usage/udf/aggregations.md): This guide demonstrates how to process Aerospike query results using Stream UDFs in Python. It provides a Lua implementation of a count function using map and reduce operations, explains how to configure the client's local UDF path, and shows how to execute secondary index queries with applied aggregations. - [Overview](https://aerospike.com/docs/develop/client/sdk/concepts/ael.md): This guide introduces the Aerospike Expression Language (AEL), a natural language syntax for intuitive record filtering in Java and Python SDKs. It covers comparison, logical, and collection operators, nested data access, existence checks, and advanced constructs like variable binding and conditional logic. The document also provides performance optimization guidance using secondary indexes and projections. - [Apply a UDF](https://aerospike.com/docs/develop/client/python/usage/udf/apply.md): This guide provides technical instructions and code examples for applying Record User Defined Functions (UDFs) via the Aerospike Python client. It covers executing UDFs on single records with one or multiple arguments, performing batch operations using `batch_apply`, and running background queries to apply functions across datasets matching specific filter expressions. - [Manage UDFs](https://aerospike.com/docs/develop/client/python/usage/udf/manage.md): This guide demonstrates how to manage Lua User-Defined Functions (UDFs) in Aerospike using the Python client and asadm tool. It provides specific instructions for registering, removing, and updating UDFs, along with methods to manually clear the UDF cache to ensure function updates are applied correctly. - [Create](https://aerospike.com/docs/develop/client/rust/usage/atomic/create.md): This guide provides practical examples of using the Aerospike Rust client's `put()` method to write single or multiple bins to a record. It covers advanced usage including bin deletion, customizing write behavior with `WritePolicy`, managing record TTLs, and implementing optimistic locking via Read-Modify-Write patterns. - [Delete](https://aerospike.com/docs/develop/client/rust/usage/atomic/delete.md): This guide demonstrates how to use the `Client::delete` method in the Aerospike Rust client to remove specific keys from a namespace and set. It provides a practical code example that illustrates how to handle various return scenarios, including successful deletions, cases where the record does not exist, and error handling using `WritePolicy`. - [Bin operations](https://aerospike.com/docs/develop/client/rust/usage/atomic/multi.md): This guide demonstrates how to perform multiple bin operations on an Aerospike record in a single atomic transaction using the Rust client. It details specific operations like add, append, and get, while providing practical code examples for implementing Client::operate to modify and read data efficiently. - [Read](https://aerospike.com/docs/develop/client/rust/usage/atomic/read.md): This guide demonstrates how to use the Aerospike Rust client's `get` method to retrieve data from a record. It provides practical code examples for reading all bins, selecting specific bins by name, and fetching only metadata like TTL, while also showing how to handle KeyNotFoundError. - [Apply a UDF](https://aerospike.com/docs/develop/client/rust/usage/udf/apply.md): This document provides a technical guide on invoking Record User Defined Functions (UDFs) using the Aerospike Rust client. It details the `execute_udf` method signature and parameters, including how to pass single or multiple arguments to Lua functions. Practical code examples demonstrate reading bins and performing arithmetic operations on records. - [Manage UDFs](https://aerospike.com/docs/develop/client/rust/usage/udf/manage.md): This guide demonstrates how to register Lua User-Defined Functions (UDFs) using the Aerospike Rust client through both ASCII text files and raw strings. It explains how UDF filenames map to server-side user paths and provides details on the asynchronous nature of the registration process within a cluster. - [Batched commands](https://aerospike.com/docs/develop/client/rust/usage/multi/batch.md): This guide demonstrates how to perform efficient batch reads in the Aerospike Rust client using `batch_get` and `client.batch`. It explains how the client optimizes requests by grouping keys by server node and provides a complete, runnable example including dependency setup and error handling for missing records. - [Background queries](https://aerospike.com/docs/develop/client/c/usage/multi/queries/background.md): This guide explains how to use the Aerospike C client's scan APIs to perform background queries without waiting for results. It details how to retrieve a scan ID and use the as_scan_info structure with aerospike_scan_info() to monitor real-time progress via fields like progress_pct. - [Primary index queries](https://aerospike.com/docs/develop/client/c/usage/multi/queries/primary.md): This document details how to execute primary index queries using the Aerospike C client's scan APIs, specifically aerospike_scan_foreach() and aerospike_scan_background(). It provides implementation guidance for callback functions, including how to handle as_val types and convert them into records using as_record_fromval(). - [Secondary index queries](https://aerospike.com/docs/develop/client/c/usage/multi/queries/secondary.md): This guide provides technical instructions for managing secondary indexes in Aerospike using the C client, covering creation of integer and string indexes and their removal. It also details how to define query objects, execute them via aerospike_query_foreach(), and process results through specialized callback functions. - [Background queries](https://aerospike.com/docs/develop/client/csharp/usage/multi/queries/background.md): This guide demonstrates how to use the Aerospike C# client to perform asynchronous background queries that apply transactional write operations directly to records. It includes practical examples for using filter expressions, querying both primary and secondary indexes, and tracking task completion via query status polling. - [Basic](https://aerospike.com/docs/develop/client/csharp/usage/multi/queries/basic.md): This guide covers basic read-only query operations in Aerospike using the C# client. It explains how to implement query policies and use Filter Expressions to refine results, providing a practical code example for filtering records based on nested data structures like maps and lists. - [Primary index queries](https://aerospike.com/docs/develop/client/csharp/usage/multi/queries/primary.md): This guide demonstrates how to perform primary index queries using the Aerospike C# client, covering essential techniques such as filtering by set name, applying metadata and data filter expressions, and limiting record counts. It also provides a detailed implementation of pagination using partition filters to manage large result sets efficiently. - [Secondary index queries](https://aerospike.com/docs/develop/client/csharp/usage/multi/queries/secondary.md): Learn to implement secondary index queries in Aerospike using C#, covering index creation, removal, and various filter types like range and geospatial comparisons. The guide provides practical code examples for advanced workflows, such as combining query results with batch operations to efficiently retrieve specific map values. - [Creation and setup](https://aerospike.com/docs/develop/client/go/usage/cdt/list/create.md): This document provides practical examples for managing list Complex Data Types (CDTs) using the Aerospike Go client. It details how to use ListAppendOp for adding items, ListInsertOp for index-based insertion, and ListCreateOp for initialization. It also covers configuring list policies such as ordered and unordered structures. - [Get operations](https://aerospike.com/docs/develop/client/go/usage/cdt/list/get.md): This technical guide details various retrieval operations for the Aerospike Go client's List complex data type. It provides practical code examples for fetching items by index, range, or rank, finding indices by specific values, and determining total list size. - [Range operations](https://aerospike.com/docs/develop/client/go/usage/cdt/list/range.md): This guide details how to perform various list range operations using the Aerospike Go client. It provides specific implementation instructions and code examples for retrieving items via index ranges, rank ranges (sorted by value), and defined value ranges. - [Modify operations](https://aerospike.com/docs/develop/client/go/usage/cdt/list/modify.md): This guide provides technical documentation and Go code examples for performing modification operations on Aerospike List Complex Data Types (CDTs). It covers specific functions such as setting values at indices, removing items by index or value, popping elements from queues, incrementing numeric counters, and clearing entire lists. - [Creation and setup](https://aerospike.com/docs/develop/client/go/usage/cdt/map/create.md): This guide demonstrates how to create and manage maps using the Aerospike Go client via MapPutOp, MapPutItemsOp, and MapCreateOp. It includes code examples for single and bulk updates and details various map ordering policies, such as KEY_ORDERED and KEY_VALUE_ORDERED, to assist with use cases like range queries and leaderboards. - [Get operations](https://aerospike.com/docs/develop/client/go/usage/cdt/map/get.md): This document provides a comprehensive guide to retrieving data from maps using the Aerospike Go client's CDT operations. It includes function signatures and practical code examples for MapGetByKeyOp, MapGetByKeyListOp, MapGetByKeyRangeOp, MapGetByIndexOp, MapGetByRankOp, MapGetByValueOp, and MapSizeOp. - [Modify operations](https://aerospike.com/docs/develop/client/go/usage/cdt/map/modify.md): This guide provides technical documentation for performing map modification operations using the Aerospike Go client. It includes specific code examples for incrementing or decrementing numeric values, removing entries by key or value, and clearing entire maps from a record. - [Range operations](https://aerospike.com/docs/develop/client/go/usage/cdt/map/range.md): This document provides a technical usage guide for performing map range operations using the Aerospike Go client. It covers retrieving items by index range, rank range (including top N via count), value range, and relative key position, providing practical Go code examples for each operation. - [List operations](https://aerospike.com/docs/develop/client/go/usage/cdt/nested/list.md): This guide demonstrates how to perform complex nested list operations using the Aerospike Go client. It provides practical examples for managing 2D arrays, appending elements to lists within maps using policies, and utilizing chained CDT contexts to directly access deeply nested values without retrieving entire structures. - [Nested CDT operations](https://aerospike.com/docs/develop/client/go/usage/cdt/nested/context.md): This guide explains how to navigate complex data structures in Aerospike using the Go client's CDT context functions. It details specific context types like CtxMapKey and CtxListIndex and provides a practical code example for chaining contexts to access deeply nested values within Maps and Lists. - [Map operations](https://aerospike.com/docs/develop/client/go/usage/cdt/nested/map.md): This guide demonstrates how to use the Aerospike Go client to perform nested map operations within Complex Data Types (CDT). It provides practical code examples for storing multi-level structures, such as user addresses and configuration settings, and retrieving specific values using CDT contexts like `as.CtxMapKey`. - [Secondary index](https://aerospike.com/docs/develop/client/php/usage/multi/queries/secondary.md): This guide provides a complete PHP code example for implementing secondary indexes in Aerospike. It demonstrates how to populate a set, create a numeric index on a specific bin, and execute range-based queries using filters to retrieve targeted records efficiently. - [Primary index](https://aerospike.com/docs/develop/client/php/usage/multi/queries/primary.md): This document provides a practical PHP code example demonstrating how to interact with an Aerospike database. It walks through connecting to a server, writing sample user data with specific bins, and performing a scan operation to retrieve and iterate over records within a namespace and set. - [Background queries](https://aerospike.com/docs/develop/client/go/usage/multi/queries/background.md): This guide explains how to use the Aerospike Go client to perform efficient, asynchronous background queries that apply transactional write operations directly to records. It provides practical code examples for implementing filter expressions on primary and secondary indexes and demonstrates how to track task completion using the IsDone method. - [Basic](https://aerospike.com/docs/develop/client/go/usage/multi/queries/basic.md): This guide details basic read-only query operations using the Aerospike Go client, including the implementation of query policies. It features a specific code example demonstrating how to construct complex record filter expressions to evaluate nested data types, such as checking the size of a list within a map bin. - [Primary index](https://aerospike.com/docs/develop/client/go/usage/multi/queries/primary.md): This guide demonstrates how to execute primary index queries using the Aerospike Go client. It covers implementing metadata and data filter expressions, managing pagination through partition filters, and limiting result sets, providing complete code examples for practical application development. - [Background queries](https://aerospike.com/docs/develop/client/java/usage/multi/queries/background.md): This usage guide demonstrates how to execute efficient, asynchronous background queries with the Aerospike Java client. It covers applying transactional operations to records across primary and secondary indexes, utilizing filter expressions within write policies, and tracking task completion status through ExecuteTask. - [Secondary index](https://aerospike.com/docs/develop/client/go/usage/multi/queries/secondary.md): This guide provides technical instructions for managing secondary indexes in Aerospike using the Go client. It covers creating and dropping indexes via asadm or the API, performing range and geospatial queries with Filter Expressions, and combining query results with batch operations to execute CDT tasks on returned keys. - [Basic](https://aerospike.com/docs/develop/client/java/usage/multi/queries/basic.md): This guide explains how to execute basic read-only queries using the Aerospike Java client. It covers configuring Query Policies, including short versus long queries and PREFER_RACK support, and provides a practical code example for implementing Filter Expressions to filter complex nested data structures like maps and lists. - [Primary index](https://aerospike.com/docs/develop/client/java/usage/multi/queries/primary.md): This usage guide details how to execute Primary Index queries using the Aerospike Java client. It includes practical examples for filtering records by set name, applying expression-based metadata and data filters, performing projection operations on maps, and managing result sets through pagination with partition filters. - [Secondary index](https://aerospike.com/docs/develop/client/java/usage/multi/queries/secondary.md): This guide details how to manage Aerospike secondary indexes using the Java client, covering creation, removal, and various query types like range and geo-spatial filters. It demonstrates implementing complex Filter Expressions and shows how to optimize performance by combining queries with batch operations to retrieve specific map data from returned keys. - [Background queries](https://aerospike.com/docs/develop/client/node/usage/multi/queries/background.md): This guide explains how to use the Aerospike Node.js client to issue asynchronous background queries that apply transactional write operations directly to records. It covers implementing filter expressions, querying via primary and secondary indexes, and monitoring task progress using job status information. - [Basic](https://aerospike.com/docs/develop/client/node/usage/multi/queries/basic.md): This guide covers fundamental read-only query operations in the Aerospike Node.js client, explaining how requests are distributed across cluster nodes. It details how to use query policies for filtering results, featuring a code example that implements complex filter expressions on nested maps and lists. - [Secondary index](https://aerospike.com/docs/develop/client/node/usage/multi/queries/secondary.md): This guide demonstrates how to manage and query secondary indexes using the Aerospike Node.js client. It covers index creation and removal via the API or asadm, performing range and geospatial queries, and applying filter expressions. Additionally, it shows how to combine index-based queries with batch operations for efficient data retrieval from returned keys. - [Background queries](https://aerospike.com/docs/develop/client/python/usage/multi/queries/background.md): This guide demonstrates how to use the Aerospike Python client to perform asynchronous background queries that apply write operations directly to records. It includes specific examples for querying primary and secondary indexes with filter expressions, as well as methods for tracking job progress and completion status. - [Primary index](https://aerospike.com/docs/develop/client/node/usage/multi/queries/primary.md): This guide provides a comprehensive overview of performing primary index queries using the Aerospike Node.js client. It covers querying specific sets, applying advanced filter expressions for both metadata and record data, and implementing efficient pagination using partition filters. Practical code examples are provided to help developers implement these features. - [Basic](https://aerospike.com/docs/develop/client/python/usage/multi/queries/basic.md): This guide explains how to execute basic read-only queries using the Aerospike Python client, including how requests are distributed across nodes. It details the application of query policies for record filtering and provides a practical code example for building complex filter expressions with map and list operations. - [Primary index](https://aerospike.com/docs/develop/client/python/usage/multi/queries/primary.md): This guide demonstrates how to perform primary index queries using the Aerospike Python client, covering advanced features like metadata and data filter expressions. It includes practical code examples for filtering records by bin values or device size and explains how to implement efficient pagination through partition filters. - [Secondary index](https://aerospike.com/docs/develop/client/python/usage/multi/queries/secondary.md): This guide provides comprehensive instructions for managing secondary indexes in Aerospike using the Python client. It covers creating and removing indexes via asadm or API, performing range and geospatial queries, applying filter expressions, and combining query results with batch operations to perform advanced CDT and transaction operations on returned keys. - [Primary index](https://aerospike.com/docs/develop/client/rust/usage/multi/queries/primary.md): This guide demonstrates how to use the Aerospike Rust client to perform primary index queries across a specified namespace and set. It features an asynchronous code example that utilizes Client::query and PartitionFilter::all to scan and count records. Additionally, it explains error handling behavior during parallel query execution within the record stream. - [Secondary index](https://aerospike.com/docs/develop/client/rust/usage/multi/queries/secondary.md): This guide provides a comprehensive overview of managing secondary indexes with the Aerospike Rust client. It covers creating and dropping indexes, defining query statements with various filter macros, and executing queries using partition filters. Additionally, it demonstrates how to implement cursor-based pagination for large result sets through a complete code example. - [Blob/bytes](https://aerospike.com/docs/develop/data-types/blob.md): This document details Aerospike's Blob/bytes data types, covering general-purpose and language-specific bins. It provides technical specifications for bitwise modify operations like add, set, and resize, alongside read operations such as count, get, and scanning. Comprehensive code examples in Java, Python, C, Go, C#, and Node.js demonstrate how to perform efficient server-side binary data manipulation. - [HyperLogLog data type](https://aerospike.com/docs/develop/data-types/hll.md): This technical guide covers the Aerospike HyperLogLog (HLL) data type used for efficient cardinality estimation in large datasets. It provides detailed documentation for modify and read operations—including set unions, intersections, and similarity estimates—alongside error bound formulas, performance metrics, and specific business use cases like fraud detection. - [Arithmetic](https://aerospike.com/docs/develop/expressions/arithmetic.md): This guide details Aerospike arithmetic expression operators used to compute numeric results from bins in read/write or comparison expressions. It covers standard math functions like add, div, and log, alongside integer bitwise helpers such as int_and and int_lscan. Each operation includes argument specifications and code examples for Java, Python, C, Go, C#, and Node.js. - [Blob bin operations](https://aerospike.com/docs/develop/expressions/blob-bin.md): This technical reference details bitwise expression operations for Aerospike blob (bytes) bins, covering modify actions like bit_add and bit_set alongside read actions like bit_get and bit_count. It provides argument specifications and multi-language code examples in Java, Python, C, Go, C#, and Node.js to help developers perform efficient bit manipulation without full data round-tripping. - [Comparison](https://aerospike.com/docs/develop/expressions/comparison.md): This technical reference details Aerospike's comparison expression operators used for record filtering in queries, scans, and XDR. It covers specific operations like eq, ne, cmp_regex, cmp_geo, and in_list, providing argument specifications, return types, and multi-language code examples for Java, Python, C, Go, C#, and Node.js. - [Declare and control-flow](https://aerospike.com/docs/develop/expressions/declare.md): This guide explains Aerospike expressions for variable declaration and control-flow logic in database queries. It details how to use `cond` for branching, `let` and `def` for local scoping and variable reuse, and `unknown` for managing trilean results. Practical implementation examples are provided for Java, Python, C, Go, C#, and Node.js. - [HyperLogLog bin operations](https://aerospike.com/docs/develop/expressions/hll-bin.md): This document details HyperLogLog (HLL) bin expression operations in Aerospike, including modify functions like hll_add and read functions such as hll_get_count, hll_get_union, and hll_may_contain. It explains how to use these expressions within filter trees and policies, providing practical code implementations for Java, Python, C, Go, C#, and Node.js. - [List bin operations](https://aerospike.com/docs/develop/expressions/list-bin.md): This document provides a technical reference for Aerospike list bin expression operations used in filter, operation, and projection pipelines. It covers read operations like get-by-index or size, as well as modify operations such as append, insert, remove, and sort. Each entry includes argument details and multi-language code examples for Java, Python, C, Go, C#, and Node.js. - [Logic](https://aerospike.com/docs/develop/expressions/logic.md): This document details Aerospike logic expression operations such as AND, OR, NOT, and EXCLUSIVE for boolean filtering. It explains the trilean evaluation model involving unknown values and demonstrates how to apply these operators in record filters, XDR, and path expressions. Comprehensive code examples are provided for Java, Python, C, Go, C#, and Node.js client libraries. - [Map bin operations](https://aerospike.com/docs/develop/expressions/map-bin.md): This reference covers Aerospike map bin expressions for reading and modifying map-type bins within expression pipelines. It includes detailed instructions on modify operations like `map_put` and `map_increment`, as well as read operations such as `map_get_by_key` and `map_size`. Comprehensive code examples are provided for Java, Python, C, Go, C#, and Node.js to assist in implementation. - [Record metadata](https://aerospike.com/docs/develop/expressions/metadata.md): This document details Aerospike record metadata expression operations such as TTL, void time, digest modulo, and record size. These expressions can be used in secondary index filters, query predicates, record policies, and XDR shipping filters, providing specific syntax and code examples for various client languages. - [Record storage](https://aerospike.com/docs/develop/expressions/storage.md): This document provides a comprehensive guide to Aerospike record storage expressions, enabling users to retrieve typed values from bins and primary keys. It details specific operations like `bin_exists`, `bin_type`, and various type-specific readers, offering technical specifications and implementation examples in Java, Python, C, Go, C#, and Node.js. - [List operations](https://aerospike.com/docs/develop/data-types/collections/list/operations.md): This technical guide details Aerospike list operations for manipulating ordered and unordered lists via modify, read, and set commands. It covers specific functions like appending items, removing elements by index or rank range, and retrieving values using wildcards or intervals. The documentation includes multi-language code samples to assist in implementing complex collection logic. - [Map operations](https://aerospike.com/docs/develop/data-types/collections/map/operations.md): This technical guide details how to manipulate Aerospike map-type bins through modify, read, and set operations. It covers essential configurations including map policies, contexts, and return types, offering specific documentation for functions like increment, remove by index range, and get by rank with multi-language code samples. ## Kubernetes Operator - [Aerospike Kubernetes Operator](https://aerospike.com/docs/kubernetes.md): This guide explains how the Aerospike Kubernetes Operator (AKO) automates the deployment, scaling, and management of Aerospike clusters via Custom Resource Definitions. It details core features such as configuration management, XDR setup, and backup/restore, while outlining the underlying architecture using Go-based controllers and Kubernetes StatefulSets. - [Get started with AKO in the cloud](https://aerospike.com/docs/kubernetes/learn/get-started-cloud.md): This tutorial provides a step-by-step guide to deploying Aerospike Database Enterprise Edition on GKE or EKS using the Aerospike Kubernetes Operator (AKO). It covers installing cert-manager, configuring cloud-specific SSD storage classes, and managing cluster resources via custom resources. You will learn how to provision, verify, and clean up a running Aerospike cluster in the cloud. - [Get started with AKO locally](https://aerospike.com/docs/kubernetes/learn/get-started-local.md): This tutorial provides step-by-step instructions for deploying the Aerospike Kubernetes Operator (AKO) and Aerospike Database Enterprise Edition on local Minikube or MicroK8s clusters. It covers installing dependencies via Helm, configuring storage, applying sample custom resources, and performing environment cleanup. This guide is ideal for developers wanting to quickly test AKO in a lightweight setup. - [Install Aerospike Kubernetes Operator using Helm](https://aerospike.com/docs/kubernetes/install/helm.md): This guide provides step-by-step instructions for installing the Aerospike Kubernetes Operator (AKO) using Helm charts. It covers essential prerequisites, installation commands, log verification, and methods for granting namespace permissions via kubectl or akoctl, alongside a complete configuration reference table. - [Install Aerospike Kubernetes Operator](https://aerospike.com/docs/kubernetes/install.md): This guide covers the two primary installation methods for the Aerospike Kubernetes Operator (AKO): using Operator Lifecycle Manager (OLM) or Helm charts. It includes critical information on system requirements, architecture-specific notes for ARM, and warnings regarding Community Edition compatibility and installation method mixing. - [Aerospike Kubernetes Operator limitations and restrictions](https://aerospike.com/docs/kubernetes/install/limitations.md): This document outlines technical limitations for clusters managed by the Aerospike Kubernetes Operator (AKO). It details restrictions on updating existing deployments regarding storage and replication, lists immutable configuration parameters like node IDs and ports, and specifies unsupported features such as multi-site clustering and IPv6. - [Install Aerospike Kubernetes Operator on OLM through OperatorHub](https://aerospike.com/docs/kubernetes/install/olm.md): This guide provides step-by-step instructions for installing the Aerospike Kubernetes Operator via OLM and OperatorHub. It covers Pod Security Admission requirements, installation verification, and log monitoring. Additionally, it details how to grant necessary namespace permissions using kubectl or akoctl for both internal pod-only and external network connectivity. - [Install Aerospike Kubernetes Operator on Red Hat OpenShift](https://aerospike.com/docs/kubernetes/install/openshift.md): This guide provides step-by-step instructions for installing the Aerospike Kubernetes Operator on Red Hat OpenShift via the web console or command line. It also covers verifying logs, managing namespace permissions with kubectl or akoctl, and configuring essential Security Context Constraints (SCCs) like anyuid, hostnetwork, and privileged. - [Aerospike Kubernetes Operator system requirements](https://aerospike.com/docs/kubernetes/install/requirements.md): This document details the system requirements for the Aerospike Kubernetes Operator, specifying compatible Aerospike Database editions (EE/FE 6.0+) and Kubernetes versions (1.23–1.34). It covers supported environments like EKS, AKS, GKE, Minikube, and Microk8s, while noting specific limitations for GKE Autopilot clusters. - [Aerospike Kubernetes Operator Command Line Tool](https://aerospike.com/docs/kubernetes/manage/akoctl.md): This document provides instructions for installing and using akoctl, a Krew plugin for the Aerospike Kubernetes Operator. It details how to use the collectinfo sub-command to gather cluster logs and object inventories, as well as the auth sub-command to create or delete RBAC resources like ServiceAccounts and RoleBindings. - [Node maintenance for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/node-maintenance.md): This guide details how to safely migrate Aerospike pods during Kubernetes node maintenance like upgrades or patching. It covers three primary methods: using the safe pod eviction webhook for `kubectl drain` operations, applying scheduling policies for network-attached storage, and utilizing K8sNodeBlockList for local-attached storage migrations. - [Uninstall Aerospike Kubernetes Operator](https://aerospike.com/docs/kubernetes/manage/uninstall.md): This document provides step-by-step instructions for removing the Aerospike Kubernetes Operator (AKO) from a cluster. It covers cleaning up Custom Resource Definitions (CRDs), Custom Resources (CRs), and RBAC resources, as well as specific uninstallation procedures for both OLM and Helm deployment methods. - [Monitor Aerospike clusters on Kubernetes](https://aerospike.com/docs/kubernetes/observe/clusters.md): This guide details how to expose Aerospike metrics via a Prometheus Exporter sidecar using plaintext or Kubernetes secrets. It also provides instructions for scraping metrics with the Prometheus Operator or AKO monitoring stack and visualizing them through pre-built Grafana dashboards. - [Logging for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/observe/logs.md): This document provides comprehensive instructions for managing Aerospike logs in Kubernetes environments. It covers basic stdout/stderr collection, platform-specific setups for GKE and Amazon EKS, and a detailed deployment guide for the Promtail, Loki, and Grafana (PLG) stack using Helm. - [Monitor Aerospike Kubernetes Operator](https://aerospike.com/docs/kubernetes/observe/operator-monitoring.md): This guide explains how to monitor the Aerospike Kubernetes Operator (AKO) by configuring Prometheus to scrape metrics via ServiceMonitor resources for OLM or Helm installations. It details custom AKO metrics and provides instructions for using pre-built Grafana dashboards for metric visualization. - [Configuration parameters for Aerospike Kubernetes Operator](https://aerospike.com/docs/kubernetes/reference/config-reference.md): This technical reference details all configuration parameters for the Aerospike Kubernetes Operator (AKO) Custom Resource (CR). It covers essential settings such as cluster size, storage volume policies, rack awareness, network endpoint types, and access control. The guide also explains how to manage pod specifications and execute on-demand operations like warm or cold restarts. - [Troubleshooting Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/reference/troubleshooting.md): This guide provides specific troubleshooting steps for common Aerospike Kubernetes Operator deployment issues, such as pods stuck in pending or crashing states. It includes practical kubectl commands to inspect container logs, analyze Kubernetes events, and review AKO operator manager logs to diagnose cluster-level errors and connectivity problems. - [Connect to an Aerospike cluster on Kubernetes](https://aerospike.com/docs/kubernetes/install/deploy/connect.md): This guide details how to connect to an Aerospike cluster deployed by AKO using asadm or client libraries. It covers configuring firewall rules based on pod density, retrieving specific pod endpoints with kubectl, and establishing connections from both inside and outside the Kubernetes network. - [Delete an Aerospike cluster on Kubernetes](https://aerospike.com/docs/kubernetes/install/deploy/delete.md): This guide explains how to delete an Aerospike cluster on Kubernetes by removing its Custom Resource file. It covers the permanent loss of resources, the role of the cascadeDelete flag in managing PVCs, and provides critical warnings about retaining cloud-provider storage volumes after cluster deletion. - [Use Helm to create an Aerospike Cluster on Kubernetes](https://aerospike.com/docs/kubernetes/install/deploy/helm.md): This guide provides step-by-step instructions for deploying Aerospike Enterprise Edition clusters on Kubernetes via Helm and the Aerospike Kubernetes Operator (AKO). It covers essential setup tasks like namespace permissioning, persistent storage configuration, and detailed deployment workflows for both minimal testing ("dev") and secure "production" environments. - [Aerospike deployment with AKO](https://aerospike.com/docs/kubernetes/install/deploy.md): This guide explains how to use the Aerospike Kubernetes Operator (AKO) to deploy an Aerospike Database EE cluster using Helm or kubectl. It provides comprehensive instructions on connecting to your cluster, managing configurations, monitoring performance, performing zero-downtime upgrades, and deleting deployments. - [Use kubectl to create an Aerospike cluster on Kubernetes](https://aerospike.com/docs/kubernetes/install/deploy/kubectl.md): This guide provides step-by-step instructions for deploying an Aerospike Database Enterprise Edition cluster with AKO using kubectl. It covers essential tasks such as preparing namespaces, configuring storage classes, managing security secrets like TLS, and applying Custom Resource files to successfully launch and verify your cluster. - [Upgrade the Aerospike Database version on a Kubernetes cluster](https://aerospike.com/docs/kubernetes/install/deploy/upgrade-aerospike.md): This guide explains how to perform a zero-downtime rolling upgrade of Aerospike Database Enterprise Edition on Kubernetes using AKO. It provides step-by-step instructions for updating the spec.image field in the AerospikeCluster custom resource and includes practical kubectl commands to monitor pod status and verify the successful deployment of the new version. - [YAML configuration mapping for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/configure/config-mapping.md): This document details how AKO translates Kubernetes YAML configurations into the Aerospike aerospike.conf format. It covers specific conversion rules for storage sizes, lists, named sections like namespaces, typed sections, and logging sinks, providing clear examples of each mapping convention. - [Dynamic configuration for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/configure/dynamic-config.md): This guide explains how to enable dynamic configuration updates in the AerospikeCluster CR, allowing AKO to apply supported changes without a rolling restart. It provides implementation steps, details on failure handling for partial or full command failures, and outlines specific parameter limitations and required conditions. - [Federal Edition FIPS compliance for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/configure/federal-edition.md): This guide details how to deploy Aerospike Federal Edition on Kubernetes for FIPS 140-2 compliance. It covers mandatory PKI-only authentication, compares Federal and Enterprise editions, and explains configuring the Aerospike Kubernetes Operator (AKO) with client certificates. The document includes step-by-step instructions and a complete YAML example for cluster deployment. - [Horizontal pod autoscaling](https://aerospike.com/docs/kubernetes/manage/configure/hpa.md): This guide explains how to autoscale Aerospike clusters on Kubernetes using Horizontal Pod Autoscaler (HPA). It details two methods: scaling via resource utilization metrics like CPU and memory, or utilizing KEDA to scale based on custom Prometheus metrics such as namespace data usage. The document provides YAML examples, prerequisites, and a list of recommended performance metrics. - [Configure Aerospike on Kubernetes with AKO](https://aerospike.com/docs/kubernetes/manage/configure/overview.md): This guide explains how to use the Aerospike Kubernetes Operator (AKO) to manage deployments via Custom Resource files. It details feature configurations like scaling and rack awareness, explains YAML translation, and provides a step-by-step workflow for applying parameter changes using rolling restarts. - [Rack awareness for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/configure/rack-awareness.md): Learn how to implement rack awareness in Aerospike on Kubernetes to protect against hardware failure and reduce latency. This guide covers adding or removing racks via CR files, managing pod distribution, setting rack-level storage, and understanding the specific merging rules for applying aerospikeConfig patches. - [Update replication factor dynamically on AKO](https://aerospike.com/docs/kubernetes/manage/configure/replication-factor.md): This guide explains how to update the replication factor for AP namespaces in an AerospikeCluster CR without requiring a rolling restart. It details necessary prerequisites, such as enabling dynamic configuration updates, and provides troubleshooting steps for resolving inconsistent RF values or quorum issues using asadm and kubectl. - [Scaling Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/configure/scaling.md): This document provides detailed instructions for scaling Aerospike clusters on Kubernetes using horizontal pod adjustments, vertical resource tuning, and namespace storage expansion via Rack Revision or Rack Replacement. It also covers Kubernetes cluster autoscaling strategies and the specific challenges of managing local volumes during scale operations. - [Strong consistency for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/configure/strong-consistency.md): This guide explains how to configure a strong consistency namespace in the AerospikeCluster custom resource, providing YAML examples and verification steps via kubectl. It also outlines critical limitations of SC mode, such as its inability to be enabled on existing clusters and restrictions regarding in-memory namespaces. - [XDR for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/configure/xdr.md): This guide explains how to set up an Aerospike cluster as a cross-datacenter replication (XDR) source by modifying the AerospikeCluster custom resource. It provides specific YAML configuration examples for remote datacenter settings, instructions for managing authentication via secrets, and commands to verify the deployment. - [Access control for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/security/access-control.md): This guide details how to manage Aerospike access control on Kubernetes by configuring roles, privileges, and users within the cluster's Custom Resource (CR) file. It provides step-by-step instructions for enabling or disabling security, scoping privileges to specific namespaces or sets, and managing both password-based and PKI-only authentication modes via AKO. - [Use Kubernetes Secrets for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/security/kubernetes-secrets.md): This guide explains how to implement Kubernetes Secrets for Aerospike authentication, TLS, and feature-key files. It details the process for creating folder-based or password-based secrets via kubectl and demonstrates how patching an existing secret can trigger a warm restart of the Aerospike process instead of a rolling cold restart. - [TLS certificates for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/security/certificates.md): This guide provides instructions for setting up a TLS-enabled Aerospike cluster by creating Kubernetes Secrets and configuring the Cluster CR file. It also details the process for rotating certificates, including how to update secrets via kubectl and how Aerospike automatically picks up new certificates through Kubernetes secret syncing. - [Use LDAP external authentication for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/security/ldap.md): This document provides a sample `aerospikeConfig` YAML snippet for implementing LDAP external authentication in Aerospike clusters on Kubernetes. It covers essential parameters such as query base DN, server connection details, and role-based access patterns. This guide enables administrators to integrate existing LDAP infrastructure for secure user management. - [Create an Aerospike cluster on Kubernetes with a non-root user](https://aerospike.com/docs/kubernetes/manage/security/nonroot-cluster.md): This document explains how to deploy a secure Aerospike cluster on Kubernetes by running containers as non-root users. It details necessary CRI runtime configurations for containerd and CRI-O, instructions for updating the Aerospike Custom Resource with securityContext settings, and methods to verify device node permissions. - [Integrate Secret management services with Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/security/secret-management.md): This document details how to deploy the Aerospike Secret Agent as a sidecar in Kubernetes to proxy requests to external secret management services. It includes step-by-step instructions for creating configuration secrets, updating AKO CR volume mounts, and configuring Aerospike Database parameters using the specific `secrets:[resource:]key` syntax. - [Data in memory storage configuration for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/storage/data-in-memory.md): This guide explains how to configure Data In Memory (DIM) storage for Aerospike on Kubernetes, which is ideal for testing clusters without separate storage. It provides a specific YAML configuration example for the cluster's Custom Resource and notes that DIM namespaces cannot be used with strong consistency in Kubernetes environments. - [All-flash storage configuration for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/storage/all-flash.md): This document provides a guide and an example Kubernetes Custom Resource (CR) for configuring Aerospike with all-flash storage for both data and index. It details security requirements across different versions, explaining when privileged mode is necessary and how to implement the configuration using specific volume policies. - [Data on SSD storage configuration for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/storage/data-on-ssd.md): This document provides instructions and a YAML example for configuring an Aerospike cluster on Kubernetes to use SSD storage. It covers setting up filesystem and block volumes, defining volume policies like cascadeDelete, and mapping specific device paths to the Aerospike namespace storage engine. - [HDD storage configuration with data in memory for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/storage/hdd-storage.md): This guide demonstrates how to configure HDD storage with data-in-memory for Aerospike on Kubernetes by modifying the Custom Resource (CR) file. It provides a YAML example detailing volume definitions for work directories and namespace paths, alongside configuring a memory-type storage engine for specific namespaces. The document also covers applying these changes via kubectl. - [OpenEBS-backed local storage for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/storage/openebs.md): This guide provides instructions for implementing OpenEBS-backed LVM local PV storage for Aerospike clusters on Kubernetes. It covers installing OpenEBS via Helm, configuring LVM volume groups, and creating a custom StorageClass for dynamic provisioning. Users will also find configuration examples and critical performance advice regarding the use of replicated volumes. - [Configure storage for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/storage/overview.md): This document provides an overview of the different storage configuration methods available for Aerospike clusters running on Kubernetes. It serves as a central hub for accessing specific guides on setups like All Flash, SSD, OpenEBS, and Shadow Devices, while also offering information on scaling storage after deployment. - [Persistent memory storage configuration for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/storage/pmem.md): This guide provides a step-by-step configuration for running Aerospike on Kubernetes with Persistent Memory (PMEM) for both data and index storage. It includes prerequisites like the PMEM-CSI driver, instructions for creating a specialized StorageClass, and a complete AerospikeCluster Custom Resource example for high-performance setups. - [Provisioning storage for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/storage/storage-provisioning.md): This guide explains how to configure persistent storage for Aerospike on Kubernetes through StorageClasses. It provides practical implementation steps for Google Cloud SSDs and a comprehensive setup for local volumes, including discovery directory creation, block device linking, and deploying the local volume static provisioner. - [Shadow device storage configuration for Aerospike on Kubernetes](https://aerospike.com/docs/kubernetes/manage/storage/shadow-device.md): This guide details how to configure Aerospike's namespace storage engine to use high-performance local SSDs with write duplication to network-attached shadow devices. It provides step-by-step instructions and YAML configuration examples for the Kubernetes Custom Resource, including volume policies and device mapping for enhanced data persistence. - [Upgrade AKO using Helm](https://aerospike.com/docs/kubernetes/manage/upgrade/helm.md): This document provides a technical guide for upgrading the Aerospike Kubernetes Operator (AKO) to version 4.4.0 using Helm 3.x. It details critical manual steps for replacing Custom Resource Definitions (CRDs) to avoid data loss and includes specific commands for adding the Helm repository, performing the upgrade, and verifying success through pod logs. - [Upgrade AKO from OperatorHub.io](https://aerospike.com/docs/kubernetes/manage/upgrade/olm.md): This guide outlines the procedure for upgrading the Aerospike Kubernetes Operator (AKO) to version 4.4.0 when installed via OperatorHub.io. It details how to handle automatic and manual OLM upgrade modes, provides commands for approving InstallPlans, and explains how to verify the upgrade's success through CSV status checks and pod logs. - [Upgrade AKO on Red Hat OpenShift](https://aerospike.com/docs/kubernetes/manage/upgrade/openshift.md): This guide provides comprehensive instructions for upgrading the Aerospike Kubernetes Operator (AKO) to version 4.4.0 on Red Hat OpenShift. It covers both Web Console and command-line methods, explaining how to manage automatic or manual upgrades via InstallPlan approval. Additionally, it includes steps to verify the successful upgrade by inspecting AKO logs. - [Upgrade Aerospike Kubernetes Operator](https://aerospike.com/docs/kubernetes/manage/upgrade/upgrading-operator.md): This guide outlines the procedures for upgrading the Aerospike Kubernetes Operator to version 4.4.0. It specifies necessary intermediate upgrade steps for versions older than 4.3.0 and provides links to detailed instructions for both Helm and OLM installation methods. - [Configuration settings for an Aerospike Backup on Kubernetes](https://aerospike.com/docs/kubernetes/tools/backup/backup-configuration.md): This document provides comprehensive instructions for configuring the AerospikeBackup Custom Resource (CR) in Kubernetes. It features practical YAML examples for scheduled full and incremental backups, password file integration, and TLS-enabled clusters, alongside details on managing on-demand backup requests. - [Use Helm to create an Aerospike backup](https://aerospike.com/docs/kubernetes/tools/backup/backup-helm.md): This guide explains how to use Helm to create an Aerospike Backup Custom Resource (CR) for managing backups on Kubernetes. It provides a detailed example of a values.yaml file used to configure backup services, cluster credentials, and backup routines like cron intervals. Additionally, it lists configuration parameters for custom labels and on-demand backup settings. - [Configuration settings for Aerospike Backup Service on Kubernetes](https://aerospike.com/docs/kubernetes/tools/backup/backup-service-configuration.md): This document details how to configure the Aerospike Backup Service (ABS) on Kubernetes using Custom Resource definitions. It provides practical YAML examples for various storage backends like S3 and local storage, alongside configurations for IRSA, TLS-enabled clusters, and secret mounting to ensure secure backup deployments. - [Use Helm to deploy Aerospike Backup Service on Kubernetes](https://aerospike.com/docs/kubernetes/tools/backup/backup-service-helm.md): This guide provides step-by-step instructions for deploying Aerospike Backup Service on Kubernetes using Helm charts. It covers creating service accounts, configuring S3-compatible storage through secrets or IAM roles, and customizing deployments via values.yaml. The document also includes a reference table of available configuration parameters. - [Aerospike Backup Service on Kubernetes](https://aerospike.com/docs/kubernetes/tools/backup/backup-service.md): This guide provides instructions for deploying the Aerospike Backup Service (ABS) on Kubernetes using AKO. It details how to set up service accounts, configure S3-compatible storage via Kubernetes secrets or IAM roles (IRSA), prepare custom resource files, and verify successful deployment through kubectl commands. - [Aerospike Backup CR](https://aerospike.com/docs/kubernetes/tools/backup/backup.md): This document explains how to trigger on-demand and scheduled backups by creating and applying an Aerospike Backup Custom Resource (CR). It details the requirements for deploying the Aerospike Backup Service (ABS) and provides instructions for using kubectl to manage backup configurations via YAML files. - [Backup and restore overview](https://aerospike.com/docs/kubernetes/tools/backup/overview.md): This document provides an overview of how the Aerospike Kubernetes Operator (AKO) manages cluster backups and restores. It details the three key components involved: the Aerospike Backup Service (ABS), the Aerospike Backup Custom Resource for scheduled or on-demand tasks, and the Aerospike Restore Custom Resource. - [Configuration Settings for an Aerospike Restore on Kubernetes](https://aerospike.com/docs/kubernetes/tools/backup/restore-configuration.md): This guide details how to use the AerospikeRestore Custom Resource to manage database restores via the Aerospike Kubernetes Operator. It provides YAML examples for Full, Incremental, and Timestamp restore types, including configurations for S3 storage, local-storage, and TLS-enabled destination clusters. - [Use Helm to create an Aerospike Restore](https://aerospike.com/docs/kubernetes/tools/backup/restore-helm.md): This document provides a step-by-step guide for using Helm to create an Aerospike Restore Custom Resource on Kubernetes. It includes instructions for adding the repository, creating a customized values.yaml file with specific restore parameters like destination and policy, and deploying the chart. A configuration table is also provided for quick reference of available settings. - [Restore backups on Kubernetes](https://aerospike.com/docs/kubernetes/tools/backup/restore.md): This guide explains how to trigger Full, Incremental, or Timestamp-based restores for Aerospike clusters on Kubernetes using the Aerospike Backup Service (ABS) and Custom Resources. It provides step-by-step instructions for creating YAML configuration files, applying them with kubectl, and verifying restore status, while noting critical version compatibility requirements. - [Upgrade Aerospike Backup Service on Kubernetes](https://aerospike.com/docs/kubernetes/tools/backup/upgrade-backup-service.md): This guide details the process of upgrading Aerospike Backup Service (ABS) from version 2.x to 3.x on Kubernetes. It explains how to update the ABS Custom Resource image and modify configuration parameters to address breaking changes, ensuring a successful rolling restart of service pods. - [Kubernetes Operator Release Notes](https://aerospike.com/docs/kubernetes/release.md): Release notes and version history for Kubernetes Operator. Check this directory for version-specific changes and upgrade information.