AnyLog enables real-time visibility and management of distributed edge data, applications, and infrastructure. It transforms edge environments into scalable data tiers optimized for IoT, allowing organizations to extract insights across industries like manufacturing, utilities, oil & gas, smart cities, retail, robotics, and more.

• Documentation
• Support services — Grafana, PostgreSQL, MongoDB, Remote-GUI

docker-compose/
├── Makefile                          # Thin wrapper around deploy.sh
├── deploy.sh                         # Node lifecycle manager — works without make
├── README.md                         # This file
├── Deploy_PLC.md                     # PLC deployment guide
├── docker-makefiles/
│   ├── anylog-generic/
│   │   └── node_configs.env          # Config template — copy and customise per node
│   ├── anylog-master/
│   ├── anylog-operator/
│   ├── anylog-publisher/
│   ├── anylog-query/
│   ├── anylog-standalone-operator/
│   ├── anylog-standalone-publisher/
│   ├── build_docker_compose.sh       # Generates docker-compose.yaml from configs
│   ├── prep_configs.sh               # Pre-flight config validation
│   ├── docker-compose-template-base.yaml       # Linux template (host networking)
│   └── docker-compose-template-ports-base.yaml # Mac/Windows template (port mapping)
├── license-generator                  # code base for licnese verification + storage (Docker) 
│   ├── Dockerfile
│   ├── README.md
│   ├── deploy.sh
│   ├── docker-compose.yml
│   ├── license_key.sh
│   ├── requirements.txt
│   └── src
    │   ├── __init__.py
    │   └── license-server.py
└── support/                          # External services (Grafana, Postgres, MongoDB, etc.)
    └── README.md

Generated compose files land in docker-makefiles/docker-compose-files/ and are not committed to the repo.

Note: The Makefile is a thin wrapper — every target delegates to deploy.sh. If make is not available on your system (e.g. certain ARM/Qualcomm hardware), use bash deploy.sh directly with identical behaviour.

• Docker & Docker-Compose

# Install Docker on Ubuntu
sudo apt-get -y update
sudo apt-get install -y ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get -y update

sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin make git

# Grant non-root user permissions to use Docker
USER=`whoami`
sudo groupadd docker
sudo usermod -aG docker ${USER}
newgrp docker

• Clone the deployment repository

git clone https://github.com/AnyLog-co/docker-compose
cd docker-compose

• AnyLog is a private repository — request credentials for Docker login and your license key.

docker login -u anyloguser -p [Docker Login Passkey]

All AnyLog containers run the same image — configurations determine which services are enabled.

Both the short form (operator) and the full directory name (anylog-operator) are accepted — both tools resolve the alias automatically.

All commands are available via make or bash deploy.sh — choose whichever is available on your system.

Commands:
  login           Log into Docker Hub
  pull            Pull image from Docker Hub
  dry-run         Generate docker-compose.yaml (prints docker run command in manual mode)
  up              Start AnyLog instance
  down            Stop AnyLog instance
  clean           Stop and remove volumes
  clean-all       Stop, remove volumes and image
  logs            View container logs
  logs-f          Follow container logs
  attach          Attach to container (ctrl-d to detach)
  exec            Shell into container (anylog user)
  exec-root       Shell into container (root)
  full-test       Run test-status + test-node + test-network
  test-status     GET status from node
  test-node       Test node configuration
  test-network    Test network connectivity
  check-processes List active/inactive services
  check-vars      Show resolved variable values

Variables (make) / Options (deploy.sh):
  IS_MANUAL / --manual      Use docker run instead of docker compose (default: false)
  ANYLOG_TYPE / --type      Node type to deploy
  TAG         / --tag       Image tag                    (default: pre-develop)
  IMAGE       / --image     Image repository
  NODE_NAME   / --node-name Override container name
  TEST_CONN   / --test-conn ip:port for test commands    (default: auto-resolved)
  LICENSE_KEY / --license-key License key (skips acceptance form if set in config file; runs form if passed manually)
  PROMPT_LICENSE / --prompt-license Force the acceptance form even when a key is already saved (default: true)

• Unique ports: No two containers on the same machine can share ports. Set unique ANYLOG_SERVER_PORT and ANYLOG_REST_PORT per container.
• Unique node names: Each node must have a distinct NODE_NAME.
• Clusters: CLUSTER_NAME should be unique per operator unless HA is configured.
• License key: A valid LICENSE_KEY is required. Request one here.

Every up command validates a license before starting the node. The behavior depends on where the key comes from.

Resolution order

1. --license-key <key> flag (or LICENSE_KEY=<key> env var / make variable)
2. LICENSE_KEY= line in docker-makefiles/<type>/.env or node_configs.env
3. Interactive prompt (if a TTY is available)

If the key is found in the config file — deployment proceeds immediately. No prompts, no registration form, no network call to the license server.

If the key comes from manual input (flag or interactive prompt) — the full acceptance flow runs:

1. Displays LICENSE.txt for review
2. Prompts for name, email, and project
3. Asks for explicit yes/no acceptance of the license agreement
4. POSTs the registration to the AnyLog license server
5. Writes the accepted key back into the config file (LICENSE_KEY="<key>") so future deployments skip the form

Passing the key explicitly

# deploy.sh
bash deploy.sh up --type operator --license-key "<key>"

# make
make up ANYLOG_TYPE=operator LICENSE_KEY="<key>"

