Apache Geode Documentation
Back to Geode Page
Community
Doc Index
Apache Geode Documentation
Getting Started with Apache Geode
About Apache Geode
Main Features of Apache Geode
Prerequisites and Installation Instructions
Host Machine Requirements
Java Support
How to Install
Setting Up the CLASSPATH
How to Uninstall
Upgrading Apache Geode
Planning an Upgrade
Rolling Upgrade
Offline Upgrade
Upgrading Clients
Apache Geode in 15 Minutes or Less
Introduction to Geode Clients
Configuring and Running a Cluster
Overview of the Cluster Configuration Service
Tutorial—Creating and Using a Cluster Configuration
Deploying Application JARs to Apache Geode Members
Using Member Groups
Exporting and Importing Cluster Configurations
Cluster Configuration Files and Troubleshooting
Using gfsh to Manage a Remote Cluster Over HTTP or HTTPS
Deploying Configuration Files without the Cluster Configuration Service
Main Steps to Deploying Configuration Files
Default File Specifications and Search Locations
Changing the File Specifications
Deploying Configuration Files in JAR Files
Starting Up and Shutting Down Your System
Running Geode Locator Processes
Running Geode Server Processes
Managing System Output Files
Firewall Considerations
Firewalls and Connections
Firewalls and Ports
Cluster Management Service (Experimental)
Basic Configuration and Programming
Cluster and Cache Configuration
Cluster Members
Setting Properties
Options for Configuring the Cache and Data Regions
Local and Remote Membership and Caching
Cache Management
Introduction to Cache Management
Managing a Peer or Server Cache
Managing a Client Cache
Managing a Cache in a Secure System
Managing RegionServices for Multiple Secure Users
Launching an Application after Initializing the Cache
Data Regions
Region Management
Region Naming
Region Shortcuts and Custom Named Region Attributes
Storing and Retrieving Region Shortcuts and Custom Named Region Attributes
Managing Region Attributes
Creating Custom Attributes for Regions and Entries
Building a New Region with Existing Content
Data Entries
Managing Data Entries
Copy on Read Behavior
Requirements for Using Custom Classes in Data Caching
Topologies and Communication
Topology and Communication General Concepts
Topology Types
Planning Topology and Communication
How Member Discovery Works
How Communication Works
Using Bind Addresses
Choosing Between IPv4 and IPv6
Peer-to-Peer Configuration
Configuring Peer-to-Peer Discovery
Configuring Peer Communication
Organizing Peers into Logical Member Groups
Client/Server Configuration
Standard Client/Server Deployment
How Server Discovery Works
How Client/Server Connections Work
Configuring a Client/Server System
Organizing Servers Into Logical Member Groups
Client/Server Example Configurations
Fine-Tuning Your Client/Server Configuration
Multi-site (WAN) Configuration
How Multi-site (WAN) Systems Work
Overview of Multi-site Caching
Consistency for WAN Updates
Discovery for Multi-Site Systems
Gateway Senders
Gateway Receivers
Multi-site (WAN) Topologies
Configuring a Multi-site (WAN) System
Filtering Events for Multi-Site (WAN) Distribution
Resolving Conflicting Events
Managing Apache Geode
Apache Geode Management and Monitoring
Management and Monitoring Features
Overview of Geode Management and Monitoring Tools
Architecture and Components
JMX Manager Operations
Starting a JMX Manager
Configuring a JMX Manager
Stopping a JMX Manager
Federated MBean Architecture
List of Geode JMX MBeans
JMX Manager MBeans
Managed Node MBeans
Browsing Geode MBeans through JConsole
Geode JMX MBean Notifications
Notification Federation
List of JMX MBean Notifications
MemberMXBean Notifications
MemberMXBean Gateway Notifications
CacheServerMXBean Notifications
DistributedSystemMXBean Notifications
Configuring RMI Registry Ports and RMI Connectors
Executing gfsh Commands through the Management API
Managing Heap and Off-heap Memory
Managing Heap Memory
Using the Geode Resource Manager
How Background Eviction Is Performed
Controlling Heap Use with the Resource Manager
Configure Geode for Heap LRU Management
Tuning the JVM's Garbage Collection Parameters
Monitor and Tune Heap LRU Configurations
Resource Manager Example Configurations
Managing Off-Heap Memory
Locking Memory (Linux Systems Only)
Disk Storage
How Disk Stores Work
Disk Store File Names and Extensions
Disk Store Operation Logs
Configuring Disk Stores
Designing and Configuring Disk Stores
Disk Store Configuration Parameters
Modifying the Default Disk Store
Optimizing a System with Disk Stores
Start Up and Shut Down with Disk Stores
Disk Store Management
Disk Store Management Commands and Operations
Validating a Disk Store
Running Compaction on Disk Store Log Files
Keeping a Disk Store Synchronized with the Cache
Configuring Disk Free Space Monitoring
Handling Missing Disk Stores
Altering When Buffers Are Flushed to Disk
Creating Backups for System Recovery and Operational Management
Cache and Region Snapshots
Usage and Performance Notes
Exporting Cache and Region Snapshots
Importing Cache and Region Snapshots
Filtering Entries During Import or Export
Reading Snapshots Programmatically
Region Compression
Guidelines on Using Compression
How to Enable Compression in a Region
Working with Compressors
Comparing Performance of Compressed and Non-Compressed Regions
Network Partitioning
How Network Partitioning Management Works
Failure Detection and Membership Views
Membership Coordinators, Lead Members and Member Weighting
Network Partitioning Scenarios
Configure Apache Geode to Handle Network Partitioning
Preventing Network Partitions
Security
Security Implementation Introduction and Overview
Security Detail Considerations
External Interfaces, Ports, and Services
Resources That Must Be Protected
Log File Locations
Where to Place Security Configuration Settings
Enable Security with Property Definitions
Authentication
Implementing Authentication
Authentication Example
Implementing Authentication Expiry
Authorization
Implementing Authorization
Method Invocation Authorizers
Authorization Examples
Post Processing of Region Data
SSL
Configuring SSL
SSL-Configurable Components
SSL Configuration Properties
SSL Property Reference Tables
Procedure
SSL Sample Implementation
Performance Tuning and Configuration
Disable TCP SYN Cookies
Improving Performance on vSphere
Performance Controls
Data Serialization
Setting Cache Timeouts
Controlling Socket Use
Management of Slow Receivers
Increasing the Ratio of Cache Hits
System Member Performance
Member Properties
JVM Memory Settings and System Performance
Garbage Collection and System Performance
Slow Receivers with TCP/IP
Preventing Slow Receivers
Managing Slow Receivers
Slow distributed-ack Messages
Socket Communication
Setting Socket Buffer Sizes
Ephemeral TCP Port Limits
Making Sure You Have Enough Sockets
TCP/IP KeepAlive Configuration
TCP/IP Peer-to-Peer Handshake Timeouts
Configuring Sockets in Multi-Site (WAN) Deployments
UDP Communication
Multicast Communication
Provisioning Bandwidth for Multicast
Testing Multicast Speed Limits
Configuring Multicast Speed Limits
Run-time Considerations for Multicast
Troubleshooting the Multicast Tuning Process
Maintaining Cache Consistency
Logging
How Geode Logging Works
Understanding Log Messages and Their Categories
Naming, Searching, and Creating Log Files
Set Up Logging
Advanced Users—Configuring Log4j 2 for Geode
Statistics
How Statistics Work
Transient Region and Entry Statistics
Application-Defined and Custom Statistics
Configuring and Using Statistics
Viewing Archived Statistics
Troubleshooting and System Recovery
Producing Artifacts for Troubleshooting
Diagnosing System Problems
System Failure and Recovery
Handling Forced Cache Disconnection Using Autoreconnect
Recovering from Application and Cache Server Crashes
Recovering from Crashes with a Peer-to-Peer Configuration
Recovering from Crashes with a Client/Server Configuration
Recovering from Machine Crashes
Recovering from ConfictingPersistentDataExceptions
Preventing and Recovering from Disk Full Errors
Understanding and Recovering from Network Outages
Log Messages and Solutions
Developing with Apache Geode
Region Data Storage and Distribution
Storage and Distribution Options
Region Types
Region Data Stores and Data Accessors
Creating Regions Dynamically
Partitioned Regions
Understanding Partitioning
Configuring Partitioned Regions
Configuring the Number of Buckets for a Partitioned Region
Custom-Partitioning and Colocating Data
Understanding Custom Partitioning and Data Colocation
Standard Custom Partitioning
Fixed Custom Partitioning
Colocate Data from Different Partitioned Regions
Configuring High Availability for Partitioned Regions
Understanding High Availability for Partitioned Regions
Configure High Availability for a Partitioned Region
Set the Number of Redundant Copies
Configure Redundancy Zones for Members
Set Enforce Unique Host
Configure Member Crash Redundancy Recovery for a Partitioned Region
Configure Member Join Redundancy Recovery for a Partitioned Region
Configuring Single-Hop Client Access to Server-Partitioned Regions
Understanding Client Single-Hop Access to Server-Partitioned Regions
Configure Client Single-Hop Access to Server-Partitioned Regions
Rebalancing Partitioned Region Data
Checking Redundancy in Partitioned Regions
Restoring Redundancy in Partitioned Regions
Moving Partitioned Region Data to Another Member
Distributed and Replicated Regions
How Distribution Works
Options for Region Distribution
How Replication and Preloading Work
Configure Distributed, Replicated, and Preloaded Regions
Locking in Global Regions
Consistency for Region Updates
Consistency Checking by Region Type
Configuring Consistency Checking
Overhead for Consistency Checks
How Consistency Checking Works for Replicated Regions
How Destroy and Clear Operations Are Resolved
Transactions with Consistent Regions
General Region Data Management
Persistence and Overflow
How Persistence and Overflow Work
Configure Region Persistence and Overflow
Overflow Configuration Examples
Eviction
How Eviction Works
Configure Data Eviction
Expiration
How Expiration Works
Configure Data Expiration
Keeping the Cache in Sync with Outside Data Sources
Overview of Outside Data Sources
Configuring Database Connections Using JNDI
How Data Loaders Work
Implement a Data Loader
Data Serialization
Overview of Data Serialization
Geode PDX Serialization
Geode PDX Serialization Features
High Level Steps for Using PDX Serialization
Using Automatic Reflection-Based PDX Serialization
Customizing Serialization with Class Pattern Strings
Extending the ReflectionBasedAutoSerializer
Serializing Your Domain Object with a PdxSerializer
Implementing PdxSerializable in Your Domain Object
Programming Your Application to Use PdxInstances
Adding JSON Documents to the Geode Cache
Using PdxInstanceFactory to Create PdxInstances
Persisting PDX Metadata to Disk
Using PDX Objects as Region Entry Keys
Geode Data Serialization (DataSerializable and DataSerializer)
Standard Java Serialization
Events and Event Handling
How Events Work
Peer-to-Peer Event Distribution
Client-to-Server Event Distribution
Multi-Site (WAN) Event Distribution
List of Event Handlers and Events
Implementing Geode Event Handlers
Implementing Cache Event Handlers
Implementing an AsyncEventListener for Write-Behind Cache Event Handling
How to Safely Modify the Cache from an Event Handler Callback
Cache Event Handler Examples
Configuring Peer-to-Peer Event Messaging
Configuring Client/Server Event Messaging
Configuring Highly Available Servers
Highly Available Client/Server Event Messaging
Implementing Durable Client/Server Messaging
Tuning Client/Server Event Messaging
Conflate the Server Subscription Queue
Limit the Server's Subscription Queue Memory Use
Tune the Client's Subscription Message Tracking Timeout
Configuring Multi-Site (WAN) Event Queues
Persisting an Event Queue
Configuring Dispatcher Threads and Order Policy for Event Distribution
Conflating Events in a Queue
Delta Propagation
How Delta Propagation Works
When to Avoid Delta Propagation
Delta Propagation Properties
Implementing Delta Propagation
Errors In Delta Propagation
Delta Propagation Example
Querying
Querying FAQ and Examples
Querying with OQL
Writing and Executing a Query in OQL
Building a Query String
IMPORT Statement
FROM Clause
WHERE Clause
SELECT Statement
OQL Aggregate Functions
OQL Syntax and Semantics
Supported Character Sets
Supported Keywords
Case Sensitivity
Comments in Query Strings
Query Language Grammar
Operators
Reserved Words
Supported Literals
Query Language Restrictions and Unsupported Features
Advanced Querying
Performance Considerations
Monitoring Low Memory When Querying
Timeouts for Long-Running Queries
Using Query Bind Parameters
Querying a Specific Member
Querying Partitioned Regions
Using ORDER BY on Partitioned Regions
Querying a Partitioned Region on a Single Node
Optimizing Queries on Data Partitioned by a Key or Field Value
Performing an Equi-Join Query on Partitioned Regions
Partitioned Region Query Restrictions
Query Debugging
Working with Indexes
Tips and Guidelines on Using Indexes
Creating, Listing and Removing Indexes
Creating Key Indexes
Creating Hash Indexes
Creating Indexes on Map Fields ("Map Indexes")
Creating Multiple Indexes at Once
Maintaining Indexes (Synchronously or Asynchronously) and Index Storage
Using Query Index Hints
Using Indexes on Single Region Queries
Using Indexes with Equi-Join Queries
Using Indexes with Overflow Regions
Using Indexes on Equi-Join Queries using Multiple Regions
Index Samples
Continuous Querying
How Continuous Querying Works
Implementing Continuous Querying
Managing Continuous Querying
Transactions
Adherence to ACID Promises
Code Examples
Design Considerations
Function Execution
How Function Execution Works
Executing a Function in Apache Geode
Developing REST Applications for Apache Geode
Geode REST API Overview
Prerequisites and Limitations for Writing REST Applications
Setup and Configuration
Enabling the REST API
Starting the REST API Service
Implementing Authentication
Programmatic Startup
Using the Swagger UI to Browse REST APIs
Developing REST Applications
Working with Regions
Working with Queries
Working with Functions
Sample REST Applications
Troubleshooting and FAQ
Apache Geode REST API Reference
Region Endpoints
GET /geode/v1
GET /geode/v1/{region}
GET /geode/v1/{region}/keys
GET /geode/v1/{region}/{key}
GET /geode/v1/{region}/{key1},{key2},...,{keyN}
HEAD /geode/v1/{region}
POST /geode/v1/{region}?key=<key>
PUT /geode/v1/{region}/{key}
PUT /geode/v1/{region}/{key1},{key2},...{keyN}
PUT /geode/v1/{region}/{key}?op=REPLACE
PUT /geode/v1/{region}/{key}?op=CAS
DELETE /geode/v1/{region}
DELETE /geode/v1/{region}/{key}
DELETE /geode/v1/{region}/{key1},{key2},...{keyN}
Query Endpoints
GET /geode/v1/queries
POST /geode/v1/queries?id=<queryId>&q=<OQL-statement>
POST /geode/v1/queries/{queryId}
PUT /geode/v1/queries/{queryId}
DELETE /geode/v1/queries/{queryId}
GET /geode/v1/queries/adhoc?q=<OQL-statement>
Function Endpoints
GET /geode/v1/functions
POST /geode/v1/functions/{functionId}
Administrative Endpoints
[HEAD | GET] /geode/v1/ping
GET /geode/v1/servers
Tools and Modules
gfsh
What You Can Do with gfsh
Starting gfsh
Configuring the gfsh Environment
Useful gfsh Shell Variables
Basic Shell Features and Command-Line Usage
Specifying JSON within Command-Line Options
Tutorial—Performing Common Tasks with gfsh
Quick Reference of gfsh Commands by Functional Area
Basic Geode gfsh Commands
Configuration Commands
Data Commands
Deployment Commands
Disk Store Commands
Durable CQ and Client Commands
Function Execution Commands
Gateway (WAN) Commands
Geode Monitoring Commands
Index Commands
JMX Connection Commands
Locator Commands
Lucene Commands
PDX Commands
Region Commands
Server Commands
gfsh Command Help
alter
alter async-event-queue
alter disk-store
alter query-service
alter region
alter runtime
backup disk-store
change loglevel
clear defined indexes
close
close durable-client
close durable-cq
compact
compact disk-store
compact offline-disk-store
configure
connect
create
create async-event-queue
create defined indexes
create disk-store
create gateway-receiver
create gateway-sender
create index
create jndi-binding
create lucene index
create region
debug
define index
deploy
describe
describe client
describe config
describe connection
describe disk-store
describe jndi-binding
describe lucene index
describe member
describe offline-disk-store
describe query-service
describe region
destroy
destroy async-event-queue
destroy disk-store
destroy function
destroy gateway-receiver
destroy gateway-sender
destroy index
destroy jndi-binding
destroy lucene index
destroy region
disconnect
echo
execute function
exit
export
export cluster-configuration
export config
export data
export logs
export offline-disk-store
export stack-traces
gc
get
help
hint
history
import
import cluster-configuration
import data
list
list async-event-queues
list clients
list deployed
list disk-stores
list durable-cqs
list functions
list gateways
list indexes
list jndi-binding
list lucene indexes
list members
list regions
load-balance gateway-sender
locate entry
netstat
pause gateway-sender
pdx rename
put
query
rebalance
remove
restore redundancy
resume
resume async-event-queue-dispatcher
resume gateway-sender
revoke missing-disk-store
run
search lucene
set variable
sh
show
show dead-locks
show log
show metrics
show missing-disk-stores
show subscription-queue-size
shutdown
sleep
start
start gateway-receiver
start gateway-sender
start jconsole
start jvisualvm
start locator
start pulse
start server
status
status cluster-config-service
status gateway-receiver
status gateway-sender
status locator
status redundancy
status server
stop
stop gateway-receiver
stop gateway-sender
stop locator
stop server
undeploy
validate offline-disk-store
version
wan-copy region
Creating and Running gfsh Command Scripts
Running gfsh Commands on the OS Command Line
Mapping cache.xml Elements to gfsh Configuration Commands
Gemcached
How Gemcached Works
Deploying and Configuring a Gemcached Server
Advantages of Gemcached over Memcached
HTTP Session Management Modules
HTTP Session Management Quick Start
Advantages of Using Geode for Session Management
Common Topologies for HTTP Session Management
General Information on HTTP Session Management
Session State Log Files
Configuring Non-Sticky Sessions
HTTP Session Management Module for Pivotal tc Server
Installing the HTTP Module for tc Server
Setting Up the HTTP Module for tc Server
Changing the Default Geode Configuration in the tc Server Module
Interactive Configuration Reference for the tc Server Module
HTTP Session Management Module for Tomcat
Installing the HTTP Module for Tomcat
Setting Up the HTTP Module for Tomcat
Changing the Default Geode Configuration in the Tomcat Module
HTTP Session Management Module for AppServers
Setting Up the HTTP Module for AppServers
Changing the Default Geode Configuration in the AppServers Module
Common Geode Configuration Changes for AppServers
Geode Pulse
Pulse System Requirements
Running Pulse in Embedded Mode (Quick Start)
Hosting Pulse on a Web Application Server
Configuring Pulse Authentication
Using Pulse Views
Apache Lucene Integration
Using the Apache Lucene Integration
Requirements and Caveats
Micrometer
Configuration and Publishing
Micrometer Meters and Tags
Use Cases
The Inline Cache
Reference
gemfire.properties and gfsecurity.properties (Geode Properties)
Using Non-ASCII Strings in Apache Geode Property Files
cache.xml
cache.xml Quick Reference
<cache> Element Hierarchy
<cache> Element Reference
<client-cache> Element Hierarchy
<client-cache> Element Reference
Region Shortcuts
Region Shortcuts Quick Reference
LOCAL
LOCAL_HEAP_LRU
LOCAL_OVERFLOW
LOCAL_PERSISTENT
LOCAL_PERSISTENT_OVERFLOW
PARTITION
PARTITION_HEAP_LRU
PARTITION_OVERFLOW
PARTITION_PERSISTENT
PARTITION_PERSISTENT_OVERFLOW
PARTITION_PROXY
PARTITION_PROXY_REDUNDANT
PARTITION_REDUNDANT
PARTITION_REDUNDANT_HEAP_LRU
PARTITION_REDUNDANT_OVERFLOW
PARTITION_REDUNDANT_PERSISTENT
PARTITION_REDUNDANT_PERSISTENT_OVERFLOW
REPLICATE
REPLICATE_HEAP_LRU
REPLICATE_OVERFLOW
REPLICATE_PERSISTENT
REPLICATE_PERSISTENT_OVERFLOW
REPLICATE_PROXY
Exceptions and System Failures
Memory Requirements for Cached Data
Geode Statistics List
Cache Performance (CachePerfStats)
Cache Server (CacheServerStats)
Client-Side Notifications (CacheClientUpdaterStats)
Client-to-Server Messaging Performance (ClientStats)
Client Connection Pool (PoolStats)
Continuous Querying (CQStatistics)
Delta Propagation (DeltaPropagationStatistics)
Disk Space Usage (DiskDirStatistics)
Disk Usage and Performance (DiskRegionStatistics)
Distributed System Messaging (DistributionStats)
Distributed Lock Services (DLockStats)
Function Execution (FunctionServiceStatistics)
Gateway Queue (GatewayStatistics)
Indexes (IndexStats)
JVM Performance
Locator (LocatorStatistics)
Lucene Indexes (LuceneIndexStats)
Off-Heap (OffHeapMemoryStats)
Operating System Statistics - Linux
Partitioned Regions (PartitionedRegion<partitioned_region_name>Statistics)
Region Entry Eviction – Count-Based (LRUStatistics)
Region Entry Eviction – Size-based (LRUStatistics)
Server Notifications for All Clients (CacheClientNotifierStatistics)
Server Notifications for Single Client (CacheClientProxyStatistics)
Server-to-Client Messaging Performance (ClientSubscriptionStats)
Statistics Collection (StatSampler)
Transaction Reference Material
JTA Global Transactions with Geode
Coordinating with External JTA Transaction Managers
Using Geode as the "Last Resource" in a Container-Managed JTA Transaction
Behavior of Geode Cache Writers and Loaders Under JTA
Turning Off JTA Transactions
Glossary
Apache Geode
CHANGELOG
Supported Character Sets
Geode query language supports the full ASCII and Unicode character sets.