NATS

​

Supported Versions

• [email protected]

​

Service Configuration

• Standard protocol port 4222 for client connections
• HTTP monitoring interface 8222 for management
• Secure authentication with automatically generated credentials
• Optimized settings for performance and reliability

​

Available Configuration Options

​

JetStream Configuration

• Memory store: Up to 40GB for high-performance message caching
• File store: Up to 250GB for persistent storage
• Regular sync intervals: Ensures data durability and consistency

​

Deployment Modes

​

Non-HA Mode

• Suitable for development and testing
• Data persistence not guaranteed during node failures
• Lower resource requirements

​

HA Mode

• Creates a multi-node NATS cluster
• Configures routes between cluster nodes automatically
• Implements NATS clustering for high availability
• Provides improved reliability compared to non-HA deployments

​

Authentication Management

• The service access details in the Zerops GUI
• Environment variables in your service configuration:
  • user - Username for authentication (default: “zerops”)
  • password - Generated secure password
  • connectionString - Complete connection string in the format nats://${dbUser}:${dbPassword}@${hostname}:${port}

​

Connection Examples

​

Node.js

import { connect } from 'nats';

const nc = await connect({
  servers: process.env.connectionString
});

// Publish a message
nc.publish('subject', 'Hello NATS!');

// Subscribe to a subject
const sub = nc.subscribe('subject');
for await (const msg of sub) {
  console.log(`Received: ${msg.data}`);
}

​

Python

import asyncio
from nats.aio.client import Client as NATS
import os

async def main():
    nc = NATS()
    await nc.connect(os.environ['connectionString'])
    
    # Publish a message
    await nc.publish('subject', b'Hello NATS!')
    
    # Subscribe to a subject
    async def message_handler(msg):
        print(f"Received: {msg.data.decode()}")
    
    await nc.subscribe('subject', cb=message_handler)

if __name__ == '__main__':
    asyncio.run(main())

​

Go

import (
    "github.com/nats-io/nats.go"
    "os"
)

func main() {
    nc, _ := nats.Connect(os.Getenv("connectionString"))
    defer nc.Close()
    
    // Publish a message
    nc.Publish("subject", []byte("Hello NATS!"))
    
    // Subscribe to a subject
    nc.Subscribe("subject", func(msg *nats.Msg) {
        fmt.Printf("Received: %s\n", string(msg.Data))
    })
}

​

Health Monitoring

• HTTP Health Check: The system checks the /healthz endpoint at port 8222
• Self-Healing: The platform automatically recovers unhealthy nodes when issues are detected

​

Health Status

1. Through the Zerops GUI dashboard
2. By accessing the management interface at port 8222

​

Backup and Recovery

• Format: .tar.gz (archive of queue state)
• Tooling: Filesystem archival
• Content: Captures persistent message state

​

Restoring Backups

1. Download the backup file (.tar.gz) from the Zerops UI
2. Extract the archive to access the queue state data
3. Prepare your target environment (clear existing data if needed)
4. Restore using NATS CLI commands via Zerops VPN or during deployment. Follow the official NATS documentation for detailed restore procedures.

​

Use Cases

• Microservices Communication - Lightweight, fast inter-service messaging
• Event-Driven Architecture - Publish-subscribe patterns for event distribution
• Request-Reply Patterns - Synchronous communication with built-in timeout
• Stream Processing - Real-time data processing with JetStream
• IoT & Edge Computing - Efficient messaging for resource-constrained environments
• Multi-tenant Applications - Subject-based isolation and routing

​

Best Practices

​

Performance

• Use subject hierarchies for efficient routing
• Implement proper message batching where applicable
• Monitor JetStream storage usage
• Configure appropriate message limits for your workload

​

Reliability

• Use JetStream for critical messages requiring persistence
• Implement proper error handling and reconnection logic
• Monitor consumer lag in stream processing
• Use HA mode for production workloads

​

Security

• Store credentials in environment variables
• Use subject-based authorization where needed
• Implement TLS for sensitive data (contact support)
• Rotate credentials periodically

​

Support

• Join our Discord community
• Contact support via email