Setting the key in the config file (skips the form on all future runs)

# docker-makefiles/my-operator/node_configs.env
LICENSE_KEY="<key>"

--prompt-license / PROMPT_LICENSE

Forces the acceptance form even when a key is already saved, useful for re-registering under a new name or project:

bash deploy.sh up --type operator --prompt-license
make up ANYLOG_TYPE=operator PROMPT_LICENSE=true

For full control over node behavior, use a node_configs.env file.

1. Copy the config template

cp -r docker-makefiles/anylog-generic docker-makefiles/my-operator

2. Edit docker-makefiles/my-operator/node_configs.env — at minimum, update these:

   • NODE_TYPE — set to your desired node type
   • NODE_NAME — must be unique per node
   • COMPANY_NAME
   • ANYLOG_SERVER_PORT, ANYLOG_REST_PORT — must be unique per machine
   • LEDGER_CONN — IP:port of the master node
   • CLUSTER_NAME — unique per operator unless HA is enabled
   • LICENSE_KEY
   • DB_USER / DB_PASSWD (if using PostgreSQL)

3. Deploy

# via make
make up ANYLOG_TYPE=my-operator

# via deploy.sh (no make required)
bash deploy.sh up --type my-operator

4. Check status

make logs ANYLOG_TYPE=my-operator
bash deploy.sh logs --type my-operator

5. Attach to the node — press Enter twice once attached, ctrl-d to detach

make attach ANYLOG_TYPE=my-operator
bash deploy.sh attach --type my-operator

cp -r docker-makefiles/my-operator docker-makefiles/my-operator2
# Edit node_configs.env — update NODE_NAME, ports, CLUSTER_NAME
make up ANYLOG_TYPE=my-operator2
bash deploy.sh up --type my-operator2

When IS_MANUAL=true / --manual, the node is started with docker run --env-file rather than docker compose. This is useful on systems where docker compose is unavailable. The same node_configs.env file is used.

Running dry-run in manual mode prints the exact docker run command that will be executed — useful for inspection before committing:

make dry-run IS_MANUAL=true ANYLOG_TYPE=operator
bash deploy.sh dry-run --type operator --manual

To start:

# Generic
make up IS_MANUAL=true ANYLOG_TYPE=generic
bash deploy.sh up --type generic --manual

# Operator
make up IS_MANUAL=true ANYLOG_TYPE=operator
bash deploy.sh up --type operator --manual

# Master
make up IS_MANUAL=true ANYLOG_TYPE=master
bash deploy.sh up --type master --manual

Note: In manual mode the init container that pre-sets volume ownership does not run. Volume directories will be owned by root until AnyLog corrects permissions internally.

Debug mode starts a lightweight sidecar container alongside the AnyLog node. It shares the node's network stack, PID namespace, and data volumes, making it useful for diagnosing connectivity or inspecting files without touching the running node. Common network tools (ping, nc, curl, net-tools) are pre-installed.

make up-debug ANYLOG_TYPE=my-operator
bash deploy.sh up --type my-operator  # sidecar activated via --profile debug

# Shell into the sidecar
docker exec -it my-operator-debugger /bin/bash

make down-debug ANYLOG_TYPE=my-operator

The AnyLog container runs as the anylog user. To install tools or inspect system state without restarting:

make exec-root ANYLOG_TYPE=my-operator
bash deploy.sh exec-root --type my-operator
# node process keeps running — changes do not persist across restarts
apt-get update && apt-get install -y net-tools iputils-ping netcat-traditional

Test targets work independently of ANYLOG_TYPE — point them at any reachable node via TEST_CONN.

# Default (127.0.0.1 + REST port from config)
make test-status ANYLOG_TYPE=my-operator
bash deploy.sh test-status --type my-operator

# Target any node explicitly
make full-test TEST_CONN=192.168.1.10:32149
bash deploy.sh full-test --test-conn 192.168.1.10:32149

Port reference:

Docker Desktop uses port-based networking instead of network_mode: host, which may cause containers to advertise the Docker internal IP rather than the machine IP.

1. Enable host networking in Docker Desktop preferences.

2. Find your machine's local IP:

# Mac
ifconfig en0 | grep "inet "

# Windows
ipconfig

3. In node_configs.env, set OVERLAY_IP under the advanced section:

OVERLAY_IP=192.168.86.28

4. Optionally set TCP_BIND=true under advanced networking for stricter port binding.

5. Deploy:

make up ANYLOG_TYPE=my-operator
bash deploy.sh up --type my-operator

Docker restarts containers using in-memory state, not updated env files. To apply config changes on reboot:

Option 1 — Rebuild the container after updating configs:

make up ANYLOG_TYPE=my-operator
bash deploy.sh up --type my-operator

Option 2 — Use systemd to rebuild on boot:

# /etc/systemd/system/anylog-operator-redeploy.service
[Unit]
Description=Redeploy AnyLog Node After Reboot
After=network.target docker.service
Requires=docker.service

[Service]
WorkingDirectory=%h/docker-compose
ExecStart=/usr/bin/bash deploy.sh up --type my-operator
Restart=on-failure
User=%u

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable anylog-operator-redeploy.service

Note: Each node requires its own systemd service.

External services that work alongside AnyLog nodes are managed separately under support/.

cd support/
make up SERVICE=grafana
make list    # show all discovered services

See support/README.md for full documentation.