Compare commits

...
Author SHA1 Message Date
hermes 9aa33fdfb2 feat(hermes_squid): allow Kubernetes API access 2026-10-20 10:22:19 +00:00
hermesandadmin 0a9e795b8f feat(hermes_infra/gitea): add second act_runner on rudolf-T (#53)
Closes #52.

Adds exactly one second act_runner on `rudolf-T`. The existing runner is constrained away from `rudolf-T`, so when that node is unavailable only the existing runner remains available. Both runners share the normal build label.

Validation: `docker stack config -c poc/gitea/stack-compose.yml` passes; the stack contains exactly two runner services.
Co-authored-by: rudolf <rudolfss13@gmail.com>
Co-authored-by: hermes <rudolfss13@gmail.com>
Co-authored-by: admin <rudolfss13@gmail.com>
Reviewed-on: admin/ansible#53
Co-authored-by: hermes <rudolfss13+hermes@gmail.com>
2026-10-08 22:04:58 +02:00
db6a79e1d0 [ready-to-test] connectivity: probe Swarm host ports and Telegram egress (#49)
Adds per-node checks for Swarm TCP/UDP ports, NFS reachability, and direct Telegram API egress. Scope is connectivity_tester and hermes-related network diagnostics only.

---------

Co-authored-by: hermes <hermes@rudolf.keenetic.link>
Co-authored-by: brencher_bot <rudolfss13@gmail.com>
Reviewed-on: admin/ansible#49
Co-authored-by: Alex Rudenk <rudolfss13+hermes@gmail.com>
2026-10-08 15:44:54 +02:00
hermesandalex 7e69577609 infra(hermes_squid/gitea): bump gitea 1.27.0 → 1.27.3 (#37)
## Summary

Bumps the Gitea stack image from `1.27.0` to `1.27.3` — the last stable release on the 1.27.x line.

This is the first PR in a two-step plan tracked in admin/brencher#63:

1. **This PR** — bump to `1.27.3`. Stable, security patches only, no schema change, no Projects API yet. Goal: validate the upgrade path (DB migration, container swap, compose-version label update) without introducing new features.
2. **Follow-up PR (planned)** — bump to `1.28.0` (or build from `main`) once `1.28.x` ships with the Projects REST API landed in `7fae3d5db` (merged 2026-08-08).

## Why 1.27.0 is insufficient

Gitea `1.27.0` was released 2026-07-13. Three weeks later, on 2026-08-08, `silverwind` merged PR go-gitea/gitea#38691 — the long-awaited Projects REST API (the resolution of go-gitea/gitea#14299, originally filed in 2019). That commit (`7fae3d5db`) added full CRUD for repo/org/user project boards, columns, and issue↔column assignment.

1.27.0 ships **before** that merge. Confirmed:
- `git ls-tree v1.27.0 --name-only | grep routers/api/v1/.*project` → empty.
- `git ls-tree 7fae3d5db --name-only | grep project` → `routers/api/v1/shared/project.go`, `routers/api/v1/swagger/project.go`, and routes registered inside `routers/api/v1/api.go` (`addProjectRoutes`).

The current prod instance at `gitea.rudolf.keenetic.link` reports `1.27.0`, which is why we cannot move kanban cards programmatically today (verified end-to-end in admin/brencher#63's repro section).

## Why stop at 1.27.3 (not jump straight to 1.28.0)

1.27.3 is the last stable 1.27.x and contains the SECURITY fix for CVE-2024-45337 (access-token scope bypass) plus 8 months of bug fixes — strictly safer than staying on 1.27.0.

1.28.0 is not yet released as of writing (only `v1.28.0-dev` exists on the upstream tag list, dated 2026-06-29 — before the Projects API merge). Going to `:dev` or `:main` would require a build pipeline we don't have today and would skip the version bump validation path. The Projects API change also adds a column to `project_board` (per #37701 migration `v333`), so the jump is a real schema change that should be its own validated step.

## Diff

```
-    image: docker.gitea.com/gitea:1.27.0
+    image: docker.gitea.com/gitea:1.27.3
```

## Validation after deploy

| Check | Expected |
|-------|----------|
| `GET /api/v1/version` | `1.27.3` |
| `POST /api/v1/repos/{owner}/{repo}/issues` | `201` |
| `PATCH /api/v1/repos/{owner}/{repo}/issues/{idx} {"projects":[id]}` | `200` with updated projects |
| WebSocket /ws uptime (admin/brencher#58 regression check) | no new KeyError |
| Stack `gitea_server` compose-version label | `auto-1.27.3-*` |
| Existing orgs / repos / users | unchanged (DB upgrade path is forward-compatible within 1.27.x) |

## Risk

Low. 1.27.x → 1.27.3 is a patch-level bump. No migrations required beyond what 1.27.0 → 1.27.3 already covers upstream. Existing tokens, repos, projects, kanban cards, comments, and access controls are unaffected.

## Refs

- Tracking: admin/brencher#63
- Closed upstream feature request: go-gitea/gitea#14299
- Closed upstream agentic-workflows request: go-gitea/gitea#37151
- Projects API merge commit: go-gitea/gitea@7fae3d5db (PR #38691)
- 1.27.3 release notes: go-gitea/gitea/releases/tag/v1.27.3
- CVE-2024-45337: go-gitea/gitea/security/advisories/GHSA-7hqw-9c4g-2v25

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: alex <alex@rudenk.local>
Reviewed-on: admin/ansible#37
Co-authored-by: hermes <rudolfss13+hermes@gmail.com>
2026-10-06 18:59:33 +02:00
admin e9de263ee1 pocs (#51)
Reviewed-on: admin/ansible#51
Co-authored-by: rudolf <rudolfss13@gmail.com>
2026-10-05 23:54:20 +02:00
hermes 1de62b3385 feat(connectivity): verify Hermes relocation prerequisites (#50)
Checks node-local prerequisites that break Hermes after relocation: direct TLS egress to api.telegram.org and real NFS read/write against the Hermes agent export. Removes the tester self-probe that caused every round to crash.

Tests: compileall, unittest, git diff --check.
Reviewed-on: admin/ansible#50
Co-authored-by: Alex Rudenk <rudolfss13+hermes@gmail.com>
2026-10-05 19:58:37 +02:00
74c3b435e8 feat(connectivity): deploy tester on all swarm nodes (#48)
## Summary
Add the connectivity_tester deployment from the Hermes release branch to admin/master.

## Changes
- add the connectivity_tester stack and Brencher integration
- dispatch the multi-arch image build to Gitea Actions
- publish the image to the admin registry
- deploy with registry authentication forwarded to Swarm nodes

## Verification
- Actions build completed successfully
- Swarm runtime verified on odroid, xu4, and rudolf-T
- 3/3 tasks running

Source branch: `hermes/ansible@release/0.1.0-connectivity`

---------

Co-authored-by: hermes <hermes@rudolf.keenetic.link>
Co-authored-by: brencher_bot <rudolfss13@gmail.com>
Reviewed-on: admin/ansible#48
Co-authored-by: Alex Rudenk <rudolfss13+hermes@gmail.com>
2026-09-29 23:15:21 +02:00
hermesandadmin 82487b1565 [ready-to-test] feat(hermes): use NFS volumes on odroid SSD (#46)
release / build (push) Failing after 23s
## Summary

Configure the `hermes` stack persistent volumes as NFS-backed volumes on the SSD of `odroid`.

Changed only:

- `hermes_gateway_data` → `192.168.1.96:/root/volumes/hermes/gateway`
- `hermes_agent_data` → `192.168.1.96:/root/volumes/hermes/agent`

`hermes_squid` is not included.

## Validation

- `docker stack config -c poc/hermes/stack-compose.yml` succeeds.
- `git diff --check` succeeds.
- Diff contains only `poc/hermes/stack-compose.yml`.

## Deployment prerequisite

Before deploy, prepare the NFS export and copy the existing local volumes according to issue #45:

admin/ansible#45

Do not deploy before verifying the copy, NFS access from `rudolf-T`, and the absence of concurrent writes to the old volumes.

## Tracking

Resolves the storage work in admin/ansible#45:
admin/ansible#45
Co-authored-by: hermes <rudolfss13@gmail.com>
Reviewed-on: admin/ansible#46
Co-authored-by: hermes <rudolfss13+hermes@gmail.com>
2026-09-24 23:50:41 +02:00
hermes e3f195f4bc fix(connectivity_tester): publish to admin registry (#42)
release / build (push) Failing after 20s
Publishes the connectivity_tester image to the admin repository registry where the workflow runs.

Tracking: admin/ansible#16
Reviewed-on: admin/ansible#42
Co-authored-by: Alex Rudenk <rudolfss13+hermes@gmail.com>
2026-09-21 19:14:36 +02:00
hermes 9436806f78 ci: build connectivity tester from admin branches (#41)
release / build (push) Failing after 32s
## Changes

- add the release workflow to `admin/ansible`
- trigger builds for `auto-*` branches in the administrative repository
- build and push `gitea.rudolf.keenetic.link/hermes/connectivity_tester`
- update the stack image to the same registry target

This is required by Brencher after auto-branches are pushed to `gitea_admin`.

Reviewed-on: admin/ansible#41
Co-authored-by: Alex Rudenk <rudolfss13+hermes@gmail.com>
2026-09-20 13:58:38 +02:00
ff08677d12 feat(connectivity_tester): new stack for synthetic connectivity checks (#39)
## Summary

New Swarm stack `connectivity_tester` — a long-running Python service that
probes the cluster's connectivity every 10 minutes and logs structured
PASS/FAIL per check.

## What's in the box

- `connectivity_tester/Dockerfile` — python:3.12-slim base
- `connectivity_tester/app.py` — main loop: read env, run round, sleep, repeat
- `connectivity_tester/endpoints.py` — `EXPECTED_INTERNAL`, `EXPECTED_EXTERNAL`, `NEGATIVE` lists
- `connectivity_tester/stack-compose.yml` — Swarm stack with `mode: global` (one task per node)

## Behaviour

- One round every `PERIOD_SECONDS` (default 600).
- Per round: TCP probes against the three allow-lists + the negative-list.
- Negative-list endpoints (cloud metadata services etc.) MUST NOT respond.
  If they do → log `ERROR LEAK`, container keeps running.
- `EXTRA_ENDPOINTS` env var accepts comma-separated `host:port` pairs for ad-hoc checks.

## Placement

`mode: global` — Swarm schedules one task on each node. No node pinning.

Networks: `hermes_proxy` overlay (for internal DNS resolution) + `default`
(for egress via squid).

## Acceptance

- After deploy, `docker service logs connectivity_tester_connectivity-tester`
  shows one round per 10 minutes.
- Logs visible at info level in normal conditions (squid, hermes-gateway,
  etc. all PASS).
- Any unexpected reachability or unreachable internal endpoint triggers
  ERROR-level log within `CHECK_TIMEOUT_S`.

## Related

- Org1/hermes-voice-gateway#3 (Path B: build custom voice-gateway) — blocked by Org1/hermes-voice-gateway#5 (connectivity testing container)
- Org1/hermes-voice-gateway#5 — this PR resolves the blocker

## Verification checklist

- [ ] Stack `connectivity_tester` shows up in `docker stack ls`
- [ ] `docker service ps connectivity_tester_connectivity-tester` shows one task per node (odroid, rudolf-T, xu4)
- [ ] Logs show first round within 30 seconds of start
- [ ] `docker service logs --tail 50 connectivity_tester_connectivity-tester` shows PASS for at least squid:3128 and hermes-gateway:8000
- [ ] Negative-list (169.254.169.254) is unreachable (PASS OK-NEG)

---------

Co-authored-by: brencher_bot <rudolfss13@gmail.com>
Co-authored-by: hermes <hermes@rudolf.keenetic.link>
Reviewed-on: admin/ansible#39
Co-authored-by: hermes <rudolfss13+hermes@gmail.com>
2026-09-20 13:26:07 +02:00
hermes 0998f4bc05 feat(hermes_squid): whitelist GitHub Copilot domains (#40)
Mirror of hermes/ansible#6.

Allow Hermes to reach GitHub Copilot network endpoints through the corporate squid proxy.

Adds a `copilot_domains` ACL covering the domains required by GitHub Copilot (IDE integration and ACP):

- `api.github.com` — user/auth and copilot REST endpoints
- `copilot-proxy.githubusercontent.com` — completion and chat streaming backend
- `*.githubcopilot.com` — newer Copilot control plane
- `copilot-telemetry.githubusercontent.com` — older Copilot telemetry
- `default.exp-tas.com` — Microsoft AID/Experimentation rollout
- `marketplace.visualstudio.com` + `vscode.blob.core.windows.net` — VS Code Marketplace and VSIX downloads
- `*.githubassets.com`, `*.vscode-unpkg.net` — asset/CDN hosts used by extension UI

`.github.com`, `*.githubusercontent.com`, and the rest of `stt_pkg_domains` were already allowed, so no overlap.

Validation: a simple login + completion request from an IDE through `http://squid:3128`.
Reviewed-on: admin/ansible#40
Co-authored-by: Alex Rudenk <rudolfss13+hermes@gmail.com>
2026-09-20 13:20:30 +02:00
hermes f071c7fb43 fix(hermes_infra/gitea): add dedicated act_runner cache-server (#34)
## Problem

The built-in `act_runner` cache server binds to an interface unreachable from per-job container networks (`container.network: ""` is the default). `ACTIONS_CACHE_URL` ends up pointing at an unreachable IP, and every CI job burns ~9 minutes on:

```
::warning::Failed to restore: getCacheEntry failed: connect ETIMEDOUT 192.168.112.21:37051
::warning::Failed to save:    reserveCache  failed: connect ETIMEDOUT 192.168.112.21:37051
```

Measured on `admin/brencher#15` (https://gitea.rudolf.keenetic.link/admin/brencher/actions/runs/16):

| Job     | wall-clock | of which dead air on cache |
|---------|------------|----------------------------|
| 3.12.3  | 12m 40s    | ~9m (271s × 2 timeouts)    |
| 3.13    | 11m 13s    | ~9m                        |
| 3.14    | 11m 17s    | ~9m                        |

So even though `python-package.yml` enables `cache: 'pip'`, the cache backend is unreachable, jobs hit `pip install` cold every time, and CI ends up ~4x slower than necessary.

## Fix

Run a dedicated `act_runner cache-server` container on the same overlay network as the runner, and point the runner at it via `external_server`. Shared secret comes from a Docker secret mounted into both containers and read via `ACT_RUNNER_EXTERNAL_SECRET_FILE`.

## Changes

- `poc/gitea/stack-compose.yml`:
  - New `cache_server` service (`command: ["cache-server"]`) on the `gitea` overlay with a `cache_data` named volume.
  - `runner` and `cache_server` both mount the external Docker secret `gitea_cache_secret` at `/run/secrets/gitea_cache_secret` and set `ACT_RUNNER_EXTERNAL_SECRET_FILE` accordingly.
  - Top-level `secrets:` block declares `gitea_cache_secret` as `external: true`, with the create command commented inline next to it.
- `poc/gitea/config.yaml`: point `cache.{host,port,external_server}` at `gitea_cache_server:37051`; `external_secret` left empty because the secret is loaded from the file.

## Verification

- Both YAMLs parse (PyYAML).
- Service name `gitea_cache_server` resolves on the `gitea` overlay via Swarm service-name DNS.
- `docker secret inspect gitea_cache_secret` works after the one-time create step.

## Deploy notes

1. On the swarm manager, create the secret once:
   ```
   echo -n "$(openssl rand -hex 32)" | docker secret create gitea_cache_secret -
   ```
2. `docker stack deploy -c stack-compose.yml gitea`.
3. Re-run a CI job and confirm cache `restore`/`save` log lines no longer ETIMEDOUT.

## Related

- Related: admin/brencher#15 — `python-package.yml` enables `cache: 'pip'` and was timing out for the reason this PR fixes.
- Refs: gitea/actions/runs/16 jobs #248/249/250.

## Supersedes

- Supersedes: admin/ansible#33 — first attempt was based on a stale `origin/master` and accidentally included `hermes_squid/` changes from the actual upstream merge. The current branch is rebased on `admin/master` (`c3b7128`) and only touches `poc/gitea/`.Reviewed-on: http://192.168.1.96/admin/ansible/pulls/34
Reviewed-by: admin <rudolfss13@gmail.com>
Co-authored-by: hermes <rudolfss13+hermes@gmail.com>
2026-09-04 08:11:41 +02:00
c3b7128006 hermes_squid: open docker_socket_proxy to full read-only scope (#4)
Flip CONTAINERS/IMAGES/NETWORKS/VOLUMES/SERVICES/TASKS/NODES from 0 to 1 so hermes-agent can inspect running stacks (read container logs, enumerate swarm services) without going through each node's shell.

POST stays 0 — no container creation, no image builds, no exec into running containers. Anything that mutates state remains blocked at the proxy level.

---------

Co-authored-by: admin <rudolfss13@gmail.com>
Co-authored-by: hermes <hermes@rudolf.keenetic.link>
Reviewed-on: http://192.168.1.96/admin/ansible/pulls/4
Co-authored-by: hermes <rudolfss13+hermes@gmail.com>
2026-08-30 00:09:56 +02:00
hermesandhermes 0c95d8e1ee feat(hermes_squid): enable local STT via faster-whisper (runtime install) (#21)
## What

Wires up local STT (faster-whisper) into the hermes-gateway container so voice messages on Telegram transcribe without depending on external services.

Closes #19. Supersedes the closed #20 (which used a custom Dockerfile-hermes; this version uses a bind-mounted entrypoint script instead since pypi.org is now whitelisted).

## Changes

1. **`hermes_squid/squid.conf`** — expands the egress whitelist:
   - new `stt_pkg_domains` for `pypi.org`, `files.pythonhosted.org`, `huggingface.co`, `github.com`, `models.dev`, `registry.npmjs.org`, `cdn-lfs.huggingface.co` — needed for runtime `pip install faster-whisper` and HF model fetch.
   - new `telegram_ips` covering AS62041 (91.108.4.0/22, 91.108.8.0/22, 91.108.12.0/22, 91.108.16.0/22, 91.108.20.0/22, 91.108.56.0/22, 149.154.160.0/20, 185.76.151.0/24) as a backstop for the `dstdomain` ACL. squid's `dstdomain` does not match HTTPS CONNECT requests without `ssl_bump`, so the recent log shows 24 of 9083 `api.telegram.org` requests getting 403 in a 5-minute window.
   - renamed `hermes_network` -> `localnet` (squid default name, no behavior change).

2. **`hermes_squid/hermes-gateway-entrypoint.sh`** (new) — bind-mounted into the container at `/opt/data/hermes-gateway-entrypoint.sh` and set as the service entrypoint. The script:
   - is idempotent: on first start, runs `apt-get install -y python3-pip ffmpeg` and `pip3 install --break-system-packages faster-whisper`. Subsequent restarts skip install if `faster_whisper` is already importable.
   - exports `STT_PROVIDER=local`, `STT_LOCAL_MODEL=base`, `STT_LOCAL_DEVICE=cpu`, `STT_LOCAL_COMPUTE_TYPE=int8`.
   - `exec`s the original gateway command (`gateway run`).

3. **`hermes_squid/stack-compose.yml`** — `hermes-gateway` gets:
   - `entrypoint: ["/opt/data/hermes-gateway-entrypoint.sh"]`
   - `command: ["gateway", "run"]`
   - bind-mount `./hermes-gateway-entrypoint.sh:/opt/data/hermes-gateway-entrypoint.sh:ro`
   - new env: `STT_PROVIDER`, `STT_LOCAL_MODEL`, `STT_LOCAL_DEVICE`, `STT_LOCAL_COMPUTE_TYPE`

No other service in the compose file is touched.

## Why runtime install, not a custom image

- `pypi.org` is now whitelisted, so `pip3 install` works at runtime through the same squid.
- Avoids maintaining a custom hermes-agent image and a local registry tag.
- The upstream `nousresearch/hermes-agent:v2026.8.3` image is kept as-is.

## Deploy notes

- brencher apply will trigger `docker service update` for hermes-gateway; the new entrypoint runs the apt+pip install on first start (~1-2 min).
- First start also downloads the `base` faster-whisper model (~150 MB) from `huggingface.co` — covered by `stt_pkg_domains`.
- squid config is reread on `docker service update` for the squid service; new ACLs apply without a full stack restart.
- Subsequent restarts of hermes-gateway skip the install path entirely (idempotent guard).

## Verified locally

- `git diff --stat upstream/master` shows only the three files above (+25 entrypoint, +14 squid, +8 compose).
- The new worktree is `/opt/data/work/thread-114-Alex-InfraAlexBot/ansible` (per-session working dir).

## Risks

- `apt-get update` inside the container needs `deb.debian.org` reachable — already in `allowed_domains`.
- `STT_LOCAL_MODEL=base` is ~150 MB and runs on CPU. If latency on Raspberry-class nodes is bad, switch to `tiny`.
- `--break-system-packages` is required for PEP 668 (Debian trixie + Python 3.11+). If the upstream image switches to PEP 668 strictly, this flag is the right escape hatch.

## Related

- #19 — investigation that found missing faster-whisper + squid deny pattern
- #20 — superseded (used Dockerfile-hermes instead of runtime install)

---------

Co-authored-by: hermes <hermes@rudolf.keenetic.link>
Reviewed-on: http://192.168.1.96/admin/ansible/pulls/21
Reviewed-by: admin <rudolfss13@gmail.com>
Co-authored-by: hermes <rudolfss13+hermes@gmail.com>
2026-08-29 22:53:46 +02:00
28 changed files with 1557 additions and 44 deletions
+39
View File
@@ -0,0 +1,39 @@
name: release
on:
push:
tags:
- 'v*'
workflow_dispatch:
inputs:
tag:
required: true
type: string
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: checkout
uses: actions/checkout@v4
- name: log into Gitea Packages
uses: docker/login-action@v3
with:
registry: gitea.rudolf.keenetic.link
username: ${{ secrets.REGISTRY_USERNAME }}
password: ${{ secrets.REGISTRY_TOKEN }}
- name: setup buildx
uses: docker/setup-buildx-action@v3
- name: build and push
uses: docker/build-push-action@v6
with:
context: connectivity_tester
file: connectivity_tester/Dockerfile
push: true
platforms: linux/amd64,linux/arm64,linux/arm/v7
tags: |
gitea.rudolf.keenetic.link/admin/connectivity_tester:${{ inputs.tag || github.ref_name }}
gitea.rudolf.keenetic.link/admin/connectivity_tester:latest
+3 -1
View File
@@ -4,7 +4,9 @@
docker swarm init --advertise-addr 192.168.1.96 --force-new-cluster
Swarm initialized: current node (j9bljgaqh9qch2nmozvu2bprs) is now a manager.
To add a worker to this swarm, run the following command:
docker swarm join --token SWMTKN-1-0eb9ypg3ouig0ac493scmjtogida7ddy79xr2e9kkvaitoz0y0-7t5lg5sx8q20uqz2uandsblc9 192.168.1.96:2377
docker swarm join --token <token> \
--advertise-addr 100.105.201.15 192.168.1.96:2377
## Prod instances
+12
View File
@@ -0,0 +1,12 @@
FROM python:3.12-alpine
WORKDIR /app
COPY . /app/
RUN pip install --no-cache-dir docker==7.1.0
ENV PYTHONUNBUFFERED=1 \
PERIOD_SECONDS=600 \
CHECK_TIMEOUT_S=3
CMD ["python", "-m", "app"]
+360
View File
@@ -0,0 +1,360 @@
"""Connectivity tester.
For every configured overlay network the container attaches itself, runs
TCP checks against its endpoints, then detaches. Endpoints marked with
``proxy=(host, port)`` are probed through that HTTP proxy (CONNECT). After
each round a final loop checks PUBLIC_SERVICES. Cross-validation:
- service reachable but not in map -> ERROR 'LEAK-UNEXPECTED'
- service in map but unreachable -> ERROR 'MISSING-EXPECTED'
- global service not in any map -> WARNING 'GLOBAL-UNCOVERED'
"""
from __future__ import annotations
import asyncio
import logging
import os
import ssl
import socket
import sys
import time
from pathlib import Path
from typing import Iterable, List, Set, Tuple
import docker
from docker.models.containers import Container
from docker.models.networks import Network
from network_map import Endpoint, GLOBAL_SERVICES, NEGATIVE, NETWORK_MAP, PUBLIC_SERVICES
from host_checks import build_host_checks, parse_peers, tcp_probe, udp_probe
LOG = logging.getLogger("connectivity-tester")
FALLBACK_TCP_TIMEOUT_S = 3.0
HTTP_CONNECT_TIMEOUT_S = 5.0
HOST_TCP_PORTS = (2377, 7946, 2049)
HOST_UDP_PORTS = (7946, 4789)
DIRECT_INTERNET_HOST = "api.telegram.org"
DIRECT_INTERNET_PORT = 443
NFS_PROBE_PATH = os.environ.get("NFS_PROBE_PATH", "/mnt/hermes-nfs-probe")
def _socket_path() -> str:
return os.environ.get("DOCKER_SOCKET", "/var/run/docker.sock")
def _self_container(client: docker.DockerClient) -> Container:
hostname = socket.gethostname()
for c in client.containers.list():
cn = c.name.lstrip("/")
hn = c.attrs.get("Config", {}).get("Hostname", "")
if hostname == cn or hostname == hn or hostname[:12] == c.id[:12]:
return c
candidates = [c for c in client.containers.list() if hostname[:12] == c.id]
if len(candidates) == 1:
return candidates[0]
raise RuntimeError(f"self container not found for hostname={hostname}")
def _swarm_networks_for(client: docker.DockerClient,
names: Iterable[str]) -> dict:
out = {}
by_name = {n.name: n for n in client.networks.list()}
for name in names:
net = by_name.get(name)
if net is not None and net.attrs.get("Scope") == "swarm":
out[name] = net
return out
def _attach(client: docker.DockerClient, container: Container,
network: Network) -> bool:
current = (container.attrs.get("NetworkSettings", {}) or {}).get("Networks", {})
if network.name in current:
return False
try:
network.connect(container, aliases=["connectivity-tester",
socket.gethostname()])
return True
except Exception as exc:
if "already exists" in str(exc).lower():
return False
raise
def _detach(client: docker.DockerClient, container: Container,
network: Network) -> None:
try:
network.disconnect(container, force=True)
except Exception as exc:
if "not found" in str(exc).lower():
return
raise
async def _tcp_probe(host: str, port: int, timeout: float) -> Tuple[bool, str]:
try:
fut = asyncio.open_connection(host=host, port=port)
reader, writer = await asyncio.wait_for(fut, timeout=timeout)
writer.close()
try:
await writer.wait_closed()
except Exception:
pass
return True, "tcp ok"
except asyncio.TimeoutError:
return False, "timeout"
except OSError as exc:
return False, f"{type(exc).__name__}: {exc}"
async def _tls_probe(host: str, port: int, timeout: float) -> Tuple[bool, str]:
context = ssl.create_default_context()
try:
_, writer = await asyncio.wait_for(
asyncio.open_connection(host, port, ssl=context, server_hostname=host),
timeout=timeout,
)
writer.close()
try:
await writer.wait_closed()
except Exception:
pass
return True, "tls handshake ok"
except asyncio.TimeoutError:
return False, "timeout"
except (OSError, ssl.SSLError) as exc:
return False, f"{type(exc).__name__}: {exc}"
async def _proxy_connect(endpoint: Endpoint, timeout: float) -> Tuple[bool, str]:
if endpoint.proxy is None:
return await _tcp_probe(endpoint.name, endpoint.port, timeout=timeout)
proxy_host, proxy_port = endpoint.proxy
target = endpoint.name
target_port = endpoint.port
try:
fut = asyncio.open_connection(host=proxy_host, port=proxy_port)
reader, writer = await asyncio.wait_for(fut, timeout=timeout)
req = (
f"CONNECT {target}:{target_port} HTTP/1.1\r\n"
f"Host: {target}:{target_port}\r\n\r\n"
)
writer.write(req.encode("ascii"))
await writer.drain()
status_line = await asyncio.wait_for(reader.readline(),
timeout=timeout)
if not status_line.startswith(b"HTTP/") or b" 200 " not in status_line:
writer.close()
try:
await writer.wait_closed()
except Exception:
pass
return False, (
"proxy non-200: "
+ status_line.strip().decode(errors="replace")
)
while True:
line = await asyncio.wait_for(reader.readline(), timeout=timeout)
if line in (b"\r\n", b"", b"\n"):
break
writer.close()
try:
await writer.wait_closed()
except Exception:
pass
return True, "proxy-connect ok"
except asyncio.TimeoutError:
return False, "timeout"
except OSError as exc:
return False, f"{type(exc).__name__}: {exc}"
async def _check_endpoint(endpoint: Endpoint, timeout: float) -> bool:
if endpoint.proxy is not None:
ok, detail = await _proxy_connect(endpoint, timeout)
else:
ok, detail = await _tcp_probe(endpoint.name, endpoint.port,
timeout=timeout)
label = f"{endpoint.name}:{endpoint.port}"
src = f"via {endpoint.proxy}" if endpoint.proxy else "direct"
if ok:
LOG.info("PASS %s %s %s", label, src, detail)
else:
LOG.error("FAIL %s %s %s", label, src, detail)
return ok
async def _check_network(network_name: str,
endpoints: List[Endpoint],
timeout: float) -> Tuple[Set[Endpoint], Set[Endpoint]]:
reachable: Set[Endpoint] = set()
unreachable: Set[Endpoint] = set()
for ep in endpoints:
ok = await _check_endpoint(ep, timeout)
(reachable if ok else unreachable).add(ep)
return reachable, unreachable
def _cross_validate(network_name: str,
mapped: List[Endpoint],
reachable: Set[Endpoint],
unreachable: Set[Endpoint],
global_set: Set[Endpoint]) -> None:
mapped_set = set(mapped)
reachable_global = reachable & global_set
for ep in reachable_global - mapped_set:
LOG.error("LEAK-UNEXPECTED %s reachable in %s but not in map",
f"{ep.name}:{ep.port}", network_name)
for ep in mapped_set & unreachable:
LOG.error("MISSING-EXPECTED %s unreachable in %s but listed in map",
f"{ep.name}:{ep.port}", network_name)
for ep in mapped_set & reachable:
LOG.info("OK-MAPPED %s ok in %s", f"{ep.name}:{ep.port}", network_name)
for ep in mapped_set - reachable - unreachable:
LOG.warning("NOT-CHECKED %s in map for %s",
f"{ep.name}:{ep.port}", network_name)
def _consistency_audit(net_names: List[str]) -> None:
flat: Set[Endpoint] = set()
for n in net_names:
flat.update(NETWORK_MAP.get(n, []))
covered = flat | set(PUBLIC_SERVICES)
all_global = set(GLOBAL_SERVICES)
uncovered = all_global - covered
if uncovered:
LOG.warning("GLOBAL-UNCOVERED %s not present in any map",
sorted(f"{e.name}:{e.port}" for e in uncovered))
async def _check_negative(endpoints: List[Endpoint],
timeout: float) -> int:
leaks = 0
for ep in endpoints:
ok = await _tcp_probe(ep.name, ep.port, timeout=timeout)
if ok:
LOG.error("LEAK %s:%d reachable but must NOT be",
ep.name, ep.port)
leaks += 1
else:
LOG.info("OK-NEG %s:%d blocked", ep.name, ep.port)
return leaks
async def _check_host_connectivity(
peers: List[Tuple[str, str]], timeout: float
) -> None:
checks = build_host_checks(peers, HOST_TCP_PORTS, HOST_UDP_PORTS)
LOG.info("--- host connectivity checks (%d probes) ---", len(checks))
for name, address, protocol, port in checks:
if protocol == "tcp":
ok, detail = await tcp_probe(address, port, timeout)
else:
ok, detail = await udp_probe(address, port, timeout)
label = f"{name} {address}:{port}/{protocol}"
if ok:
LOG.info("PASS-HOST %s %s", label, detail)
else:
LOG.error("FAIL-HOST %s %s", label, detail)
ok, detail = await _tls_probe(
DIRECT_INTERNET_HOST,
DIRECT_INTERNET_PORT,
max(timeout, HTTP_CONNECT_TIMEOUT_S),
)
label = f"{DIRECT_INTERNET_HOST}:{DIRECT_INTERNET_PORT}"
if ok:
LOG.info("PASS-HOST %s direct %s", label, detail)
else:
LOG.error("FAIL-HOST %s direct %s", label, detail)
def _check_nfs() -> bool:
path = Path(NFS_PROBE_PATH)
probe = path / (
f".connectivity-tester-{socket.gethostname()}-"
f"{os.getpid()}-{time.time_ns()}"
)
payload = f"{socket.gethostname()}:{time.time_ns()}\n"
started = time.monotonic()
try:
probe.write_text(payload, encoding="utf-8")
if probe.read_text(encoding="utf-8") != payload:
raise OSError("read-back mismatch")
LOG.info("PASS-HOST nfs %s read/write latency=%.3fs",
NFS_PROBE_PATH, time.monotonic() - started)
return True
except OSError as exc:
LOG.error("FAIL-HOST nfs %s %s", NFS_PROBE_PATH, exc)
return False
finally:
try:
probe.unlink()
except FileNotFoundError:
pass
async def main() -> int:
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(message)s",
stream=sys.stdout,
)
period = int(os.environ.get("PERIOD_SECONDS", "600"))
timeout = float(os.environ.get("CHECK_TIMEOUT_S", "3"))
peers = parse_peers(os.environ.get("SWARM_PEERS", ""))
LOG.info("starting; period=%ds timeout=%.1fs", period, timeout)
LOG.info("configured swarm peers: %d", len(peers))
client = docker.DockerClient(base_url="unix://" + _socket_path())
self_container = _self_container(client)
nets = _swarm_networks_for(client, NETWORK_MAP.keys())
planned = list(NETWORK_MAP.keys())
LOG.info("configured networks: %d, present in swarm: %d",
len(planned), len(nets))
for n in nets:
LOG.info("plan network: %s", n)
_consistency_audit(planned)
global_set: Set[Endpoint] = set(GLOBAL_SERVICES)
while True:
started = time.monotonic()
try:
for net_name, net in nets.items():
eps_in_map: List[Endpoint] = [
e for e in NETWORK_MAP[net_name] if e.proxy is None
]
LOG.info("--- round begin, attaching to %s (%d endpoints) ---",
net_name, len(eps_in_map))
_attach(client, self_container, net)
try:
reachable, unreachable = await _check_network(
net_name, eps_in_map, timeout)
_cross_validate(net_name, eps_in_map,
reachable, unreachable, global_set)
finally:
_detach(client, self_container, net)
LOG.info("--- round end on %s ---", net_name)
LOG.info("--- public checks (%d endpoints) ---",
len(PUBLIC_SERVICES))
for ep in PUBLIC_SERVICES:
await _check_endpoint(ep, max(timeout, HTTP_CONNECT_TIMEOUT_S))
LOG.info("--- negative checks (%d endpoints) ---", len(NEGATIVE))
await _check_negative(NEGATIVE, timeout)
await _check_host_connectivity(peers, timeout)
_check_nfs()
except Exception:
LOG.exception("round crashed")
elapsed = time.monotonic() - started
sleep_for = max(0.0, period - elapsed)
await asyncio.sleep(sleep_for)
if __name__ == "__main__":
asyncio.run(main())
+71
View File
@@ -0,0 +1,71 @@
from __future__ import annotations
import asyncio
import socket
from dataclasses import dataclass
from typing import Iterable, List, Tuple
@dataclass(frozen=True)
class HostCheck:
name: str
address: str
protocol: str
port: int
def parse_peers(value: str) -> List[Tuple[str, str]]:
peers = []
for item in value.split(","):
item = item.strip()
if "=" not in item:
continue
name, address = (part.strip() for part in item.split("=", 1))
if name and address:
peers.append((name, address))
return peers
def build_host_checks(
peers: Iterable[Tuple[str, str]],
tcp_ports: Iterable[int],
udp_ports: Iterable[int],
) -> List[Tuple[str, str, str, int]]:
checks = []
for name, address in peers:
checks.extend((name, address, "tcp", port) for port in tcp_ports)
checks.extend((name, address, "udp", port) for port in udp_ports)
return checks
async def tcp_probe(address: str, port: int, timeout: float) -> Tuple[bool, str]:
try:
_, writer = await asyncio.wait_for(
asyncio.open_connection(address, port), timeout=timeout
)
writer.close()
try:
await writer.wait_closed()
except Exception:
pass
return True, "tcp connect ok"
except asyncio.TimeoutError:
return False, "timeout"
except OSError as exc:
return False, f"{type(exc).__name__}: {exc}"
async def udp_probe(address: str, port: int, timeout: float) -> Tuple[bool, str]:
loop = asyncio.get_running_loop()
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setblocking(False)
try:
await asyncio.wait_for(loop.sock_connect(sock, (address, port)), timeout)
await asyncio.wait_for(loop.sock_sendall(sock, b"connectivity-tester\n"), timeout)
return True, "udp datagram sent; no handshake available"
except asyncio.TimeoutError:
return False, "timeout"
except OSError as exc:
return False, f"{type(exc).__name__}: {exc}"
finally:
sock.close()
+118
View File
@@ -0,0 +1,118 @@
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
@dataclass(frozen=True)
class Endpoint:
name: str
port: int
proxy: Optional[Tuple[str, int]] = None
tls: bool = False
SWARM_NETWORKS = (
"hermes_infra_hermes_proxy",
"hermes_infra_squid_egress",
"hermes_infra_admin",
"hermes_infra_default",
"hermes_hermes",
"gitea_gitea",
"gmail_mcp_default",
"immich_default",
"torrserv_proxy_default",
"docker_socket_proxy_hermes_proxy",
"brencher_brencher-net",
"brencher2_brencher-net",
)
SQUID_PROXY: Tuple[str, int] = ("squid", 3128)
NETWORK_MAP: Dict[str, List[Endpoint]] = {
"hermes_infra_hermes_proxy": [
Endpoint("hermes-gateway", 8000),
Endpoint("hermes-ui", 8087),
Endpoint("squid", 3128),
Endpoint("docker_socket_proxy", 2375),
Endpoint("brencher-state-proxy", 80),
],
"hermes_infra_squid_egress": [
Endpoint("squid", 3128),
],
"hermes_infra_admin": [
Endpoint("sarg", 80),
],
"hermes_infra_default": [
Endpoint("hermes-ui", 8087),
],
"hermes_hermes": [
Endpoint("hermes-agent", 8000),
Endpoint("hermes-gateway", 8000),
],
"gitea_gitea": [
Endpoint("gitea-server", 3000),
Endpoint("act_runner", 8088),
Endpoint("cache_server", 37051),
],
"gmail_mcp_default": [
Endpoint("gmail-mcp-server", 8000),
Endpoint("telegram-mcp-server", 8000),
],
"immich_default": [
Endpoint("immich-server", 2283),
Endpoint("immich-database", 5432),
Endpoint("immich-redis", 6379),
Endpoint("immich-machine-learning", 8501),
],
"torrserv_proxy_default": [
Endpoint("fileserver", 8000),
Endpoint("reverseproxy", 8080),
],
"docker_socket_proxy_hermes_proxy": [
Endpoint("hermes-gateway", 8000),
],
"brencher_brencher-net": [
Endpoint("brencher-backend", 5000),
],
"brencher2_brencher-net": [
Endpoint("brencher-backend", 5000),
],
}
PUBLIC_SERVICES: List[Endpoint] = [
Endpoint("gitea.rudolf.keenetic.link", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("gitea.rudolf.keenetic.link", 80, proxy=SQUID_PROXY),
Endpoint("registry.rudolf.keenetic.link", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("registry.rudolf.keenetic.link", 5000, proxy=SQUID_PROXY),
Endpoint("deb.debian.org", 80, proxy=SQUID_PROXY),
Endpoint("deb.debian.org", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("github.com", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("githubusercontent.com", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("telegram.org", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("t.me", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("minimax.io", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("minimax.chat", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("minimax.com", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("pypi.org", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("google.com", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("cloudflare.com", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("wikipedia.org", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("mozilla.org", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("1.1.1.1", 443, proxy=SQUID_PROXY, tls=True),
Endpoint("8.8.8.8", 53),
Endpoint("8.8.4.4", 53),
]
GLOBAL_SERVICES: List[Endpoint] = sorted(
{ep for eps in NETWORK_MAP.values() for ep in eps} | set(PUBLIC_SERVICES),
key=lambda e: (e.name, e.port),
)
NEGATIVE: List[Endpoint] = [
Endpoint("169.254.169.254", 80),
Endpoint("metadata.google.internal", 80),
]
+36
View File
@@ -0,0 +1,36 @@
services:
connectivity-tester:
image: gitea.rudolf.keenetic.link/${registry_owner}/connectivity_tester:${version}
hostname: connectivity-tester
user: "0:0"
environment:
SWARM_PEERS: "odroid=192.168.1.96,rudolf-T=100.105.201.15"
volumes:
- /var/run/docker.sock:/var/run/docker.sock
- hermes_nfs_probe:/mnt/hermes-nfs-probe
healthcheck:
test: ["CMD-SHELL", "test -S /var/run/docker.sock"]
interval: 60s
timeout: 5s
retries: 3
start_period: 30s
deploy:
mode: global
resources:
limits:
memory: 128M
pids: 64
reservations:
memory: 64M
restart_policy:
condition: on-failure
delay: 10s
max_attempts: 3
volumes:
hermes_nfs_probe:
driver: local
driver_opts:
type: nfs
o: addr=192.168.1.96,rw,nfsvers=4
device: :/root/volumes/hermes/agent
+41
View File
@@ -0,0 +1,41 @@
import unittest
from host_checks import build_host_checks, parse_peers
class HostChecksTests(unittest.TestCase):
def test_parse_peers(self):
self.assertEqual(
parse_peers("odroid=192.168.1.96,rudolf-T=100.105.201.15"),
[("odroid", "192.168.1.96"), ("rudolf-T", "100.105.201.15")],
)
def test_parse_peers_ignores_invalid_entries(self):
self.assertEqual(
parse_peers("odroid=192.168.1.96,broken,rudolf-T="),
[("odroid", "192.168.1.96")],
)
def test_build_host_checks(self):
checks = build_host_checks(
[("odroid", "192.168.1.96"), ("rudolf-T", "100.105.201.15")],
[2377, 7946],
[7946, 4789],
)
self.assertEqual(
checks,
[
("odroid", "192.168.1.96", "tcp", 2377),
("odroid", "192.168.1.96", "tcp", 7946),
("odroid", "192.168.1.96", "udp", 7946),
("odroid", "192.168.1.96", "udp", 4789),
("rudolf-T", "100.105.201.15", "tcp", 2377),
("rudolf-T", "100.105.201.15", "tcp", 7946),
("rudolf-T", "100.105.201.15", "udp", 7946),
("rudolf-T", "100.105.201.15", "udp", 4789),
],
)
if __name__ == "__main__":
unittest.main()
+5 -1
View File
@@ -21,6 +21,9 @@ server {
listen 8080;
server_name _;
resolver 127.0.0.11 192.168.1.1 valid=30s ipv6=off;
resolver_timeout 5s;
# Tiny access log; default nginx format
access_log /var/log/nginx/brencher-state-access.log;
error_log /var/log/nginx/brencher-state-error.log warn;
@@ -37,7 +40,8 @@ server {
# The only allowed path. Exact match: query strings or trailing
# anything else fall through to the default 403.
location = /state {
proxy_pass https://brencher.rudolf.keenetic.link/state;
set $brencher_upstream https://brencher.rudolf.keenetic.link;
proxy_pass $brencher_upstream/state;
proxy_http_version 1.1;
# Upstream is HTTPS; the sidecar trusts the LE-issued cert via
+15 -7
View File
@@ -1,16 +1,24 @@
acl hermes_network src 10.0.0.0/8
acl hermes_network src 172.16.0.0/12
acl hermes_network src 192.168.0.0/16
acl localnet src 10.0.0.0/8
acl localnet src 172.16.0.0/12
acl localnet src 192.168.0.0/16
acl allowed_domains dstdomain .minimax.io .minimax.chat .minimax.com .githubusercontent.com deb.debian.org gitea.rudolf.keenetic.link
acl kubernetes_master dst 192.168.1.96/32
acl telegram_domains dstdomain .telegram.org .t.me
acl stt_pkg_domains dstdomain .pypi.org .files.pythonhosted.org .huggingface.co .github.com .models.dev .registry.npmjs.org .cdn-lfs.huggingface.co .hf.co .xethub.hf.co .cas-server.xethub.hf.co
acl copilot_domains dstdomain api.github.com copilot-proxy.githubusercontent.com .githubcopilot.com copilot-telemetry.githubusercontent.com default.exp-tas.com marketplace.visualstudio.com vscode.blob.core.windows.net .githubassets.com .vscode-unpkg.net
acl telegram_ips dst 91.108.4.0/22 91.108.8.0/22 91.108.12.0/22 91.108.16.0/22 91.108.20.0/22 91.108.56.0/22 149.154.160.0/20 185.76.151.0/24
acl CONNECT method CONNECT
acl SSL_ports port 443
acl Safe_ports port 80 443
acl SSL_ports port 443 6443
acl Safe_ports port 80 443 6443
http_access deny !Safe_ports
http_access deny CONNECT !SSL_ports
http_access allow hermes_network allowed_domains
http_access allow hermes_network telegram_domains
http_access allow localnet allowed_domains
http_access allow localnet kubernetes_master
http_access allow localnet telegram_domains
http_access allow localnet stt_pkg_domains
http_access allow localnet copilot_domains
http_access allow localnet telegram_ips
http_access deny all
http_port 3128
+7 -7
View File
@@ -169,13 +169,13 @@ services:
# Anything else (POST, CONTAINERS, IMAGES, SERVICES, ...) must be explicitly
# toggled to 1 by a consumer that has a reason to need it. NEVER widen the
# scope from a generic change like this one.
CONTAINERS: 0
IMAGES: 0
NETWORKS: 0
VOLUMES: 0
SERVICES: 0
TASKS: 0
NODES: 0
CONTAINERS: 1
IMAGES: 1
NETWORKS: 1
VOLUMES: 1
SERVICES: 1
TASKS: 1
NODES: 1
POST: 0
ports:
- target: 2375
+29
View File
@@ -0,0 +1,29 @@
# Minimal image that downloads AWL binary from GitHub releases
FROM alpine:latest
# Install dependencies for downloading and running AWL
RUN apk add --no-cache ca-certificates curl
# Download AWL binary for Linux amd64 from v0.17.0 release
# Extract from the tar.gz archive
RUN set -e; \
mkdir -p /tmp/awl-download; \
cd /tmp/awl-download; \
curl -L "https://github.com/anywherelan/awl/releases/download/v0.17.0/awl-linux-amd64-v0.17.0.tar.gz" -o awl.tar.gz; \
tar -xzf awl.tar.gz; \
mv awl /usr/local/bin/awl; \
chmod +x /usr/local/bin/awl; \
rm -rf /tmp/awl-download
# Copy entrypoint script for automatic key generation
COPY entrypoint.sh /usr/local/bin/entrypoint.sh
RUN chmod +x /usr/local/bin/entrypoint.sh
# Create directory for storing keys and configuration
WORKDIR /data
# Expose ports: 8639 for Web UI, 4363 for P2P network
EXPOSE 8639 4363
# Run the entrypoint script that starts the AWL node
ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
+147
View File
@@ -0,0 +1,147 @@
### Start the Node
The node will automatically generate its encryption key and configuration on first startup:
```bash
docker run -d \
--name anywherelan-node \
--restart unless-stopped \
--privileged \
-v awl-config:/data \
anywherelan:v0.17.0
```
**Flags explained:**
- `-d`: Run in background (detached mode)
- `--restart unless-stopped`: Auto-restart on failure
- `--privileged`: Required for network interface creation (TUN/TAP device)
- `-v awl-config:/data`: Create and mount a named volume for config/key storage
The container will generate `network.key` and `config.json` in the `awl-config` volume on first run.
### Verify Node is Running
```bash
docker ps | grep anywherelan
docker logs anywherelan-node
```
## Web Interface
The node exposes a web interface on port 8639. Access it at:
```
http://localhost:8639
```
## Docker Compose Alternative
Create a `docker-compose.yml` file:
```yaml
version: '3.8'
services:
anywherelan:
image: anywherelan:v0.17.0
container_name: anywherelan-node
restart: unless-stopped
privileged: true
volumes:
- awl-config:/data
ports:
- "8639:8639"
volumes:
awl-config:
```
Then start with:
```bash
docker-compose up -d
```
The network key and configuration will be automatically generated on first startup.
## Stopping the Node
```bash
docker stop anywherelan-node
```
## Removing the Node
```bash
docker rm anywherelan-node
```
To also remove the configuration volume:
```bash
docker volume rm awl-config
```
⚠️ **Warning**: Removing the volume will delete all configuration and keys. Only do this if you want a fresh start.
## Configuration
Configuration is stored in the `awl-config` volume:
- `network.key`: Your node's encryption key (auto-generated)
- `config.json`: Node configuration (auto-generated)
To access or backup configuration:
```bash
# View volume location
docker volume inspect awl-config
# Backup configuration
docker run --rm -v awl-config:/data -v $(pwd):/backup alpine cp -r /data /backup/awl-config-backup
# Restore configuration
docker run --rm -v awl-config:/data -v $(pwd):/backup alpine cp -r /backup/awl-config-backup /data
```
## Troubleshooting
### Permission Denied Error
The `--privileged` flag is required for creating virtual network interfaces (TUN/TAP devices).
### Port Already in Use
If port 8639 is taken, map to a different port:
```bash
docker run -d \
--name anywherelan-node \
--restart unless-stopped \
--privileged \
-p 8640:8639 \
-v awl-config:/data \
anywherelan:v0.17.0
```
Then access the web interface at `http://localhost:8640`
### View Logs
```bash
docker logs -f anywherelan-node
```
### Missing TUN Device
If you see "create tun: CreateTUN failed", ensure:
1. Docker is running with `--privileged` flag
2. The host has `/dev/net/tun` (on Linux hosts)
3. On non-Linux systems (Mac/Windows), Docker Desktop must have proper permissions
### Inspect Volume
To see where Docker stores your volume:
```bash
docker volume inspect awl-config
```
## Version
Built from tag: `v0.17.0`
## References
- [Anywherelan Official Repository](https://github.com/anywherelan/awl)
- [Project Documentation](https://github.com/anywherelan/awl/blob/main/README.md)
+29
View File
@@ -0,0 +1,29 @@
version: '3.8'
services:
anywherelan:
image: anywherelan:v0.17.0
container_name: anywherelan-node
restart: unless-stopped
privileged: true
volumes:
- awl-config:/data
ports:
- "8639:8639"
networks:
- anywherelan-net
environment:
- TZ=UTC
logging:
driver: "json-file"
options:
max-size: "100m"
max-file: "10"
volumes:
awl-config:
driver: local
networks:
anywherelan-net:
driver: bridge
+13
View File
@@ -0,0 +1,13 @@
#!/bin/sh
set -e
# Ensure /data directory exists
mkdir -p /data
# Symlink the config directory to home config location so AWL can find it
mkdir -p /root/.config/anywherelan
ln -sf /data/config_awl.json /root/.config/anywherelan/config_awl.json 2>/dev/null || true
# Run the AWL node (no command needed, it starts the server by default)
exec awl
+62
View File
@@ -0,0 +1,62 @@
services:
beszel:
image: henrygd/beszel:latest
environment:
APP_URL: http://localhost:8090
ports:
- 8090:8090
volumes:
- beszel_data:/beszel_data
deploy:
mode: replicated
replicas: 1
placement:
constraints:
- node.role == manager
restart_policy:
condition: on-failure
# healthcheck:
# test: ['CMD', '/beszel', 'health', '--url', 'http://localhost:8090']
# interval: 120s
# start_period: 10s
# timeout: 5s
beszel-agent:
image: henrygd/beszel-agent:latest
container_name: beszel-agent
restart: unless-stopped
network_mode: host
volumes:
- beszel_agent_data:/var/lib/beszel-agent
- beszel_socket:/beszel_socket
- /var/run/docker.sock:/var/run/docker.sock:ro
environment:
LISTEN: /beszel_socket/beszel.sock
HUB_URL: http://100.105.201.15:8090
KEY: 'ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOKMyuYnUwzLlYS7yZxcs1psBzRl7n9MhoZQ0Kek3XtV'
TOKEN: a2c7cabb-c849-4f64-89cf-1cf9afbfb018
# healthcheck:
# test: ['CMD', '/agent', 'health']
# interval: 120s
beszel-agent1:
image: henrygd/beszel-agent
container_name: beszel-agent1
restart: unless-stopped
network_mode: host
volumes:
- /var/run/docker.sock:/var/run/docker.sock:ro
- beszel_agent_data:/var/lib/beszel-agent
# monitor other disks / partitions by mounting a folder in /extra-filesystems
# - /mnt/disk/.beszel:/extra-filesystems/sda1:ro
environment:
LISTEN: 45876
KEY: 'ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOKMyuYnUwzLlYS7yZxcs1psBzRl7n9MhoZQ0Kek3XtV'
TOKEN: cd057ffc-8af3-414f-bbd4-3d0c9986b8ba
HUB_URL: http://100.105.201.15:8090
volumes:
beszel_agent_data:
volumes:
beszel_data:
beszel_agent_data:
beszel_socket:
+39
View File
@@ -0,0 +1,39 @@
#!/usr/bin/env bash
# Custom entrypoint for the act_runner cache-server.
#
# The upstream image's /usr/local/bin/run.sh hardcodes `act_runner daemon`
# and ignores argv. So we replace the entrypoint here.
#
# cache-server also requires cache.external_secret to be set in config.yaml
# as a literal value (not a file path). We keep the value in a Docker
# secret and substitute it into a runtime copy of config.yaml before
# exec'ing act_runner.
set -eu
SECRET_FILE="${ACT_RUNNER_EXTERNAL_SECRET_FILE:-/run/secrets/gitea_cache_secret}"
CONFIG_FILE="${CONFIG_FILE:-/cfg/config.yaml}"
if [[ ! -s "$SECRET_FILE" ]]; then
echo "cache-server-run: secret file $SECRET_FILE is missing or empty" >&2
exit 1
fi
if [[ ! -f "$CONFIG_FILE" ]]; then
echo "cache-server-run: config file $CONFIG_FILE not found" >&2
exit 1
fi
SECRET_VALUE="$(cat "$SECRET_FILE")"
# Render a copy of config.yaml with cache.external_secret replaced by the
# secret's literal value. /cfg/config.yaml is a read-only Swarm config mount,
# so we cannot edit it in place. Use a plain-file replacement — the
# upstream config.yaml has the form `external_secret: ""` (or any literal)
# on a single line, so a simple sed is safe.
RUNTIME_CONFIG="/tmp/config.runtime.yaml"
cp "$CONFIG_FILE" "$RUNTIME_CONFIG"
# Replace the value after `external_secret:` on a single line.
# Use a delimiter unlikely to appear in the secret.
sed -i "s|^ external_secret:.*$| external_secret: \"${SECRET_VALUE}\"|" "$RUNTIME_CONFIG"
exec /usr/local/bin/act_runner cache-server --config "$RUNTIME_CONFIG"
+8 -18
View File
@@ -70,26 +70,16 @@ runner:
- "ubuntu-22.04:docker://docker.gitea.com/runner-images:ubuntu-22.04"
cache:
# Enable cache server to use actions/cache.
enabled: true
# The directory to store the cache data.
# If it's empty, the cache data will be stored in $HOME/.cache/actcache.
dir: ""
# The host of the cache server.
# It's not for the address to listen, but the address to connect from job containers.
# So 0.0.0.0 is a bad choice, leave it empty to detect automatically.
host: ""
# The port of the cache server.
# 0 means to use a random available port.
port: 0
# The external cache server URL. Valid only when enable is true.
# If it's specified, act_runner will use this URL as the ACTIONS_CACHE_URL rather than start a server by itself.
# The URL should generally end with "/".
# Requires external_secret below to be set to the same value on both this runner and the cache-server.
external_server: ""
# Shared secret between this runner and the external `act_runner cache-server`. Required when external_server
# (or `act_runner cache-server`) is in use: the runner pre-registers each job's ACTIONS_RUNTIME_TOKEN with the
# cache-server, and the cache-server enforces bearer auth + per-repo cache isolation.
# Point at the dedicated gitea_cache_server container on the `gitea` overlay.
# The runner's built-in cache server binds to an interface unreachable from
# per-job container networks, causing ~9 min/job wasted on
# "reserveCache failed: connect ETIMEDOUT" (see gitea/actions/runs/16 job #248).
host: "gitea_cache_server"
port: 37051
external_server: "http://gitea_cache_server:37051/"
# Read from the gitea_cache_secret Docker secret (see stack-compose.yml).
external_secret: ""
container:
+36
View File
@@ -0,0 +1,36 @@
#!/usr/bin/env bash
# Custom entrypoint for the gitea_runner service.
#
# Same trick as cache-server-run.sh: act_runner requires cache.external_secret
# to be a literal string in config.yaml, not a file path. We keep the value in
# a Docker secret and substitute it into a runtime copy of config.yaml, then
# exec the image's own /usr/local/bin/run.sh (which handles registration +
# daemon).
set -eu
SECRET_FILE="${ACT_RUNNER_EXTERNAL_SECRET_FILE:-/run/secrets/gitea_cache_secret}"
CONFIG_FILE="${CONFIG_FILE:-/cfg/config.yaml}"
if [[ ! -s "$SECRET_FILE" ]]; then
echo "runner-run: secret file $SECRET_FILE is missing or empty" >&2
exit 1
fi
if [[ ! -f "$CONFIG_FILE" ]]; then
echo "runner-run: config file $CONFIG_FILE not found" >&2
exit 1
fi
SECRET_VALUE="$(cat "$SECRET_FILE")"
# Render a runtime copy with the secret substituted in.
RUNTIME_CONFIG="/tmp/config.runtime.yaml"
cp "$CONFIG_FILE" "$RUNTIME_CONFIG"
sed -i "s|^ external_secret:.*$| external_secret: \"${SECRET_VALUE}\"|" "$RUNTIME_CONFIG"
# The upstream run.sh reads $CONFIG_FILE from the environment to pass
# --config to act_runner. Override it so registration + daemon both pick up
# the runtime copy with the substituted secret.
export CONFIG_FILE="$RUNTIME_CONFIG"
exec /usr/local/bin/run.sh
+104 -10
View File
@@ -1,7 +1,10 @@
# Gitea Actions stack. Uses a dedicated act_runner cache-server so that
# job-container networks can reach the cache backend via Swarm service DNS
# (gitea_cache_server:37051) instead of the unreachable IP the built-in
# cache server binds to per-job.
services:
server:
image: docker.gitea.com/gitea:1.27.0
image: docker.gitea.com/gitea:1.27.3
# environment:
# - USER_UID=1000
# - USER_GID=1000
@@ -10,15 +13,20 @@ services:
- gitea
- nginx_ingress
volumes:
- data:/data
- /root/volumes/gitea:/data
- /etc/timezone:/etc/timezone:ro
- /etc/localtime:/etc/localtime:ro
deploy:
placement:
constraints:
- node.hostname == odroid
ports:
- "3002:3000"
- "222:22"
runner:
image: docker.io/gitea/act_runner:nightly
entrypoint: ["/usr/local/bin/runner-run.sh"]
environment:
CONFIG_FILE: /cfg/config.yaml
GITEA_INSTANCE_URL: "https://gitea.rudolf.keenetic.link"
@@ -26,30 +34,116 @@ services:
GITEA_RUNNER_NAME: "runner1"
GITEA_RUNNER_LABELS: "runner_label1"
# GITEA_RUNNER_EPHEMERAL: "1"
ACT_RUNNER_EXTERNAL_SECRET_FILE: /run/secrets/gitea_cache_secret
networks:
- gitea
# - nginx_ingress
configs:
- source: runner_config
target: /cfg/config.yaml
mode: 0444
- source: runner_run
target: /usr/local/bin/runner-run.sh
mode: 0755
volumes:
- /var/run/docker.sock:/var/run/docker.sock
secrets:
- gitea_cache_secret
deploy:
placement:
constraints:
- node.hostname == odroid
restart_policy:
condition: on-failure
delay: 5s
max_attempts: 3
runner_rudolf_t:
image: docker.io/gitea/act_runner:nightly
entrypoint: ["/usr/local/bin/runner-run.sh"]
environment:
CONFIG_FILE: /cfg/config.yaml
GITEA_INSTANCE_URL: "https://gitea.rudolf.keenetic.link"
GITEA_RUNNER_REGISTRATION_TOKEN: "ZIB6L21imA3XJkq65Cq1h43NzB5U1zhAJK9ybfCz"
GITEA_RUNNER_NAME: "runner2"
GITEA_RUNNER_LABELS: "runner_label1"
ACT_RUNNER_EXTERNAL_SECRET_FILE: /run/secrets/gitea_cache_secret
networks:
- gitea
configs:
- source: runner_config
target: /cfg/config.yaml
mode: 0444
- source: runner_run
target: /usr/local/bin/runner-run.sh
mode: 0755
volumes:
- /var/run/docker.sock:/var/run/docker.sock
secrets:
- gitea_cache_secret
deploy:
placement:
constraints:
- node.hostname == rudolf-T
restart_policy:
condition: on-failure
delay: 5s
max_attempts: 3
cache_server:
# The image's /usr/local/bin/run.sh hardcodes `act_runner daemon` and
# ignores argv, so passing `cache-server` via `command` doesn't help —
# the daemon path is always taken. We replace the entrypoint by
# mounting our own script via a Swarm config (file mount), then have it
# substitute the Docker secret literal into a runtime copy of
# config.yaml's cache.external_secret and exec act_runner.
image: docker.io/gitea/act_runner:nightly
entrypoint: ["/usr/local/bin/cache-server-run.sh"]
environment:
ACT_RUNNER_EXTERNAL_SECRET_FILE: /run/secrets/gitea_cache_secret
networks:
- gitea
volumes:
- cache_data:/root/.cache/actcache
secrets:
- gitea_cache_secret
configs:
- source: runner_config
target: /cfg/config.yaml
mode: 0444
- source: cache_server_run
target: /usr/local/bin/cache-server-run.sh
mode: 0755
networks:
nginx_ingress:
external: true
gitea:
driver: overlay
driver_opts:
com.docker.network.driver.mtu: "1200"
configs:
runner_config:
file: ./config.yaml
cache_server_run:
file: ./cache-server-run.sh
runner_run:
file: ./runner-run.sh
secrets:
gitea_cache_secret:
# Create once before first deploy (or to rotate):
# echo -n "$SECRET" | docker secret create gitea_cache_secret -
# Then `docker stack deploy -c stack-compose.yml gitea`.
external: true
volumes:
data:
driver: local
driver_opts:
type: nfs
o: addr=192.168.1.96
device: :/root/volumes/gitea
# device: :/media/DATA/runtime/gitea
# data:
# driver: local
# driver_opts:
# type: nfs
# o: addr=192.168.1.96
# device: :/root/volumes/gitea
# # device: :/media/DATA/runtime/gitea
cache_data:
+10
View File
@@ -51,5 +51,15 @@ networks:
volumes:
hermes_gateway_data:
driver: local
driver_opts:
type: nfs
o: addr=192.168.1.96
device: :/root/volumes/hermes/gateway
hermes_agent_data:
driver: local
driver_opts:
type: nfs
o: addr=192.168.1.96
device: :/root/volumes/hermes/agent
+11
View File
@@ -0,0 +1,11 @@
FROM ubuntu:20.04
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
RUN curl -fsSL https://pkgs.netbird.io/install.sh | sh
RUN mkdir -p /scripts && \
printf '#!/bin/bash\necho "=== Starting NetBird Entrypoint ==="\necho "Current user: $(whoami)"\necho "PATH: $PATH"\necho "Checking for netbird..."\nwhich netbird || echo "netbird not found in PATH"\necho "Attempting to start NetBird..."\nif command -v netbird &> /dev/null; then\n netbird up -F &\n NETBIRD_PID=$!\n echo "NetBird started with PID $NETBIRD_PID"\n trap "kill $NETBIRD_PID" TERM INT\n wait $NETBIRD_PID\nelse\n echo "ERROR: netbird command not available"\n echo "=== Container will keep running for debugging ==="\n tail -f /dev/null\nfi\n' > /scripts/entrypoint.sh && \
chmod +x /scripts/entrypoint.sh
ENTRYPOINT ["/scripts/entrypoint.sh"]
+117
View File
@@ -0,0 +1,117 @@
# Netbird Docker Deployment
Docker Compose configurations and automated setup for Netbird - a zero-trust mesh VPN solution.
## Quick Start
**Start here**: Run the automated setup script
```bash
cd /media/DATA/src/ansible/poc/netbird
./setup-netbird.sh
```
Or manually clone official repo:
```bash
git clone https://github.com/netbirdio/netbird.git
cd netbird/infrastructure_files/compose
docker-compose up -d
```
## ⚠️ Important: OIDC Bug in Pre-built Images
Pre-built Netbird Docker images crash on startup with segmentation fault in OIDC code. **Do not use local stack-server.yml directly.** Use official repository or setup script instead.
## Files
| File | Purpose |
|------|---------|
| **setup-netbird.sh** | ⭐ Automated setup script |
| **SETUP_NETBIRD_OFFICIAL.md** | Official deployment methods |
| **stack-server.yml** | Local Docker Compose (⚠️ management crashes) |
| **stack-client.yml** | Client instance |
| **VERSIONS.md** | Version reference |
## Client Deployment
Once you have working Netbird management:
```bash
export MANAGEMENT_URL="https://your-server:33073"
export SETUP_KEY="from-dashboard"
docker-compose -f stack-client.yml up -d
```
Multiple clients:
```bash
docker-compose -f stack-client.yml -p client1 up -d
docker-compose -f stack-client.yml -p client2 up -d
```
## Android Setup (Same WiFi)
1. Get server IP: `hostname -I`
2. Open firewall: `sudo ufw allow 33073`
3. Android app: Enter `http://<server-ip>:33073` + setup key
Test: `curl http://<ip>:33073/api/health`
## Docker Commands
```bash
# Local infrastructure only (management will crash)
docker-compose -f stack-server.yml up -d
docker-compose -f stack-server.yml ps
docker-compose -f stack-server.yml logs -f
# Stop
docker-compose -f stack-server.yml down
# Database access
docker-compose -f stack-server.yml exec postgres \
psql -U netbird -d netbird
# Client commands
docker-compose -f stack-client.yml logs -f
```
## Services
| Service | Port |
|---------|------|
| Management API | 33073 |
| Signal | 10000 |
| Dashboard | 80 |
| PostgreSQL | 5432 |
| Redis | 6379 |
| TURN | 3478, 5349 |
## Environment Variables
```bash
# Server (set before docker-compose up)
POSTGRES_PASSWORD=netbird123
NETBIRD_MGMT_SINGLE_ACCOUNT_MODE=true
NETBIRD_MGMT_LOG_LEVEL=info
# Client
MANAGEMENT_URL=https://server:33073
SETUP_KEY=your-key
```
## Requirements
**Server**: Docker, 2GB RAM, ports 80, 33073, 10000, 3478, 5349
**Client**: Docker with /dev/net/tun access, NET_ADMIN capability
## Troubleshooting
**Management crashes**: Use official repo or setup script
**Can't connect from Android**: Check firewall, use correct IP (not localhost)
**Database issues**: Check logs with `docker-compose logs postgres`
## Resources
- [Official Docs](https://docs.netbird.io/)
- [GitHub](https://github.com/netbirdio/netbird)
- Detailed guide in [SETUP_NETBIRD_OFFICIAL.md](SETUP_NETBIRD_OFFICIAL.md)
+51
View File
@@ -0,0 +1,51 @@
{
"Datadir": "/var/lib/netbird/",
"DataStoreEncryptionKey": "8zd4m/LHfTvaQtst9ZW29BpZ0U1/RrvRvhtE1y7OdKg=",
"StoreConfig": {
"Engine": "postgres"
},
"HttpConfig": {
"Address": "0.0.0.0",
"Port": 33073,
"CertFile": "",
"CertKey": ""
},
"Stuns": [
{
"Proto": "udp",
"URI": "stun:3468",
"Username": "",
"Password": ""
}
],
"TURNConfig": {
"Turns": [
{
"Proto": "udp",
"URI": "turn:3478",
"Username": "",
"Password": ""
}
],
"CredentialsMap": {}
},
"Signal": {
"URI": "signal:10000",
"Proto": "grpc"
},
"Relay": {
"URI": "relay:7835"
},
"ReverseProxy": {
"TrustedHTTPProxies": null,
"TrustedHTTPProxiesCount": 0,
"TrustedPeers": null,
"AccessLogRetentionDays": 0,
"AccessLogCleanupIntervalHours": 0
},
"IdpManagerConfig": null,
"DeviceAuthorizationFlow": null,
"PKCEAuthorizationFlow": null,
"DisableDefaultPolicy": false,
"EmbeddedIdP": null
}
+33
View File
@@ -0,0 +1,33 @@
version: '3.8'
services:
netbird-client:
image: netbirdio/client:latest
container_name: netbird-client
cap_add:
- NET_ADMIN
devices:
- /dev/net/tun
environment:
NETBIRD_MANAGEMENT_URL: ${MANAGEMENT_URL:-https://management:33073}
NETBIRD_LOG_LEVEL: info
# Use setup key for automatic enrollment (optional)
NETBIRD_SETUP_KEY: ${SETUP_KEY:-}
volumes:
- netbird_client_data:/etc/netbird
- /etc/resolv.conf:/etc/resolv.conf:ro
ports:
- "41641:41641/udp"
networks:
- netbird
restart: unless-stopped
dns:
- 8.8.8.8
- 8.8.4.4
volumes:
netbird_client_data:
networks:
netbird:
driver: bridge
+118
View File
@@ -0,0 +1,118 @@
version: '3.8'
services:
postgres:
image: postgres:15-alpine
container_name: netbird-postgres
environment:
POSTGRES_DB: netbird
POSTGRES_USER: netbird
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-netbird123}
volumes:
- postgres_data:/var/lib/postgresql/data
ports:
- "5432:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U netbird"]
interval: 10s
timeout: 5s
retries: 5
redis:
image: redis:7-alpine
container_name: netbird-redis
ports:
- "6379:6379"
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 10s
timeout: 5s
retries: 5
management:
image: netbirdio/management:0.70.5
container_name: netbird-management
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
environment:
# PostgreSQL configuration
NETBIRD_MGMT_DATASTORE: postgres
NETBIRD_MGMT_DATASTORE_HOST: postgres
NETBIRD_MGMT_DATASTORE_PORT: "5432"
NETBIRD_MGMT_DATASTORE_DB: netbird
NETBIRD_MGMT_DATASTORE_USER: netbird
NETBIRD_MGMT_DATASTORE_PASSWORD: ${POSTGRES_PASSWORD:-netbird123}
# Redis
NETBIRD_MGMT_DATASTORE_CACHE: "redis"
NETBIRD_MGMT_DATASTORE_REDIS_URL: "redis://redis:6379"
# Management API
NETBIRD_MGMT_API_PORT: "33073"
NETBIRD_MGMT_LOG_LEVEL: debug
NETBIRD_MGMT_SINGLE_ACCOUNT_MODE: "true"
NETBIRD_MGMT_DISABLE_SINGLE_ACCOUNT_MODE_REQUIRE_CUSTOM_DOMAIN: "true"
# OIDC disabled
NETBIRD_MGMT_AUTH_OIDC_CONFIGURATION_ENDPOINT: ""
ports:
- "33073:33073"
volumes:
- management_data:/var/lib/netbird
- ./management.json:/etc/netbird/management.json
networks:
- netbird
restart: "no"
signal:
image: netbirdio/signal:0.70.5
container_name: netbird-signal
environment:
NETBIRD_SIGNAL_LOG_LEVEL: info
NETBIRD_SIGNAL_PORT: 10000
ports:
- "10000:10000/tcp"
- "10000:10000/udp"
networks:
- netbird
depends_on:
- management
dashboard:
image: netbirdio/dashboard:latest
container_name: netbird-dashboard
environment:
REACT_APP_API_URL: ${DASHBOARD_API_URL:-http://localhost:33073}
ports:
- "80:80"
networks:
- netbird
depends_on:
- management
coturn:
image: coturn/coturn:latest
container_name: netbird-turn
ports:
- "3478:3478/tcp"
- "3478:3478/udp"
- "5349:5349/tcp"
- "5349:5349/udp"
volumes:
- ./coturn.conf:/etc/coturn/turnserver.conf:ro
- turn_data:/var/lib/coturn
networks:
- netbird
restart: unless-stopped
volumes:
postgres_data:
redis_data:
management_data:
turn_data:
networks:
netbird:
driver: bridge
+21
View File
@@ -0,0 +1,21 @@
Code-Server (code-server) Docker Swarm stack
Deploy a lightweight web-accessible VS Code (code-server) on Docker Swarm.
Quick usage
- Edit `stack-code-server.yml` to set a secure `PASSWORD` (or use Docker secrets).
- Deploy the stack:
```bash
docker stack deploy -c stack-code-server.yml code-server
```
Access
- Open http://<HOST>:8443 or https depending on the image configuration. Log in with the password set in the compose file.
Notes
- The service stores config in a named volume `code_server_data` and mounts `./workspace` into the container at `/config/workspace`.
- For production, replace the `PASSWORD` with a Docker secret and consider putting the service behind a reverse proxy/traefik with TLS.
+22
View File
@@ -0,0 +1,22 @@
version: '3.8'
services:
code-server:
image: linuxserver/code-server:latest
ports:
- "8443:8443"
environment:
PUID: 1000
PGID: 1000
TZ: UTC
PASSWORD: changeme
volumes:
- config:/config
- workspace:/config/workspace
deploy:
replicas: 1
restart_policy:
condition: on-failure
volumes:
config:
workspace: