• WebSphere eXtreme Scale 8.6.1 documentation
  • Product overview
    • WebSphere eXtreme Scale overview
    • What's new
    • Release notes
    • Notices
    • Privacy policy considerations
    • Hardware and software requirements
    • Directory conventions
    • WebSphere eXtreme Scale technical overview
    • Caching overview
      • Caching architecture
        • Catalog service
        • Container servers, partitions, and shards
        • Maps
        • Clients
      • Enterprise data grid overview
        • Class evolution
      • IBM eXtremeMemory
      • Zones
      • Evictors
      • OSGi framework overview
    • Cache integration overview
      • JPA level 2 (L2) cache plug-in
      • HTTP session management
      • Dynamic cache provider overview
    • Database integration overview
      • Sparse and complete cache
      • Side cache
      • In-line cache
      • Write-behind caching
      • Loaders
      • Data preloading and warm-up
      • Database synchronization
      • WebSphere eXtreme Scale change data capture adapter for InfoSphere Data Replication
      • Data invalidation
      • Indexing
      • JPA Loaders
    • Serialization overview
      • Serialization using Java
      • ObjectTransformer plug-in
      • Serialization using the DataSerializer plug-ins
    • Scalability overview
      • Data grids, partitions, and shards
      • Partitioning
      • Placement and partitions
      • Single-partition and cross-data-grid transactions
      • Scaling in units or pods
    • Availability overview
      • High availability
        • Core groups
        • High availability catalog service
        • Catalog server quorums
        • Replication for availability
      • Replicas and shards
        • Shard placement
        • Reading from replicas
        • Load balancing across replicas
        • Shard lifecycles
        • Map sets for replication
    • Transaction processing overview
      • Transactions
        • Transaction processing in Java EE applications
      • CopyMode attribute
      • Locking strategies
      • Lock types
      • Deadlocks
      • Data access and transactions
      • Transaction isolation
      • Single-partition and cross-data-grid transactions
      • JMS for distributed transaction changes
      • Two-phase commit and error recovery
    • Security overview
    • REST data services overview
  • Scenarios
    • Configuring an enterprise data grid
      • Enterprise data grid overview
      • Configuring IBM eXtremeIO (XIO)
      • Configuring XDF
      • Developing enterprise data grid applications
        • Class evolution
        • Defining ClassAlias and FieldAlias annotations to correlate Java and .NET classes
          • ClassAlias and FieldAlias annotations
        • Mapping keys to partitions with PartitionKey annotations
        • Java and C# data type equivalents
      • Starting stand-alone servers (XIO)
      • Tuning IBM eXtremeIO (XIO)
    • Securing your data grid in eXtreme Scale
      • Authenticating eXtreme Scale connections between servers
        • Authenticating eXtreme Scale server connections in stand-alone environments
        • Authenticating eXtreme Scale server connections in the OSGi framework
        • Authenticating eXtreme Scale server connections in WebSphere Application Server
      • Authenticating requests from clients to servers
        • Authenticating client requests in stand-alone environments
        • Authenticating client requests in the OSGi framework
        • Authenticating client requests in WebSphere Application Server
      • Authorizing access to the data grid
        • Authorizing access to the data grid in stand-alone environments
        • Authorizing access to the data grid in the OSGi framework
        • Authorizing access to the data grid in WebSphere Application Server
      • Authorizing access for special administrative operations
        • Authorizing access for administrative operations in stand-alone environments
        • Authorizing access for administrative operations in the OSGi framework
        • Authorizing access for administrative operations in WebSphere Application Server
      • Securing data that flows between eXtreme Scale clients and servers with SSL encryption
        • Securing data that flows between eXtreme Scale servers in stand-alone environments with SSL encryption
        • Securing data that flows between eXtreme Scale and the OSGi framework with SSL encryption
        • Securing data that flows between eXtreme Scale and WebSphere Application Server with SSL encryption
      • Storing security artifacts for authorized users
        • Storing security artifacts in stand-alone environments
        • Storing security artifacts in the OSGi framework
        • Storing security artifacts in WebSphere Application Server
      • Starting and stopping secure servers
        • Starting secure servers in a stand-alone environment
        • Starting and stopping secure servers in the OSGi framework
        • Starting secure servers in WebSphere Application Server
        • Stopping secure servers
    • Using an OSGi environment to develop and run eXtreme Scale plug-ins
      • OSGi framework overview
      • Installing the Eclipse Equinox OSGi framework with Eclipse Gemini for clients and servers
        • Installing eXtreme Scale bundles
      • Running eXtreme Scale containers with non-dynamic plug-ins in an OSGi environment
      • Administering eXtreme Scale servers and applications in an OSGi environment
      • Building and running eXtreme Scale dynamic plug-ins for use in an OSGi environment
        • Building eXtreme Scale dynamic plug-ins
        • Configuring eXtreme Scale plug-ins with OSGi Blueprint
        • Installing and starting OSGi-enabled plug-ins
      • Running eXtreme Scale containers with dynamic plug-ins in an OSGi environment
        • Configuring OSGi-enabled plug-ins using the ObjectGrid descriptor XML file
        • Starting eXtreme Scale servers using the Eclipse Equinox OSGi framework
        • Administering OSGi-enabled services using the xscmd utility
        • Configuring servers with OSGi Blueprint
    • Using JCA to connect transactional applications to eXtreme Scale clients
      • Transaction processing in Java EE applications
      • Installing an eXtreme Scale resource adapter
      • Configuring eXtreme Scale connection factories
      • Configuring Eclipse environments to use eXtreme Scale connection factories
      • Configuring applications to connect with eXtreme Scale
      • Securing J2C client connections
      • Developing eXtreme Scale client components to use transactions
      • Administering J2C client connections
    • Migrating a WebSphere Application Server memory-to-memory replication or database session to use WebSphere eXtreme Scale session management
      • Taking note of previous configuration settings in WebSphere Application Server administrative console
      • Creating the catalog service domain for WebSphere eXtreme Scale session management
      • Configuring WebSphere eXtreme Scale to use your previous configuration settings
    • Using WebSphere eXtreme Scale as a dynamic cache provider
      • Dynamic cache provider overview
      • Planning environment capacity
      • Configuring an enterprise data grid in a stand-alone environment for dynamic caching
      • Configuring dynamic cache instances
  • Samples
    • Free trial
    • Sample properties files
    • Sample: xsadmin utility
      • Creating a configuration profile for the xsadmin utility
      • xsadmin utility reference
      • Verbose option for the xsadmin utility
  • Tutorials
    • Tutorial: Querying a local in-memory data grid
      • ObjectQuery tutorial - step 1
      • ObjectQuery tutorial - step 2
      • ObjectQuery tutorial - step 3
      • ObjectQuery tutorial - step 4
    • Tutorial: Storing order information in entities
      • Step 1
      • Step 2
      • Step 3
      • Step 4
      • Step 5
      • Step 6
    • Tutorial: Configuring Java SE security
      • Java SE security tutorial - Step 1
      • Java SE security tutorial - Step 2
      • Java SE security tutorial - Step 3
      • Java SE security tutorial - Step 4
      • Java SE security tutorial - Step 5
      • Java SE security tutorial - Step 6
    • Tutorial: Integrate WebSphere eXtreme Scale security with WebSphere Application Server
      • Introduction
      • Module 1: Prepare WebSphere Application Server
        • Lesson 1.1: Understand the topology and get the tutorial files
        • Lesson 1.2: Configure the WebSphere Application Server environment
      • Module 2: Configure WebSphere eXtreme Scale to use WebSphere Application Server Authentication plug-ins
        • Lesson 2.1: Configure client server security
        • Lesson 2.2: Configure catalog server security
        • Lesson 2.3: Configure container server security
        • Lesson 2.4: Install and run the sample
      • Module 3: Configure transport security
        • Lesson 3.1: Configure CSIv2 inbound and outbound transport
        • Lesson 3.2: Add SSL properties to the catalog server properties file
        • Lesson 3.3: Run the sample
      • Module 4: Use Java Authentication and Authorization Service (JAAS) authorization in WebSphere Application Server
        • Lesson 4.1: Enable WebSphere eXtreme Scale authorization
        • Lesson 4.2: Enable user-based authorization
        • Lesson 4.3: Configure group-based authorization
      • Module 5: Use the xscmd tool to monitor data grids and maps
    • Tutorial: Security in a mixed environment
      • Introduction
      • Module 1: Prepare the environment
        • Lesson 1.1: Understand the topology and get the tutorial files
        • Lesson 1.2: Configure the WebSphere Application Server environment
      • Module 2: Configure authentication
        • Lesson 2.1: Configure WebSphere eXtreme Scale client security
        • Lesson 2.2: Configure catalog server security
        • Lesson 2.3: Configure container server security
        • Lesson 2.4: Install and run the sample
      • Module 3: Configure transport security
        • Lesson 3.1: Configure CSIv2 inbound and outbound transport
        • Lesson 3.2: Add SSL properties to the catalog server properties file
        • Lesson 3.3: Run the sample
      • Module 4: Use Java Authentication and Authorization Service (JAAS) authorization in WebSphere Application Server
        • Lession 4.1: Enable WebSphere eXtreme Scale authorization
        • Lesson 4.2: Enable user-based authorization
      • Module 5: Use the xscmd utility to monitor data grids and maps
    • Tutorial: Running eXtreme Scale bundles in the OSGi framework
      • Introduction: Starting and configuring the eXtreme Scale server and container to run plug-ins in the OSGi framework
      • Module 1: Preparing to install and configure eXtreme Scale server bundles
        • Lesson 1.1: Understand the OSGi sample bundles
        • Lesson 1.2: Understand the OSGi configuration files
      • Module 2: Installing and starting eXtreme Scale bundles in the OSGi framework
        • Lesson 2.1: Start the console and install the eXtreme Scale server bundle
        • Lesson 2.2: Customize and configure the eXtreme Scale server
        • Lesson 2.3: Configure the eXtreme Scale container
        • Lesson 2.4: Install the Google Protocol Buffers and sample plug-in bundles
        • Lesson 2.5: Start the OSGi bundles
      • Module 3: Running the eXtreme Scale sample client
        • Lesson 3.1: Set up Eclipse to run the client and build the samples
        • Lesson 3.2: Start a client and insert data into the grid
      • Module 4: Querying and upgrading the sample bundle
        • Lesson 4.1: Query service rankings
        • Lesson 4.2: Determine whether specific service rankings are available
        • Lesson 4.3: Update the service rankings
  • Getting started
    • Tutorial: Getting started with WebSphere eXtreme Scale
      • Lesson 1.1: Configuring data grids
      • Module 2: Create a client application
        • Lesson 2.1: Creating a Java client application
        • Lesson 2.2: Creating a .NET client application
        • Lesson 2.3: Creating an enterprise data grid application
      • Module 3: Running the sample application in the data grid
        • Lesson 3.1: Starting catalog and container servers
        • Lesson 3.2: Running the getting started sample client application
        • Lesson 3.3: Running the .NET sample client application
      • Lesson 4: Monitor your environment
    • Getting started with developing applications
  • WebSphere eXtreme Scale Liberty Deployment
    • Overview
      • Hardware and software requirements for XSLD
      • Reserved TCP/IP ports for XSLD
    • Installing XSLD / Creating a cache member group
      • Installing XSLD as root user
      • Installing XSLD as non-root user
    • Logging into XSLD as the administrator
    • Tutorial: Creating a data grid and running cache operations
      • Lesson 1: Creating a general user
      • Lesson 2: Creating a group
      • Lesson 3: Creating a data grid
      • Lesson 4: Assigning group permissions to a data grid
      • Lesson 5: Running cache operations with the REST API
    • Tutorial: Increasing capacity and setting up replication
      • Lesson 1: Increasing cache capacity
      • Lesson 2: Setting up replication between two members
      • Lesson 3: Setting up Derby auto replication in XSLD
      • Lesson 4: Monitoring Derby replication in XSLD
    • Admin and Operational REST APIs
      • Running REST APIs with the IBM API Discovery tool
      • Running REST APIs with cURL
        • Cache member group API
          • Getting members of a cache member group
          • Getting information about a cache member group
        • Group management API
          • Viewing group members
          • Listing all the roles for a group
          • Viewing the ACL of a group
          • Changing permissions on a group for data grid access
          • Creating a group
        • User management API
          • Adding a user to a group
        • Task API commands
          • NewMemberJoinTaskCommand
          • SetupDerbyReplicationTaskCommand
          • DisableDerbyReplicationTaskCommand
          • DisjoinMemberTaskCommand
          • RestartServersTaskCommand
          • ForceDerbyFailoverTaskCommand
          • UpdateContainerAndJVMSizeTaskCommand
          • UpdateXMSettingTaskCommand
        • Grids management API
          • Creating or updating a grid
          • Listing grids
          • Getting data grid information
          • Getting a key value
          • Inserting a key value
          • Updating a key value
          • Deleting a key value
        • Grid template management API
          • Creating a grid template
          • Listing grid templates
          • Deleting grid templates
    • Running xscmd commands with the REST API
    • Administering
      • Restarting XSLD servers
      • Changing the secret key in XSLD
      • Setting up SMTP email in XSLD
      • Resetting passwords for a user in XSLD
      • Unlocking a locked user in XSLD
      • Creating LDAP users and binding to a cache member group
      • Verifying product version
    • Troubleshooting
      • Enabling remote logging in XSLD
      • Getting trace logs for problem determination
      • Enabling logging for HTTP access requests to the Operational REST server
    • Security
      • Securing the eXtreme Scale client for XSLD
        • Enabling Transport Layer Security (TLS) in the eXtreme Scale client
        • Enabling credential authentication in the eXtreme Scale client
      • Securing a cache member group
        • Creating a keystore and a truststore
        • Configuring TLS for a cache member group
        • Configuring TLS for a cache member group with cURL
    • Advanced configuration
      • Configuring the eXtreme Scale server in Liberty
        • Setting up replication between data caches
        • Example: Setting the catalog server heartbeat frequency
        • Enabling disk overflow
        • Configuring system APIs and plug-ins
          • Example: Adding a plug-in to the ObjectGrid XML file
      • Configuring the eXtreme Scale client in Liberty
        • Accessing the data grid with Java APIs
        • Accessing the data grid with JNDI
        • Configuring the client to use HTTP session failover
        • Configuring the client to use dynamic caching
    • Liberty configuration elements
      • elasticCacheClient
      • elasticCacheCatalog
      • elasticCacheCatalogCluster
      • xioEndpoint
      • elasticCache
      • gridApplication
      • objectGrid
      • httpSessionElasticCache
      • distributedMap
      • elasticCacheServerSecurity
      • elasticCacheStats
      • elasticCacheClientSecurity
      • elasticCacheDiskOverflow
  • WebSphere eXtreme Scale Pattern
    • Pattern overview
    • Tutorial: Creating a pattern with a cache member group
      • Lesson 1: Downloading and configuring a pattern type
      • Lesson 2: Deploying a cache member group in a virtual system pattern
    • Performing a rolling upgrade on a cache member group
    • Configuring the eXtreme Scale client to use the caching server
    • Pattern troubleshooting
  • Planning
    • Planning overview
    • Planning the topology
      • Local in-memory cache
      • Peer-replicated local cache
      • Embedded cache
      • Distributed cache
      • Database integration overview
        • Sparse and complete cache
        • Side cache
        • In-line cache
        • Write-behind caching
        • Loaders
        • Data preloading and warm-up
        • Database synchronization
        • Data invalidation
        • Indexing
      • Multiple data center topologies
        • Topologies for multi-master replication
        • Configuration considerations for multi-master topologies
        • Loader considerations in a multi-master topology
        • Design considerations for multi-master replication
    • Interoperability with other products
    • Planning for configuration
      • Supported APIs and configurations by client type
      • Planning for network ports
        • Planning for firewall traffic between catalog servers
        • Planning for firewall traffic between container and catalog servers
        • Planning for firewall traffic between container servers
        • Planning for firewall traffic between clients and data grid servers
        • Planning for firewall traffic between the xscmd utility and data grid servers
        • Planning for firewall traffic between the monitoring console and data grid servers
        • Planning for firewall traffic between an MBean dashboard and data grid servers
      • Planning to use IBM eXtremeMemory
      • Security overview
    • Planning for installation
      • Hardware and software requirements
      • Microsoft .NET considerations
      • Java SE considerations
      • Java EE considerations
      • Directory conventions
    • Planning environment capacity
      • Enabling disk overflow
      • Sizing memory and partition count calculation
      • Sizing CPU per partition for transactions
      • Sizing CPUs for parallel transactions
    • Planning to develop WebSphere eXtreme Scale applications
      • Planning to develop Microsoft .NET applications
        • Microsoft .NET considerations
      • Planning to develop Java applications
        • Java API overview
        • Java plug-ins overview
        • REST data services overview
        • Spring framework overview
        • Java class loader and classpath considerations
        • Relationship management
        • Cache key considerations
        • Data for different time zones
  • Installing
    • Considerations for GDPR readiness
    • Installation overview
    • Planning for installation
      • Installation topologies
      • Hardware and software requirements
      • Offering IDs for WebSphere eXtreme Scale product offerings
      • Java SE considerations
      • Java EE considerations
      • Directory conventions
      • Runtime files for WebSphere Application Server installation
      • Runtime files for installation
    • IBM Installation Manager and WebSphere eXtreme Scale product offerings
      • Installing IBM Installation Manager using the GUI
        • Installing the product with the GUI
      • Installing IBM Installation Manager using the command line
        • Installing the product using the command line
      • Installing IBM Installation Manager using response files
        • Installing the product using a response file
          • Creating a keyring
    • Installing WebSphere eXtreme Scale Client for .NET overview
      • Installing WebSphere eXtreme Scale Client for .NET
      • Installing WebSphere eXtreme Scale Client for .NET with silent mode
      • Installing WebSphere eXtreme Scale Client for .NET without the installation program
      • Uninstalling WebSphere eXtreme Scale Client for .NET
    • Installing the Eclipse Equinox OSGi framework with Eclipse Gemini for clients and servers
    • Installing the REST data service
      • Installing eXtreme Scale bundles
    • Installing within WebSphere Application Server
    • Deploying the REST gateway on WebSphere Application Server Classic
    • Creating and augmenting profiles
      • Using the graphical user interface to create profiles
      • Using the graphical user interface to augment profiles
      • manageprofiles command
      • Non-root profiles
    • First steps after installation
    • Uninstalling the product using IBM Installation Manager
      • Uninstalling the product using the GUI
      • Uninstalling the product using the command line
      • Uninstalling the product using response files
    • Troubleshooting the product installation
  • Updating and migrating
    • Updating eXtreme Scale servers
    • Migrating to WebSphere eXtreme Scale
    • Installing fix packs using IBM Installation Manager
      • Installing fix packs using the GUI
      • Installing fix packs using the command line
      • Installing fix packs using a response file
      • Installing XSLD fix packs using IBM Installation Manager
    • Uninstalling fix packs using IBM Installation Manager
      • Uninstalling fix packs using the GUI
      • Uninstalling fix packs using the command line
      • Uninstalling fix packs using response files
    • Updating WebSphere eXtreme Scale on WebSphere Application Server
    • Upgrading WebSphere eXtreme Scale Client for .NET
      • Creating a side-by-side installation of fix packs for WebSphere eXtreme Scale Client for .NET
    • xsadmin tool to xscmd tool migration
    • Deprecated properties and APIs
      • Removed properties and APIs
  • Configuring
    • Configuration methods
    • Operational checklist
    • Configuring data grids
      • Configuring local deployments
      • Configuring XDF
      • Configuring evictors with XML files
        • Configuring the near cache to update the LAST_ACCESS_TIME value for the TTL evictor in the data grid
      • Configuring a locking strategy in the ObjectGrid descriptor XML file
      • Configuring the lock timeout value
      • Configuring peer-to-peer replication with JMS
        • Distributing changes between peer JVMs
        • JMS event listener
      • Configuring dynamic maps
      • Managing host names for communication between clients and servers
      • Configuring the management concentrator
    • Configuring deployment policies
      • Configuring distributed deployments
      • Controlling shard placement with zones
        • Zones for replica placement
        • Zone-preferred routing
        • Defining zones for container servers
        • Example: Zone definitions in the deployment policy descriptor XML file
        • Viewing zone information with the xscmd utility
    • Configuring catalog and container servers
      • Configuring catalog servers and catalog service domains
        • Example: Configuring catalog service domains
        • Configuring WebSphere eXtreme Scale with WebSphere Application Server
          • Configuring the catalog service in WebSphere Application Server
            • Creating catalog service domains in WebSphere Application Server
              • Catalog service domain administrative tasks
              • Catalog service domain collection
              • Catalog service domain settings
              • Client security properties
              • Catalog service domain custom properties
        • Managing host names for communication between clients and servers
        • Configuring the quorum mechanism
        • Tuning failover detection
      • Configuring container servers
        • Container server reconnect properties
        • Configuring container servers in WebSphere Application Server
          • Configuring WebSphere Application Server applications to automatically start container servers
      • Configuring an enterprise data grid in a stand-alone environment for dynamic caching
      • Configuring core groups
    • Configuring multiple data center topologies
    • Configuring ports
      • Configuring ports in stand-alone mode
      • Configuring ports in a WebSphere Application Server environment
      • Servers with multiple network cards
    • Configuring transports
      • Displaying the transport type of your catalog service domain
      • Configuring IBM eXtremeIO (XIO)
      • Configuring Object Request Brokers
        • Configuring the Object Request Broker in a WebSphere Application Server environment
        • Configuring the Object Request Broker with stand-alone WebSphere eXtreme Scale processes
        • Configuring a custom Object Request Broker
    • Configuring IBM eXtremeMemory
    • Configuring Java clients
      • Java client overrides
      • Configuring Java clients with an XML configuration
      • Configuring the REST gateway with an XML configuration
      • Configuring Java clients programmatically
      • Configuring the near cache
      • Configuring a near cache for the dynamic cache
      • Configuring near-cache invalidation
      • Configuring an evictor for the near cache
      • Configuring JMS-based client synchronization
      • Configuring request and retry timeout values
    • Configuring WebSphere eXtreme Scale Client for .NET
      • WebSphere eXtreme Scale Client for .NET overrides
      • Configuring WebSphere eXtreme Scale Client for .NET programmatically
      • Enabling dynamic configuration of WebSphere eXtreme Scale Client for .NET
      • Configuring the ASP.NET session state store provider
        • Creating a data grid to use with the ASP.NET session state store provider
        • Configuring the ASP.NET session state store provider
    • Configuring eXtreme Scale connection factories
      • Configuring Eclipse environments to use eXtreme Scale connection factories
    • Configuring cache integration
      • Configuring HTTP session managers
        • Configuring the HTTP session manager with WebSphere Application Server
          • Configuring WebSphere Application Server HTTP session persistence to a data grid
            • eXtreme Scale session management settings
          • Splicing a session data grid application with the addObjectGridFilter script
          • Editing the splicer.properties file
        • Configuring HTTP session manager with WebSphere Portal
        • Configuring the HTTP session manager for various application servers
        • Displaying HTTP session sizes
        • XML files for HTTP session manager configuration
        • Servlet context initialization parameters
        • splicer.properties file
        • Example: Overriding the session ID with the sessionIdOverrideClass interface
        • Example: Persisting an updated session attribute with the setAttribute() method
      • Configuring dynamic cache instances
        • Configuring the default dynamic cache instance (baseCache)
        • Configuring object or servlet dynamic cache instances
        • Customizing a dynamic cache instance with custom properties
          • Cache instances properties file
          • Dynamic cache custom properties
      • JPA level 2 (L2) cache plug-in
        • Migrating to Hibernate Version 4.0
        • JPA cache configuration properties for Hibernate Version 4.0
        • Configuring the OpenJPA cache plug-in
          • Example: OpenJPA ObjectGrid XML files
        • Configuring the Hibernate cache plug-in
          • Example: Hibernate ObjectGrid XML files
      • Configuring a Spring cache provider
    • Configuring database integration
      • Configuring JPA loaders
        • Configuring a JPA time-based data updater
    • Configuring CDC in eXtreme Scale
    • Configuring REST data services
      • Enabling the REST data service
        • Scalable data model in eXtreme Scale
        • Retrieving and updating data with REST
        • Starting a stand-alone data grid for REST data services
        • Starting a data grid for REST data services in WebSphere Application Server
      • Configuring application servers for the REST data service
        • Deploying the REST data service on WebSphere Application Server
          • Starting REST data services with WebSphere eXtreme Scale integrated in WebSphere Application Server 7.0
        • Deploying the REST data service on WebSphere Application Server Community Edition
          • Starting the REST data service in WebSphere Application Server Community Edition
        • Deploying the REST data service on Apache Tomcat
          • Starting REST data services in Apache Tomcat
      • Configuring Web browsers to access REST data service ATOM feeds
      • Using a Java client with REST data services
      • Visual Studio 2008 WCF client with REST data service
    • Deploying the REST gateway on WebSphere Application Server Classic
    • Configuring OSGi-enabled plug-ins using the ObjectGrid descriptor XML file
    • Configuring servers for OSGi
      • Configuring eXtreme Scale plug-ins with OSGi Blueprint
      • Configuring servers with OSGi Blueprint
      • Configuring servers with OSGI config admin
  • Administering
    • Starting and stopping stand-alone servers
      • Starting stand-alone servers (XIO)
        • Starting a stand-alone catalog service (XIO)
        • Starting container servers (XIO)
        • startXsServer script (XIO)
      • Stopping stand-alone servers (XIO)
        • stopXsServer script (XIO)
      • Starting stand-alone servers (ORB)
        • Starting a stand-alone catalog service (ORB)
        • Starting container servers (ORB)
        • startOgServer script (ORB)
      • Stopping stand-alone servers (ORB)
        • stopOgServer script (ORB)
    • Stopping servers gracefully with the xscmd utility
    • Starting and stopping servers in a WebSphere Application Server environment
    • Using the embedded server API to start and stop servers
      • Embedded server API
    • Administering with the xscmd utility
    • Controlling placement
    • Managing ObjectGrid availability
    • Managing data center failures
      • When quorum is not enabled
      • When quorum is enabled
    • Querying , displaying, and invalidating data
    • Retrieving eXtreme Scale environment information with the xscmd utility
    • Starting eXtreme Scale servers using the Eclipse Equinox OSGi framework
    • Installing and starting OSGi-enabled plug-ins
    • Administering OSGi-enabled services using the xscmd utility
      • Updating OSGi services for eXtreme Scale plug-ins with xscmd
    • Administering with Managed Beans (MBeans)
      • Accessing Managed Beans (MBeans) using the wsadmin tool
      • Accessing Managed Beans (MBeans) programmatically
    • Administering J2C client connections
  • Developing applications
    • Developing Java applications
      • Setting up the Java development environment
        • Accessing Java API documentation
        • Setting up a stand-alone development environment in Eclipse
        • Running a WebSphere eXtreme Scale application that uses an application server other than WebSphere Application Server in Eclipse
        • Running an integrated client or server application with WebSphere Application Server in Rational Application Developer
      • Accessing data with client applications
        • Connecting to distributed ObjectGrid instances programmatically
        • Tracking map updates
        • Interacting with an ObjectGrid using the ObjectGridManager interface
          • Creating ObjectGrid instances with the ObjectGridManager interface
          • Retrieving a ObjectGrid instance with the ObjectGridManager interface
          • Removing ObjectGrid instances with the ObjectGridManager interface
          • Controlling the lifecycle of an ObjectGrid with the ObjectGridManager interface
          • Accessing the ObjectGrid shard
        • Accessing data with indexes (Index API)
          • DynamicIndexCallback interface
        • Using Sessions to access data in the grid
          • SessionHandle for routing
          • SessionHandle integration
        • Caching objects with no relationships involved (ObjectMap API)
          • Introduction to ObjectMap
          • Creating dynamic maps with Java APIs
          • ObjectMap and JavaMap
          • Maps as FIFO queues
        • Caching objects and their relationships (EntityManager API)
          • Relationship management
          • Defining an entity schema
          • Entity manager in a distributed environment
          • Interacting with EntityManager
            • Entity listeners and callback methods
            • Entity listener examples
          • EntityManager fetch plan support
          • Entity query queues
          • EntityTransaction interface
        • Collocating multiple cache objects in the same partition
          • Routing cache objects to the same partition
        • Defining ClassAlias and FieldAlias annotations to correlate Java classes
          • ClassAlias and FieldAlias annotations
        • Retrieving entities and objects (Query API)
          • Querying data in multiple time zones
          • Data for different time zones
          • Using the ObjectQuery API
            • Configuring an ObjectQuery schema
          • EntityManager Query API
            • Simple queries with EntityManager
          • Reference for eXtreme Scale queries
            • ObjectGrid query Backus-Naur Form
        • Notifying clients of map updates using continuous query
        • Programming for transactions
          • Interacting with data in a transaction
          • Developing applications that update multiple partitions in a single transaction
            • Two-phase commit and error recovery
            • Developing applications to write to multi-partition transactions for WebSphere eXtreme Scale in a stand-alone environment
            • Developing eXtreme Scale client components to use transactions
          • Using locking
            • Configuring and implementing locking in Java applications
            • Example: flush method lock ordering
            • Java exception handling for locking
            • Map entry locks with query and indexes
            • Java examples for transaction isolation
            • Optimistic collision exception
            • Running parallel logic with the DataGrid API
              • DataGrid APIs and partitioning
              • DataGrid agents and entity-based Maps
              • DataGrid API example
        • Configuring Java clients programmatically
          • Java client overrides
          • Enabling client-side map replication
      • System APIs and plug-ins
        • Managing plug-in life cycles
          • Writing an ObjectGridPlugin plug-in
          • Writing a BackingMapPlugin plug-in
        • Plug-ins for multimaster replication
          • Developing custom arbiters for multi-master replication
        • Plug-ins for versioning and comparing cache objects
        • Plug-ins for serializing cached objects
          • Serializer programming overview
          • Avoiding object inflation when updating and retrieving cache data
          • ObjectTransformer plug-in
        • Plug-ins for providing event listeners
          • MapEventListener plug-in
          • ObjectGridEventListener plug-in
          • BackingMapLifecycleListener plug-in
          • ObjectGridLifecycleListener plug-in
        • Plug-ins for evicting cache objects
          • Enabling evictors programmatically
          • Custom evictors
        • Plug-ins for indexing data
          • Configuring the InverseRangeIndex plug-in
            • InverseRangeIndex plug-in attributes
          • Configuring the HashIndex plug-in
            • HashIndex plug-in attributes
            • Custom indexing plug-ins
            • Using a composite index
            • Using a global index
        • Plug-ins for communicating with databases
          • Configuring database loaders
          • Writing a loader
          • Map pre-loading
          • Configuring write-behind loader support
            • Write-behind caching
            • Write-behind loader application design considerations
            • Handling failed write-behind updates
            • Example: Writing a write-behind dumper class
          • JPA loader programming considerations
            • JPAEntityLoader plug-in
          • Using a loader with entity maps and tuples
          • Writing a loader with a replica preload controller
        • Plug-ins for managing transaction life cycle events
          • Transaction processing overview
          • Introduction to plug-in slots
          • External transaction managers
          • WebSphereTransactionCallback plug-in
      • Developing data grid applications with JCache APIs and plug-ins
        • JCache overview
        • Specifying eXtreme Scale as the CachingProvider
        • Retrieving an eXtreme Scale CacheManager
        • Configuring an eXtreme Scale Cache
          • JCache settings in eXtreme Scale XML configuration
          • eXtreme Scale configuration in JCache API
          • Enabling cache loaders and cache writers
          • Configuring cache entry listeners
          • Configuring an ExpiryPolicy
        • Cache API in eXtreme Scale
        • Managing an eXtreme Scale Cache
          • JCache MBean xscmd commands
          • Effects on statistics of JCache operations
          • Effects on statistics of ObjectMap operations
          • Ways to enable or disable JCache MBeans
        • Processing cache entries
        • Securing an eXtreme Scale Cache
      • Programming to use the OSGi framework
        • Building eXtreme Scale dynamic plug-ins
        • Upgrading agents and data models dynamically from OSGi bundles in the Liberty
      • Programming for JPA integration
        • JPA Loaders
        • Developing client-based JPA loaders
          • Client-based JPA preload utility overview
          • Example: Preloading a map with the ClientLoader interface
          • Example: Reloading a map with the ClientLoader interface
          • Example: Calling a client loader
          • Example: Creating a custom client-based JPA loader
          • Developing a client-based JPA loader with a DataGrid agent
        • Example: Using the Hibernate plug-in to preload data into the ObjectGrid cache
        • Starting the JPA time-based updater
          • JPA time-based data updater
      • Developing applications with the Spring framework
        • Spring framework overview
        • Managing transactions with Spring
        • Spring managed extension beans
        • Spring extension beans and namespace support
        • Starting a container server with Spring
        • Configuring clients in the Spring framework
      • Accessing data with the REST data service
        • Operations with the REST data service
        • Optimistic concurrency in the REST data service
        • Request protocols for the REST data service
          • Retrieve requests with the REST data service
          • Retrieving non-entities with REST data services
          • Insert requests with REST data services
          • Update requests with REST data services
          • Delete requests with REST data services
      • Developing data grid applications with the REST gateway
        • URI format
        • Data format
        • REST operations
        • Example: Inserting and getting data grid map entries
        • Example: Inserting and accessing data into a REST map from a Java client
        • Example: Clearing data grid map entries
        • Example: Creating dynamic maps
        • Example: TTL expiration
    • Developing .NET applications
      • Setting up the .NET development environment
        • Accessing WebSphere eXtreme Scale Client for .NET API documentation
      • Creating dynamic maps with .NET APIs
      • Defining ClassAlias and FieldAlias annotations to correlate Java and .NET classes
        • ClassAlias and FieldAlias annotations
      • Mapping keys to partitions with PartitionKey annotations
      • Programming for transactions
        • Interacting with data in a transaction
        • Configuring and implementing locking in .NET applications
        • .NET exception handling for locking
      • Configuring data grid security for WebSphere eXtreme Scale Client for .NET
      • Configuring TLS for WebSphere eXtreme Scale Client for .NET
      • Programming client authentication for WebSphere eXtreme Scale Client for .NET
        • Example: Implementing a user password credential for .NET applications
        • Example: Implementing a user credential generator for .NET applications
      • Programming custom credentials for WebSphere eXtreme Scale Client for .NET
      • Performance programming for WebSphere eXtreme Scale Client for .NET
  • Monitoring
    • Statistics overview
    • Monitoring with the web console
      • Starting and logging on to the web console
      • Connecting the web console to catalog servers
      • Viewing statistics with the web console
        • Web console statistics
      • Monitoring with custom reports
    • Monitoring the health of the environment
      • Message center overview
      • Configuring the message center
      • Viewing health event notifications in the message center
      • Viewing health notifications with the xscmd utility
      • Viewing health notifications with JMX utilities
    • Monitoring with CSV files
      • CSV file statistics definitions
    • Enabling statistics
      • Statistics modules
      • Monitoring with the statistics API
    • Monitoring with the xscmd utility
    • Monitoring with WebSphere Application Server PMI
      • Enabling PMI
      • Retrieving PMI statistics
      • PMI modules
      • Accessing Managed Beans (MBeans) using the wsadmin tool
    • Monitoring server statistics with managed beans (MBeans)
    • Monitoring client HTTP session statistics
    • Monitoring with vendor tools
      • IBM agent for Tivoli Monitoring
      • CA Wily Introscope
      • Monitoring eXtreme Scale with Hyperic HQ
    • Monitoring eXtreme Scale information in DB2
  • Tuning performance
    • Tuning operating systems and network settings
    • Tuning ORB properties
    • Tuning IBM eXtremeIO (XIO)
    • Tuning Java virtual machines
    • Tuning failover detection
    • Tuning database connections for PowerPC
    • Tuning garbage collection with WebSphere Real Time
      • WebSphere Real Time in a stand-alone environment
      • WebSphere Real Time in WebSphere Application Server
    • Tuning the cache sizing agent
      • Cache memory consumption sizing
    • Tuning and performance for application development
      • Tuning the copy mode
        • Improving performance with byte array maps
        • Tuning copy operations with the ObjectTransformer interface
      • Tuning evictors
      • Tuning locking performance
      • Tuning serialization performance
        • Tuning serialization
      • Tuning query performance
        • Query plan
        • Query optimization using indexes
        • Client query optimization using global indexes
      • Tuning EntityManager interface performance
        • Entity performance instrumentation agent
  • Security
    • Securing your data grid in eXtreme Scale
    • Data grid authentication
    • Data grid security
    • WebSphere eXtreme Scale security standards
    • Authenticating and authorizing clients
      • Authenticating application clients
      • Authorizing application clients
      • Authorizing administrative clients
    • Enabling LDAP authentication in eXtreme Scale catalog and container servers
    • Enabling keystore authentication in eXtreme Scale container and catalog servers
    • Developing keystore files for data encryption
    • Configuring secure transport types
      • Transport layer security and secure sockets layer
      • Configuring SSL parameters
    • Java Management Extensions (JMX) security
    • Security integration with external providers
    • Securing the REST data service
    • Security integration with WebSphere Application Server
      • Configuring client security on a catalog service domain
      • Configuring WebSphere eXtreme Scale for WebSphere Application Server for NIST SP800-131a
      • Configuring WebSphere Application Server to use FIPS 140-2
    • Configuring data grid security for WebSphere eXtreme Scale Client for .NET
    • Enabling data grid authorization
    • Starting and stopping secure servers
      • Starting secure servers in a stand-alone environment
      • Starting secure servers in WebSphere Application Server
      • Stopping secure servers
    • Configuring FIPS 140-2
      • Configuring WebSphere Application Server to use FIPS 140-2
      • Configuring the web console to use FIPS 140-2
    • Configuring NIST SP800-131a
      • Configuring NIST SP800-131a for .NET applications
      • Configuring the web console for NIST SP800-131a compliance
    • Configuring security profiles for the xscmd utility
    • Securing J2C client connections
    • Programming for security
      • Security API
      • Client authentication programming
      • Client authorization programming
      • Data grid authentication
      • Local security programming
      • Programming client authentication for WebSphere eXtreme Scale Client for .NET
        • Example: Implementing a user password credential for .NET applications
        • Example: Implementing a user credential generator for .NET applications
  • Troubleshooting
    • Troubleshooting and support for WebSphere eXtreme Scale
      • Techniques for troubleshooting problems
      • Searching knowledge bases
      • Getting fixes
        • Getting fixes from Fix Central
      • Contacting IBM Support
      • Exchanging information with IBM
      • Subscribing to Support updates
    • Enabling logging
      • Configuring remote logging
      • Configuring log file pruning for WebSphere eXtreme Scale Client for .NET
      • WebSphere eXtreme Scale Client for .NET logs
    • Collecting trace
      • Server trace options
    • Troubleshooting with HPEL
    • Analyzing log and trace data
      • Log analysis overview
      • Running log analysis
      • Creating custom scanners for log analysis
      • Troubleshooting log analysis
    • Troubleshooting the product installation
    • Troubleshooting client connectivity
    • Troubleshooting cache integration
    • Troubleshooting the JPA cache plug-in
    • Troubleshooting IBM eXtremeMemory
    • Troubleshooting administration
    • Troubleshooting data monitoring
    • Troubleshooting multiple data center configurations
    • Troubleshooting high availability
    • Troubleshooting loaders
    • Troubleshooting XML configuration
    • Troubleshooting deadlocks
    • Troubleshooting lock timeout exceptions for a multi-partition transaction
      • Resolving lock timeout exceptions
    • Troubleshooting client exceptions
    • Troubleshooting security
    • Troubleshooting Liberty profile configurations
    • Collecting data with the IBM Support Assistant Data Collector
    • IBM Support Assistant for WebSphere eXtreme Scale
  • Reference
    • ObjectGrid interface
    • BackingMap interface
    • ExceptionMapper interface
    • Regular expression syntax
    • Configuration files
      • Server properties file
      • Client properties file
      • REST data service properties file
      • ObjectGrid descriptor XML file
        • objectGrid.xsd file
      • Deployment policy descriptor XML file
        • deploymentPolicy.xsd file
      • Entity metadata descriptor XML file
        • emd.xsd file
      • Security descriptor XML file
        • objectGridSecurity.xsd file
      • Spring descriptor XML file
        • Spring objectgrid.xsd file
      • eXtreme Scale user exit descriptor file
        • wxsUserExitConfig.xsd file
    • Messages
    • User interface settings
      • eXtreme Scale session management settings
      • Catalog service domain collection
      • Catalog service domain settings
      • Client security properties
      • Catalog service domain custom properties
  • xscmd utility reference
    • • Container commands
        • enableforplacement
        • findbykey
        • listDisabledForPlacement
        • releaseShard
        • reserveShard
      • Multimaster replication commands
        • dismissLink
        • establishLink
        • showDomainReplicationState
        • showLinkedDomains
        • showLinkedPrimaries
        • showTransport
      • Placement service commands
        • balanceShardTypes
        • balanceStatus
        • listAllJMXAddresses
        • placementServiceStatus
        • resumeBalancing
        • resume
        • routetable
        • showPlacement
        • enableforplacement
        • listDisabledForPlacement
        • releaseShard
        • reserveShard
        • showReplicationState
        • suspend
        • suspendBalancing
        • suspendstatus
        • swapShardWithPrimary
        • triggerPlacement
      • Object grid commands
        • clearGrid
        • disableJCacheMBean
        • enableJCacheMBean
        • listIndoubts
        • listObjectGridNames
        • revisions
        • showJCacheStats
        • showMapSizes
        • showSessionSize
      • OSGi commands
        • osgiAll
        • osgiCheck
        • osgiCurrent
        • osgiUpdate
      • Profile management commands
        • listProfiles
        • removeProfile
        • showProfile
      • Quorum management commands
        • overrideQuorum
        • showQuorumStatus
      • Server commands
        • getCatTraceSpec
        • getNotificationFilter
        • getStatsSpec
        • getTraceSpec
        • listCoreGroups
        • listHosts
        • listenForNotifications
        • setCatTraceSpec
        • setNotificationFilter
        • setStatsSpec
        • setTraceSpec
        • showCoreGroupMembers
        • showInfo
        • showNotificationHistory
        • showPrimaryCatalogServer
        • teardown
• Site map