How To Install Hazelcast on Ubuntu 24.04 LTS

Hazelcast stands as a powerful in-memory data grid platform that revolutionizes distributed computing for modern applications. Ubuntu 24.04 LTS provides the perfect foundation for deploying this robust clustering solution with its enhanced stability and long-term support guarantees.

Installing Hazelcast on Ubuntu 24.04 LTS opens doors to high-performance distributed caching, real-time analytics, and scalable microservices architectures. This comprehensive guide walks through every aspect of the installation process, from initial system preparation to production-ready deployment configurations.

Whether deploying for development environments or enterprise-grade production systems, this tutorial provides the expertise needed for successful Hazelcast implementation. The following sections cover multiple installation methods, security configurations, performance optimizations, and troubleshooting techniques to ensure optimal results.

System Requirements and Prerequisites

Hardware and Software Requirements

Successful Hazelcast deployment on Ubuntu 24.04 LTS demands careful attention to system specifications. The minimum hardware configuration requires at least 8 CPU cores per Hazelcast member to handle concurrent operations effectively. Memory allocation represents a critical factor, with 8 GB RAM serving as the baseline requirement for optimal performance.

Storage considerations extend beyond basic disk space requirements. Fast SSD storage significantly improves data persistence and recovery operations. Network infrastructure must support high-throughput communication between cluster members, particularly in multi-node deployments.

Ubuntu 24.04 LTS compatibility verification ensures seamless integration with Hazelcast’s latest features. The operating system’s kernel version and package management system align perfectly with Hazelcast’s deployment requirements. System architecture support encompasses both x86_64 and ARM64 platforms, providing flexibility for various deployment scenarios.

Essential Prerequisites Setup

Java Development Kit installation forms the cornerstone of Hazelcast deployment. JDK 11 or higher versions provide the runtime environment necessary for optimal performance. Oracle JDK, OpenJDK, and Amazon Corretto represent viable options for production environments.

User permissions configuration requires sudo access for package installations and system service management. Creating dedicated service accounts enhances security while maintaining proper access controls. Network configuration preparation includes firewall rule planning and port allocation for cluster communication.

Security preparations encompass SSL certificate generation, authentication mechanism setup, and network segmentation planning. These foundational elements ensure production-ready deployments meet enterprise security standards.

Java Installation on Ubuntu 24.04 LTS

Installing OpenJDK

Java runtime environment installation begins with system package updates and repository verification. Ubuntu 24.04 LTS ships with comprehensive OpenJDK packages supporting multiple Java versions simultaneously.

sudo apt update && sudo apt upgrade -y
sudo apt install default-jdk -y

The default installation typically provides Java 21 LTS, offering excellent performance characteristics and long-term support. Alternative version installations accommodate specific application requirements:

# Install OpenJDK 11
sudo apt install openjdk-11-jdk -y

# Install OpenJDK 17
sudo apt install openjdk-17-jdk -y

# Install OpenJDK 21 (Latest LTS)
sudo apt install openjdk-21-jdk -y

Version verification confirms successful installation and identifies the active Java runtime:

java -version
javac -version

Java Environment Configuration

Environment variable configuration ensures consistent Java runtime behavior across system sessions. The JAVA_HOME variable points to the active Java installation directory:

# Find Java installation path
sudo update-alternatives --config java

# Set JAVA_HOME permanently
echo 'export JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64' >> ~/.bashrc
echo 'export PATH=$PATH:$JAVA_HOME/bin' >> ~/.bashrc
source ~/.bashrc

Multiple Java version management utilizes Ubuntu’s alternatives system for seamless switching between installations:

sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/java-11-openjdk-amd64/bin/java 1
sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/java-17-openjdk-amd64/bin/java 2
sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/java-21-openjdk-amd64/bin/java 3

Environment verification confirms proper configuration through comprehensive testing:

echo $JAVA_HOME
which java
java -version

Hazelcast Installation Methods

Method 1: Package Manager Installation

Repository-based installation provides the most straightforward approach to Hazelcast deployment on Ubuntu systems. The official Hazelcast repository ensures access to the latest stable releases with automated dependency management.

Repository configuration begins with GPG key import and source list addition:

# Import Hazelcast GPG key
wget -qO - https://repository.hazelcast.com/api/gpg/key/public | gpg --dearmor | sudo tee /usr/share/keyrings/hazelcast-archive-keyring.gpg > /dev/null

