LogoLogo
StackState.comDownloadSupportExplore playground
StackState v5.1
StackState v5.1
  • Welcome to the StackState docs!
  • StackState self-hosted v5.1 docs
  • Getting Started
  • 🚀Setup
    • Install StackState
      • Requirements
      • Kubernetes / OpenShift
        • Kubernetes install
        • OpenShift install
        • Required Permissions
        • Non-high availability setup
        • Override default configuration
        • Configure storage
        • Configure Ingress
        • Install from custom image registry
        • Migrate from Linux install
      • Linux
        • Before you install
        • Download
        • Install StackState
        • Install with production configuration
        • Install with development configuration
        • Install with POC configuration
        • Set up a reverse proxy
        • Set up TLS without reverse proxy
      • Initial run guide
      • Troubleshooting
    • Upgrade StackState
      • Steps to upgrade
      • Version specific upgrade instructions
      • StackPack versions
      • StackState release notes
    • StackState Agent
      • About StackState Agent V3
      • Docker
      • Kubernetes / OpenShift
      • Linux
      • Windows
      • Advanced Agent configuration
      • Use an HTTP/HTTPS proxy
      • Agent V1 (legacy)
      • Migrate Agent V1 to Agent V2
        • Linux
        • Docker
    • StackState CLI
      • CLI: sts
      • CLI: stac (deprecated)
      • Comparison between CLIs
    • Data management
      • Backup and Restore
        • Kubernetes backup
        • Linux backup
        • Configuration backup
      • Data retention
      • Clear stored data
  • 👤Use
    • Concepts
      • The 4T data model
      • Components
      • Relations
      • Health state
      • Layers, Domains and Environments
      • Perspectives
      • Anomaly detection
      • StackState architecture
    • StackState UI
      • Explore mode
      • Filters
      • Views
        • About views
        • Configure the view health
        • Create and edit views
        • Visualization settings
      • Perspectives
        • Topology Perspective
        • Events Perspective
        • Traces Perspective
        • Metrics Perspective
      • Timeline and time travel
      • Analytics
      • Keyboard shortcuts
    • Checks and monitors
      • Checks
      • Add a health check
      • Anomaly health checks
      • Monitors
      • Manage monitors
    • Problem analysis
      • About problems
      • Problem lifecycle
      • Investigate a problem
      • Problem notifications
    • Metrics
      • Telemetry streams
      • Golden signals
      • Top metrics
      • Add a telemetry stream
      • Browse telemetry
      • Set telemetry stream priority
    • Events
      • About events
      • Event notifications
      • Manage event handlers
    • Glossary
  • 🧩StackPacks
    • About StackPacks
    • Add-ons
      • Autonomous Anomaly Detector
      • Health Forecast
    • Integrations
      • About integrations
      • 💠StackState Agent V2
      • 💠AWS
        • AWS
        • AWS ECS
        • AWS X-ray
        • StackState/Agent IAM role: EC2
        • StackState/Agent IAM role: EKS
        • Policies for AWS
        • AWS (legacy)
        • Migrate AWS (legacy) to AWS
      • 💠Dynatrace
      • 💠Kubernetes
      • 💠OpenShift
      • 💠OpenTelemetry
        • About instrumentations
        • AWS NodeJS Instrumentation
        • Manual Instrumentation
          • Prerequisites
          • Tracer and span mappings
          • Relations between components
          • Span health state
          • Merging components
          • Code examples
      • 💠ServiceNow
      • 💠Slack
      • 💠Splunk
        • Splunk
        • Splunk Events
        • Splunk Health
        • Splunk Metrics
        • Splunk Topology
      • 💠VMWare vSphere
      • Apache Tomcat
      • Azure
      • Cloudera
      • Custom Synchronization
      • DotNet APM
      • Elasticsearch
      • Humio
      • Java APM
      • JMX
      • Logz.io
      • MySQL
      • Nagios
      • OpenMetrics
      • PostgreSQL
      • Prometheus
      • SAP
      • SCOM
      • SolarWinds
      • Static Health
      • Static Topology
      • Traefik
      • WMI
      • Zabbix
    • Develop your own StackPacks
  • 🔧Configure
    • Topology
      • Component actions
      • Identifiers
      • Topology naming guide
      • Topology sources
      • Create a topology manually
      • Configure topology synchronizations
      • Enable email event notifications
      • Send topology data over HTTP
      • Set the topology filtering limit
      • Use a proxy for event handlers
      • Use tags
      • Tune topology synchronization
      • Debug topology synchronization
    • Telemetry
      • Add telemetry during topology synchronization
      • Data sources
        • Elasticsearch
        • Prometheus mirror
      • Send events over HTTP
      • Send metrics data over HTTP
      • Set the default telemetry interval
      • Debug telemetry synchronization
    • Traces
      • Set up traces
      • Advanced configuration for traces
    • Health
      • Health synchronization
      • Send health data over HTTP
        • Send health data
        • Repeat Snapshots JSON
        • Repeat States JSON
        • Transactional Increments JSON
      • Debug health synchronization
    • Anomaly Detection
      • Export anomaly feedback
      • Scale the AAD up and down
      • The AAD status UI
    • Security
      • Authentication
        • Authentication options
        • File based
        • LDAP
        • Open ID Connect (OIDC)
        • KeyCloak
        • Service tokens
      • RBAC
        • Role-based Access Control
        • Permissions
        • Roles
        • Scopes
        • Subjects
      • Secrets management
      • Self-signed certificates
      • Set up a security backend for Linux
      • Set up a security backend for Windows
    • Logging
      • Kubernetes logs
      • Linux logs
      • Enable logging for functions
  • 📖Develop
    • Developer guides
      • Agent checks
        • About Agent checks
        • Agent check API
        • Agent check state
        • How to develop Agent checks
        • Connect an Agent check to StackState
      • Custom functions and scripts
        • StackState functions
        • Check functions
        • Component actions
        • Event handler functions
        • ID extractor functions
        • Mapping functions
        • Monitor functions
        • Propagation functions
        • Template functions
        • View health state configuration functions
      • Custom Synchronization StackPack
        • About the Custom Synchronization StackPack
        • How to customize elements created by the Custom Synchronization StackPack
        • How to configure a custom synchronization
      • Integrate external services
      • Mirroring Telemetry
      • Monitors
        • Create monitors
        • Monitor STJ file format
      • StackPack development
        • How to create a StackPack
        • Packaging
        • How to get a template file
        • How to make a multi-instance StackPack
        • Prepare a multi-instance provisioning script
        • Upload a StackPack file
        • Prepare a shared template
        • Customize a StackPack
        • Prepare instance template files
        • Prepare a StackPack provisioning script
        • Resources in a StackPack
        • StackState Common Layer
      • Synchronizations and templated files
    • Reference
      • StackState OpenAPI docs
      • StackState Template JSON (STJ)
        • Using STJ
        • Template functions
      • StackState Markup Language (STML)
        • Using STML
        • STML Tags
      • StackState Query Language (STQL)
      • StackState Scripting Language (STSL)
        • Scripting in StackState
        • Script result: Async
        • Script result: Streaming
        • Time in scripts
        • Script APIs
          • Async - script API
          • Component - script API
          • HTTP - script API
          • Prediction - script API
          • StackPack - script API
          • Telemetry - script API
          • Time - script API
          • Topology - script API
          • UI - script API
          • View - script API
    • Tutorials
      • Create a simple StackPack
      • Push data to StackState from an external system
      • Send events to StackState from an external system
      • Set up a mirror to pull telemetry data from an external system
Powered by GitBook
LogoLogo

Legal notices

  • Privacy
  • Cookies
  • Responsible disclosure
  • SOC 2/SOC 3
On this page
  • Overview
  • Kubernetes and OpenShift
  • Supported versions
  • Node sizing
  • Docker images
  • Storage
  • Ingress
  • Namespace resource limits
  • Linux
  • Server requirements
  • Size requirements
  • AWS requirements
  • Networking
  • Production deployment
  • Development/POC deployment
  • Port list per process
  • Client (browser)
  1. Setup
  2. Install StackState

Requirements

StackState Self-hosted v5.1.x

PreviousInstall StackStateNextKubernetes / OpenShift

Last updated 4 months ago

Overview

This page details the requirements for all supported installations of StackState:

Requirements for and the can be found at the bottom of the page.

Kubernetes and OpenShift

Supported versions

StackState can be installed on a Kubernetes or OpenShift cluster using the Helm charts provided by StackState. These Helm charts require Helm v3.x to install and are supported on:

  • Amazon Elastic Kubernetes Service (EKS): 1.21 to 1.28

  • Azure Kubernetes Service (AKS): 1.20 to 1.28

  • OpenShift: 4.8 to 4.10

Node sizing

For a standard deployment, the StackState Helm chart will deploy backend services in a redundant setup with 3 instances of each service. The number of nodes required for environments with out-of-the-box settings are listed below, note that these may change based on system tuning:

The recommended requirements include spare CPU/Memory capacity to ensure smooth application rolling update.

Requirements for the recommended high availability setup with backups enabled:

  • Node requirements: minimum 8 vCPUs, minimum 32GB memory

  • Total of 56 vCPUs available for StackState

  • Total of 120 GB memory available for StackState

  • Total of 2 TB disk space for data storing services (doesn't include disk space required for backups)

Requirements for the minimal high availability setup with backups enabled:

  • Node requirements: minimum 8 vCPUs, minimum 32GB memory

  • Total of 37 vCPUs available for StackState

  • Total of 98 GB memory available for StackState

  • Total of 2 TB disk space for data storing services (doesn't include disk space required for backups)

Optionally, a can be configured which has the requirements listed below.

Recommended setup

Requirements for the recommended non-high availability setup:

  • Node requirements: minimum 8 vCPUs, minimum 32GB memory

  • Total of 38 vCPUs available for StackState

  • Total of 90 GB memory available for StackState

  • Total of 850 GB disk space for data storing services

Minimal setup

Requirements for the minimal non-high availability setup:

  • Node requirements: minimum 8 vCPUs, minimum 32GB memory

  • Total of 25 vCPUs available for StackState

  • Total of 56 GB memory available for StackState

  • Total of 850 GB disk space for data storing services

Docker images

Storage

StackState uses persistent volume claims for the services that need to store data. The default storage class for the cluster will be used for all services unless this is overridden by values specified on the command line or in a values.yaml file. All services come with a pre-configured volume size that should be good to get you started, but can be customized later using variables as required.

Ingress

By default, the StackState Helm chart will deploy a router pod and service. This service's port 8080 is the only entry point that needs to be exposed via Ingress. You can access StackState without configuring Ingress by forwarding this port:

kubectl port-forward service/<helm-release-name>-distributed-router 8080:8080

When configuring Ingress, make sure to allow for large request body sizes (50MB) that may be sent occasionally by data sources like the StackState Agent or the AWS integration.

Namespace resource limits

It isn't recommended to set a ResourceQuota as this can interfere with resource requests. The resources required by StackState will vary according to the features used, configured resource limits and dynamic usage patterns, such as Deployment or DaemonSet scaling.

If it's necessary to set a ResourceQuota for your implementation, the namespace resource limit should be set to match the node sizing requirements. For example, using the recommended node sizing for virtual machines (6 nodes with 32GB memory, 8 vCPUs), the namespace resource limit should be 6*32GB = 192GB and 6*8 vCPUs = 48 vCPUs.

Linux

Server requirements

Operating system

OS
Release

Ubuntu

Bionic

Ubuntu

Xenial

Ubuntu

Trusty

Fedora

28 - 40

CentOS

7, Stream 8 - 9

Debian

Stretch

Red Hat

7 - 9.3

Amazon Linux

2

Java

OpenJDK 11.

Size requirements

Production setup

The StackState production setup runs on two machines and requires:

StackState node:

  • 32GB of RAM

  • 500GB disk space (available under /opt/stackstate)

  • 8 cores CPU

StackGraph node:

  • 24GB of RAM

  • 500GB disk space (available under /opt/stackstate)

  • 8 cores CPU

POC setup

The POC setup runs on a single node and requires:

  • 32GB of RAM

  • 500GB disk space (available under /opt/stackstate)

  • 8 cores CPU

Development setup

The development setup runs on a single node and requires:

  • 16GB of RAM

  • 500GB disk space (available under /opt/stackstate)

  • 4 cores CPU

AWS requirements

To meet StackState minimal requirements, the AWS instance type needs to have at least:

  • 4 CPU cores

  • 16GB of memory. For example, m5.xlarge.

The AWS CLI has to be installed on the EC2 instance that's running StackState.

Networking

All listed ports are TCP ports.

Production deployment

A production deployment separates StackState and StackState's database processes; StackGraph.

StackState has to be reachable on port 7070 by any supported browser. StackState port 7077 must be reachable from any system pushing data to StackState

StackGraph should be reachable by StackState on ports 2181, 8020, 15165, 16000, 16020, 50010.

The following ports can be opened for monitoring, but are also useful when troubleshooting:

  • StackState: 9010, 9011, 9020, 9021, 9022, 9023, 9024, 9025, 9026

  • StackGraph: 9001, 9002, 9003, 9004, 9005, 9006, 16010, 16030, 50070, 50075

Development/POC deployment

StackState has to be reachable on port 7070 by any supported browser. StackState port 7077 must be reachable from any system pushing data to StackState

The following ports can be opened for monitoring, but are also useful when troubleshooting: 9001, 9002, 9003, 9004, 9005, 9006, 9010, 9011, 9020, 9021, 9022, 9023, 9024, 9025, 9026, 16010, 16030, 50070, 50075

Port list per process

Detailed information about ports per process.

PROCESS
PORT LIST

Elasticsearch

9200: HTTP api

9300: Native api

HBase Master

16000: Master client API (needs to be open for clients)

16010: Master Web UI (optional)

HBase Region Server

16020: Region client API (needs to be open for clients)

16030: Region Web UI (optional)

HDFS DataNode

50010: Datanode API (needs to be open for clients)

50020: IPC api (communication within HDFS cluster)

50075: HTTP api (optional)

HDFS NameNode

8020: File system (needs to be open for clients)

50070: Web UI (optional)

Kafka

9092: Client port

Receiver

7077: HTTP Agent API (aka receiver API). When using the StackState Agent, data is sent to this endpoint.

StackGraph ProcessManager

5152: StackGraph ProcessManager, at the moment only from localhost

StackState

7070: HTTP api & user interface

7071: Admin API for health checks and admin operations. Typically you want to use this only from `localhost`

StackState ProcessManager

5154: StackState ProcessManager, at the moment only from localhost

Tephra Transaction service

15165: Client API

Zookeeper

2181: Client API

2888: Zookeeper peers (general communication), only when running a cluster

3888: Zookeeper peers (leader election), only when running a cluster

Client (browser)

To use the StackState GUI, you must use one of the following web browsers:

  • Chrome

  • Firefox

For a list of all Docker images used, see the .

For more details on the defaults used, see the page .

For more details on configuring Ingress, have a look at the page .

One of the following operating systems running Java. Check also the specific requirements for the :

🚀
image overview
Configure storage
Configure Ingress docs
StackState Agent V2 StackPack
non-high availability setup
Kubernetes and OpenShift
Linux
networking
StackState client (browser)
Production setup
POC setup
Development setup