Getting Started with Indigo RT — Installation to First RunIndigo RT is a robust real-time processing platform built to handle streaming data, low-latency computation, and high-throughput workloads across distributed environments. This guide walks you through everything from prerequisites to your first successful run, including installation, configuration, basic architecture, and troubleshooting tips to get you comfortable with Indigo RT quickly.

---

What is Indigo RT?

Indigo RT is a real-time processing framework designed for building, deploying, and scaling stream-processing applications. It supports a modular architecture with pluggable data connectors, an event-driven runtime, and built-in monitoring and persistence layers. Indigo RT is suited for use cases like financial tick processing, IoT telemetry ingestion, real-time analytics, and online machine learning inference.

---

Key concepts

• Node: A running instance of Indigo RT that executes operators.
• Operator: A unit of computation (map, filter, join, aggregate) applied to a stream.
• Stream: A continuous sequence of events/messages.
• Connector: A plugin used for input/output (Kafka, MQTT, HTTP, etc.).
• Topology: The graph of operators and streams composing your application.
• State: Local or distributed storage for maintaining operator context (e.g., windows, counters).

---

System requirements

• OS: Linux (Ubuntu 20.04+ recommended) or macOS. Windows via WSL2.
• CPU: 4+ cores for development; 8+ for production.
• RAM: 8 GB+ for development; 16+ GB recommended for production.
• Disk: SSD with 10 GB free for binaries and logs.
• Java: OpenJDK 11+ (if Indigo RT uses JVM) — adjust to actual runtime requirement.
• Network: Open ports for clustering (default 7000–7005, adjust in config).

---

Installation options

1. Docker (recommended for development)
2. Native package (DEB/RPM)
3. Kubernetes Helm chart (production)

---

Install with Docker (recommended)

Prerequisites: Docker 20.10+, docker-compose (optional).

1. Pull the Indigo RT image:

   
   docker pull indigo/indigo-rt:latest 

2. Run a single-node container:

   
   docker run -d --name indigo-rt  -p 8080:8080 -p 7000:7000  -v indigo-data:/var/lib/indigo  indigo/indigo-rt:latest 

3. Verify logs:

   
   docker logs -f indigo-rt 

---

Install natively (DEB/RPM)

1. Download the package from the official distribution.

2. Install: “`bash

   Debian/Ubuntu

   sudo dpkg -i indigo-rt_1.0.0_amd64.deb

RHEL/CentOS

sudo rpm -ivh indigo-rt-1.0.0.x86_64.rpm

3. Start service: ```bash sudo systemctl start indigo-rt sudo systemctl enable indigo-rt sudo journalctl -u indigo-rt -f 

---

Kubernetes deployment (production)

Use the Helm chart for clustering, statefulsets for storage, and configure a load balancer for the HTTP API.

1. Add Helm repo:

   
   helm repo add indigo https://charts.indigo.io helm repo update 

2. Install chart:

   
   helm install indigo indigo/indigo-rt -n indigo --create-namespace 

3. Check pods:

   
   kubectl get pods -n indigo 

---

Configuration essentials

Main config file (example: /etc/indigo/config.yaml):

• node:
  • id: node-1
  • port: 7000
• http:
  • port: 8080
• storage:
  • path: /var/lib/indigo
  • type: local|distributed
• connectors:
  • kafka: brokers: [“kafka:9092”]
• logging:
  • level: INFO

Adjust heap and GC settings for Java-based runtimes via environment variables or systemd unit files.

---

Create your first topology

1. Project setup: create a directory and initialize:

   
   mkdir my-indigo-app cd my-indigo-app indigo-cli init 

2. Define a simple topology (example in YAML or JSON):

topology:   name: sample-topology   sources:     - id: kafka-source       type: kafka       topic: events   operators:     - id: parse       type: map       function: parseJson     - id: filter       type: filter       predicate: "event.type == 'click'"     - id: count       type: windowed-aggregate       window: 60s       function: count   sinks:     - id: console       type: logger 

1. Deploy:

   
   indigo-cli deploy sample-topology.yaml --node http://localhost:8080 

---

Run and test

• Send test messages (Kafka example):

  
  kafka-console-producer --broker-list localhost:9092 --topic events <<EOF {"type":"click","user":"u1"} {"type":"view","user":"u2"} {"type":"click","user":"u3"} EOF 

• Check Indigo RT dashboard at http://localhost:8080 for topology status, metrics, and logs.
• View container logs:

  
  docker logs -f indigo-rt 

---

Monitoring and metrics

• Built-in metrics endpoint (Prometheus format) at /metrics.
• Exporter: Configure Prometheus to scrape Indigo RT.
• Dashboards: Use Grafana with example dashboards provided in the Helm chart.

---

Common first-run issues & fixes

• Node won’t start: check logs for port conflicts and Java heap OOM.
• Connector fails: verify network, broker addresses, and credentials.
• State not persisted after restart: confirm storage.path permissions and volume mounts.
• High GC pauses: increase heap or tune GC settings (G1GC for lower pause times).

---

Next steps

• Explore more operators (joins, enrichments, ML inference).
• Set up secure TLS between nodes and for connectors.
• Benchmarks: run load tests with sample data to size your cluster.
• Automate deployments with CI/CD (use indigo-cli deploy in pipelines).

---

If you want, I can provide: (a) a ready-to-deploy sample topology repo, (b) a tuned production Helm values.yaml, or © troubleshooting for a specific error you see. Which would you like?