# Add Hazelcast repository
echo "deb [signed-by=/usr/share/keyrings/hazelcast-archive-keyring.gpg] https://repository.hazelcast.com/debian stable main" | sudo tee -a /etc/apt/sources.list.d/hazelcast.list

# Update package index
sudo apt update

Package installation proceeds with standard APT commands:

sudo apt install hazelcast -y

Installation verification confirms successful deployment and version identification:

hz --version
which hz

Method 2: Binary Distribution Installation

Binary distribution installation offers maximum control over deployment locations and configurations. This method suits environments requiring custom installation paths or offline deployments.

Download and extraction process utilizes the latest stable release:

# Create installation directory
sudo mkdir -p /opt/hazelcast
cd /tmp

# Download latest stable release
wget https://github.com/hazelcast/hazelcast/releases/download/v5.5.0/hazelcast-5.5.0.tar.gz

# Extract binary distribution
tar -xzf hazelcast-5.5.0.tar.gz

# Move to installation directory
sudo mv hazelcast-5.5.0/* /opt/hazelcast/
sudo chown -R $USER:$USER /opt/hazelcast

Symbolic link creation and PATH configuration enable system-wide access:

# Create symbolic links
sudo ln -sf /opt/hazelcast/bin/hz /usr/local/bin/hz
sudo ln -sf /opt/hazelcast/bin/hz-start /usr/local/bin/hz-start
sudo ln -sf /opt/hazelcast/bin/hz-stop /usr/local/bin/hz-stop

# Update PATH variable
echo 'export PATH=$PATH:/opt/hazelcast/bin' >> ~/.bashrc
source ~/.bashrc

Method 3: Docker Installation

Container-based deployment provides isolation, portability, and simplified management capabilities. Docker installation requires prior Docker engine setup on the Ubuntu system.

Docker engine installation verification:

# Install Docker if not present
sudo apt install docker.io -y
sudo systemctl start docker
sudo systemctl enable docker
sudo usermod -aG docker $USER

Hazelcast container deployment utilizes the official Docker image:

# Pull official Hazelcast image
docker pull hazelcast/hazelcast:5.5.0

# Run Hazelcast container
docker run -d \
  --name hazelcast-instance \
  -p 5701:5701 \
  -e HZ_NETWORK_PUBLICADDRESS=localhost:5701 \
  hazelcast/hazelcast:5.5.0

Docker Compose configuration enables persistent, manageable deployments:

version: '3.8'
services:
  hazelcast:
    image: hazelcast/hazelcast:5.5.0
    container_name: hazelcast-cluster
    ports:
      - "5701:5701"
    environment:
      - HZ_NETWORK_PUBLICADDRESS=localhost:5701
      - HZ_CLUSTERNAME=development
    volumes:
      - ./config:/opt/hazelcast/config
    restart: unless-stopped

Initial Configuration and Setup

Basic Hazelcast Configuration

Configuration management centers around the hazelcast.xml file, which defines cluster behavior, network settings, and operational parameters. The default configuration provides a solid foundation for development environments but requires customization for production deployments.

Standard configuration file location varies by installation method:

• Package installation: /etc/hazelcast/hazelcast.xml
• Binary installation: /opt/hazelcast/config/hazelcast.xml
• Docker deployment: Volume-mounted configuration

Basic configuration structure encompasses essential elements:

<?xml version="1.0" encoding="UTF-8"?>
<hazelcast xmlns="http://www.hazelcast.com/schema/config"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.hazelcast.com/schema/config
           http://www.hazelcast.com/schema/config/hazelcast-config-5.5.xsd">
    
    <cluster-name>ubuntu-cluster</cluster-name>
    
    <network>
        <port auto-increment="true">5701</port>
        <join>
            <multicast enabled="false"/>
            <tcp-ip enabled="true">
                <member>127.0.0.1:5701</member>
            </tcp-ip>
        </join>
    </network>
    
</hazelcast>

Network configuration for Ubuntu environments requires careful consideration of discovery mechanisms and port allocation. TCP/IP discovery provides reliability in cloud environments where multicast may be restricted.

Creating Custom Configuration Files

Production environments demand tailored configurations addressing specific performance, security, and operational requirements. Custom configuration creation begins with copying the default template and applying environment-specific modifications.

Memory management configuration optimizes heap utilization and garbage collection behavior:

<map name="default">
    <time-to-live-seconds>300</time-to-live-seconds>
    <max-idle-seconds>600</max-idle-seconds>
    <eviction-policy>LRU</eviction-policy>
    <max-size policy="PER_NODE">10000</max-size>
</map>

Network join configuration establishes cluster member discovery and communication protocols:

<network>
    <port auto-increment="true">5701</port>
    <outbound-ports>
        <ports>0</ports>
    </outbound-ports>
    <join>
        <multicast enabled="false"/>
        <tcp-ip enabled="true">
            <member-list>
                <member>192.168.1.10:5701</member>
                <member>192.168.1.11:5701</member>
                <member>192.168.1.12:5701</member>
            </member-list>
        </tcp-ip>
    </join>
</network>

Starting and Managing Hazelcast

Service Startup Procedures

Hazelcast service initialization varies depending on the installation method and deployment requirements. Systemd integration provides robust service management capabilities for production environments.

Manual startup verification tests basic functionality:

# Package installation startup
hz-start

# Binary installation startup
/opt/hazelcast/bin/hz-start

# Background execution with nohup
nohup hz-start > /var/log/hazelcast.log 2>&1 &

Service verification confirms successful startup and cluster formation:

# Check process status
ps aux | grep hazelcast

# Verify port binding
netstat -tulpn | grep 5701

# Monitor log output
tail -f /var/log/hazelcast.log

Systemd Service Configuration

System service creation enables automatic startup, dependency management, and service monitoring capabilities. Custom systemd unit files provide complete control over service behavior.

Service file creation at /etc/systemd/system/hazelcast.service:

[Unit]
Description=Hazelcast In-Memory Data Grid
After=network.target
Requires=network.target

[Service]
Type=forking
User=hazelcast
Group=hazelcast
ExecStart=/usr/bin/hz-start
ExecStop=/usr/bin/hz-stop
PIDFile=/var/run/hazelcast.pid
Restart=on-failure
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

Service activation and management commands:

# Reload systemd configuration
sudo systemctl daemon-reload

# Enable service for automatic startup
sudo systemctl enable hazelcast

# Start service
sudo systemctl start hazelcast

# Check service status
sudo systemctl status hazelcast

# View service logs
sudo journalctl -u hazelcast -f

Cluster Configuration and Multi-Node Setup

Single Node Development Setup

Single-node configurations provide ideal environments for development, testing, and proof-of-concept deployments. These setups minimize complexity while maintaining full feature accessibility.

Development configuration emphasizes simplicity and rapid iteration:

<hazelcast>
    <cluster-name>development</cluster-name>
    <network>
        <port auto-increment="false">5701</port>
        <join>
            <multicast enabled="false"/>
            <tcp-ip enabled="true">
                <member>127.0.0.1:5701</member>
            </tcp-ip>
        </join>
    </network>
    <management-center scripting-enabled="false"/>
</hazelcast>

Testing and validation procedures verify single-node functionality:

# Start development instance
hz-start -c /path/to/dev-config.xml

# Connect with Hazelcast client
hz-cli

# Verify cluster status
cluster

Multi-Node Production Cluster

Production cluster deployment requires comprehensive planning for network topology, member discovery, and fault tolerance. Multi-node configurations distribute load and provide high availability through redundancy.

Cluster member configuration defines discovery mechanisms and communication protocols:

<hazelcast>
    <cluster-name>production-cluster</cluster-name>
    <network>
        <port auto-increment="true">5701</port>
        <public-address>PUBLIC_IP:5701</public-address>
        <join>
            <multicast enabled="false"/>
            <tcp-ip enabled="true">
                <member-list>
                    <member>10.0.1.10:5701</member>
                    <member>10.0.1.11:5701</member>
                    <member>10.0.1.12:5701</member>
                </member-list>
            </tcp-ip>
        </join>
    </network>
    <partition-group enabled="true" group-type="HOST_AWARE"/>
</hazelcast>

Network configuration considerations address firewall rules, port management, and security groups:

# Configure firewall rules
sudo ufw allow 5701:5708/tcp
sudo ufw allow from 10.0.1.0/24 to any port 5701:5708

# Test cluster connectivity
telnet MEMBER_IP 5701

Security Configuration

Authentication and Authorization

Security implementation protects cluster resources through authentication mechanisms and access control policies. Hazelcast provides multiple authentication options including simple authentication, LDAP integration, and custom security realms.

Basic authentication configuration establishes user credentials and permissions:

<security enabled="true">
    <member-credentials-factory class-name="com.hazelcast.security.UsernamePasswordCredentialsFactory">
        <properties>
            <property name="username">admin</property>
            <property name="password">secure-password</property>
        </properties>
    </member-credentials-factory>
    
    <member-authentication type="simple">
        <credentials-factory class-name="com.hazelcast.security.UsernamePasswordCredentialsFactory">
            <properties>
                <property name="username">cluster-member</property>
                <property name="password">member-password</property>
            </properties>
        </credentials-factory>
    </member-authentication>
</security>

Client security configuration restricts unauthorized access and implements permission-based controls:

<client-permissions>
    <all-permissions principal="admin"/>
    <map-permission name="secure-map" principal="user">
        <actions>
            <action>read</action>
        </actions>
    </map-permission>
</client-permissions>

TLS/SSL Encryption

Encrypted communication protects data in transit between cluster members and clients. SSL configuration requires certificate generation, keystore management, and cipher suite selection.

Keystore generation and certificate management:

# Generate keystore for cluster member
keytool -genkeypair -alias hazelcast -keyalg RSA -keysize 2048 \
        -validity 365 -keystore member.keystore \
        -dname "CN=hazelcast-member,O=MyOrg,C=US"

# Export certificate
keytool -export -alias hazelcast -keystore member.keystore \
        -file member.cert

# Create truststore
keytool -import -alias hazelcast -file member.cert \
        -keystore member.truststore

SSL configuration in hazelcast.xml:

<ssl enabled="true">
    <factory-class-name>com.hazelcast.nio.ssl.BasicSSLContextFactory</factory-class-name>
    <properties>
        <property name="keyStore">/path/to/member.keystore</property>
        <property name="keyStorePassword">keystore-password</property>
        <property name="trustStore">/path/to/member.truststore</property>
        <property name="trustStorePassword">truststore-password</property>
        <property name="protocol">TLS</property>
    </properties>
</ssl>

Performance Optimization

System-Level Optimizations

Ubuntu system tuning enhances Hazelcast performance through kernel parameter adjustments, memory management improvements, and I/O optimization. These modifications address the specific requirements of in-memory computing workloads.

Transparent Huge Pages (THP) disabling prevents memory allocation delays:

# Disable THP temporarily
echo never | sudo tee /sys/kernel/mm/transparent_hugepage/enabled
echo never | sudo tee /sys/kernel/mm/transparent_hugepage/defrag

# Make changes persistent
echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' | sudo tee -a /etc/rc.local
echo 'echo never > /sys/kernel/mm/transparent_hugepage/defrag' | sudo tee -a /etc/rc.local

Swap configuration optimization minimizes memory pressure impacts:

# Configure swappiness for in-memory workloads
echo 'vm.swappiness=1' | sudo tee -a /etc/sysctl.conf

# Apply changes immediately
sudo sysctl vm.swappiness=1

JVM tuning parameters optimize garbage collection and memory allocation patterns:

export JAVA_OPTS="-Xms8g -Xmx8g -XX:+UseG1GC -XX:MaxGCPauseMillis=200 \
                  -XX:+UnlockExperimentalVMOptions -XX:G1NewSizePercent=20 \
                  -XX:G1MaxNewSizePercent=40 -XX:+DisableExplicitGC"

Hazelcast-Specific Performance Tuning

Application-level optimization addresses serialization efficiency, operation threading, and network communication patterns. These configurations directly impact throughput and latency characteristics.

Serialization optimization reduces CPU overhead and network bandwidth consumption:

<serialization>
    <portable-version>1</portable-version>
    <use-native-byte-order>true</use-native-byte-order>
    <byte-order>BIG_ENDIAN</byte-order>
    <enable-compression>true</enable-compression>
    <enable-shared-object>true</enable-shared-object>
    
    <serializers>
        <global-serializer>com.hazelcast.nio.serialization.StreamSerializer</global-serializer>
    </serializers>
</serialization>

Operation threading configuration balances concurrent execution and resource utilization:

<executor-service name="default">
    <pool-size>16</pool-size>
    <queue-capacity>1000</queue-capacity>
</executor-service>

<properties>
    <property name="hazelcast.operation.thread.count">8</property>
    <property name="hazelcast.operation.generic.thread.count">8</property>
    <property name="hazelcast.io.thread.count">8</property>
</properties>

Testing and Verification

Functionality Validation

Comprehensive testing ensures proper installation and configuration before production deployment. Test procedures validate cluster formation, data operations, and performance characteristics under various conditions.

Cluster connectivity testing verifies member discovery and communication:

# Test cluster status
hz-cli -o my-cluster
cluster

# Verify member count and status
members

# Test data operations
m.put mykey "test value"
m.get mykey

Load testing evaluates performance under realistic workloads:

// Java client load test example
Config config = new Config();
config.getNetworkConfig().addAddress("127.0.0.1:5701");
HazelcastInstance client = HazelcastClient.newHazelcastClient(config);

IMap<String, String> map = client.getMap("test-map");

// Performance test loop
long startTime = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
    map.put("key-" + i, "value-" + i);
}
long duration = System.currentTimeMillis() - startTime;
System.out.println("Inserted 100,000 entries in " + duration + "ms");

Monitoring and Health Verification

Monitoring setup provides ongoing visibility into cluster health, performance metrics, and operational status. Log analysis identifies potential issues and optimization opportunities.

Log monitoring configuration tracks critical events and performance indicators:

# Configure log levels in hazelcast.xml
<properties>
    <property name="hazelcast.logging.type">log4j2</property>
    <property name="hazelcast.logging.details.enabled">true</property>
</properties>

# Monitor live logs
tail -f /opt/hazelcast/logs/hazelcast.log | grep -E "(WARN|ERROR)"

# Analyze cluster formation
grep "Members {size" /opt/hazelcast/logs/hazelcast.log

Performance monitoring utilizes built-in metrics and external monitoring tools:

# Enable JMX monitoring
export JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote \
                  -Dcom.sun.management.jmxremote.port=9999 \
                  -Dcom.sun.management.jmxremote.authenticate=false \
                  -Dcom.sun.management.jmxremote.ssl=false"

Troubleshooting Common Issues

Installation and Configuration Problems

Installation issues frequently stem from Java compatibility, dependency conflicts, or permission problems. Systematic troubleshooting approaches identify root causes and implement effective solutions.

Java version compatibility verification addresses runtime environment issues:

# Check Java version compatibility
java -version
javac -version

# Verify JAVA_HOME setting
echo $JAVA_HOME
ls -la $JAVA_HOME/bin/java

# Test Java functionality
java -cp /opt/hazelcast/lib/hazelcast-5.5.0.jar com.hazelcast.core.server.HazelcastMemberStarter --version

Package dependency resolution resolves missing libraries and version conflicts:

# Check package installation status
dpkg -l | grep hazelcast

# Verify package dependencies
apt-cache depends hazelcast

# Reinstall problematic packages
sudo apt remove --purge hazelcast
sudo apt autoremove
sudo apt install hazelcast

Runtime and Clustering Issues

Cluster formation problems impact system functionality and require immediate attention. Network connectivity issues, discovery mechanism failures, and configuration mismatches represent common failure modes.

Network connectivity troubleshooting verifies communication paths between cluster members:

# Test network connectivity
telnet MEMBER_IP 5701
nmap -p 5701-5708 MEMBER_IP

# Check firewall status
sudo ufw status
sudo iptables -L

# Verify network interface configuration
ip addr show
ss -tulpn | grep 5701

Discovery mechanism debugging identifies member registration and heartbeat issues:

# Enable discovery debugging
export JAVA_OPTS="$JAVA_OPTS -Dhazelcast.logging.level=DEBUG"

# Monitor discovery events
grep "Discovery" /opt/hazelcast/logs/hazelcast.log

# Verify cluster member list
grep "Member \[" /opt/hazelcast/logs/hazelcast.log

Performance troubleshooting addresses throughput and latency problems:

# Monitor system resources
top -p $(pgrep java)
iostat -x 1
vmstat 1

# Analyze GC performance
export JAVA_OPTS="$JAVA_OPTS -XX:+PrintGC -XX:+PrintGCDetails \
                  -XX:+PrintGCTimeStamps -Xloggc:/tmp/gc.log"

# Review GC logs
tail -f /tmp/gc.log

Production Best Practices

Security Hardening

Production deployments require comprehensive security measures protecting against unauthorized access and data breaches. Security hardening encompasses network isolation, access controls, and encryption implementation.

Network security configuration establishes defense-in-depth protection:

# Configure host-based firewall
sudo ufw enable
sudo ufw default deny incoming
sudo ufw allow from 10.0.0.0/8 to any port 5701:5708
sudo ufw allow from 192.168.0.0/16 to any port 5701:5708

# Disable unnecessary services
sudo systemctl disable apache2
sudo systemctl disable nginx
sudo systemctl stop apache2
sudo systemctl stop nginx

User account security implements least-privilege principles:

# Create dedicated service account
sudo useradd -r -s /bin/false hazelcast
sudo mkdir -p /var/lib/hazelcast
sudo chown hazelcast:hazelcast /var/lib/hazelcast
sudo chmod 750 /var/lib/hazelcast

# Set file permissions
sudo chown -R hazelcast:hazelcast /opt/hazelcast
sudo chmod 750 /opt/hazelcast/bin/*

Monitoring and Maintenance

Operational excellence requires proactive monitoring, regular maintenance, and capacity planning. Monitoring systems provide early warning of performance degradation and resource exhaustion.

Log rotation prevents disk space exhaustion:

# Configure logrotate for Hazelcast
sudo tee /etc/logrotate.d/hazelcast << EOF
/opt/hazelcast/logs/*.log {
    daily
    rotate 30
    compress
    delaycompress
    missingok
    notifempty
    copytruncate
}
EOF

# Test log rotation
sudo logrotate -d /etc/logrotate.d/hazelcast

Backup and recovery procedures ensure data protection and business continuity:

# Create backup script
#!/bin/bash
BACKUP_DIR="/backup/hazelcast/$(date +%Y%m%d)"
mkdir -p $BACKUP_DIR

# Backup configuration files
cp -r /opt/hazelcast/config $BACKUP_DIR/
cp -r /etc/hazelcast $BACKUP_DIR/

# Backup persistent data
cp -r /var/lib/hazelcast $BACKUP_DIR/

# Create archive
tar -czf $BACKUP_DIR.tar.gz $BACKUP_DIR
rm -rf $BACKUP_DIR

Advanced Configuration Options

High Availability Setup

Enterprise deployments demand high availability configurations ensuring continuous service delivery despite hardware failures or maintenance activities. Advanced clustering configurations provide automatic failover and load distribution capabilities.

Split-brain protection prevents data inconsistencies during network partitions:

<split-brain-protection enabled="true" name="majority-quorum">
    <minimum-cluster-size>3</minimum-cluster-size>
    <protect-on>READ_WRITE</protect-on>
    <split-brain-protection-listeners>
        <split-brain-protection-listener>com.example.QuorumListener</split-brain-protection-listener>
    </split-brain-protection-listeners>
</split-brain-protection>

<map name="critical-data">
    <split-brain-protection-ref>majority-quorum</split-brain-protection-ref>
</map>

Backup configuration ensures data replication across cluster members:

<map name="replicated-data">
    <backup-count>2</backup-count>
    <async-backup-count>1</async-backup-count>
    <read-backup-data>true</read-backup-data>
</map>

Integration Patterns

Modern architectures require seamless integration with existing systems, databases, and messaging platforms. Hazelcast provides comprehensive integration capabilities supporting various enterprise patterns.

Database integration enables transparent data loading and persistence:

<map name="customer-cache">
    <map-store enabled="true" initial-mode="LAZY">
        <class-name>com.hazelcast.examples.CustomerMapStore</class-name>
        <write-delay-seconds>60</write-delay-seconds>
        <write-batch-size>100</write-batch-size>
    </map-store>
</map>

Event processing configuration enables real-time data pipeline implementation:

<event-journal name="order-events" enabled="true">
    <capacity>10000</capacity>
    <time-to-live-seconds>3600</time-to-live-seconds>
</event-journal>

<reliable-topic name="order-topic">
    <read-batch-size>25</read-batch-size>
    <topic-overload-policy>DISCARD_NEWEST</topic-overload-policy>
    <statistics-enabled>true</statistics-enabled>
</reliable-topic>

Congratulations! You have successfully installed Hazelcast. Thanks for using this tutorial for installing Hazelcast real-time data platform on Ubuntu 24.04 LTS system. For additional help or useful information, we recommend you check the official Hazelcast website.