Przejdź do treści
Biblioteka skilli
Programowanie · Integracja z narzędziem

cloud-streaming

/cloud-streaming

Konfiguruje okulary Aria Gen 2 do strumieniowania danych z czujników bezpośrednio na publiczny endpoint HTTPS, do wdrożeń terenowych, zbierania z wielu urządzeń i potoków przetwarzania w chmurze.

Licencja
Apache-2.0
Ostatnia zmiana repozytorium
20.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
2
Przestarzałość

Brak sygnałów. Repozytorium zmienione 20.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Konfiguruje okulary Aria Gen 2 do strumieniowania danych z czujników bezpośrednio na publiczny endpoint HTTPS, do wdrożeń terenowych, zbierania z wielu urządzeń i potoków przetwarzania w chmurze.

Oryginalny opis (EN)

Use when configuring Aria Gen 2 glasses to stream sensor data directly to an internet-accessible HTTPS endpoint — instead of the default local USB / same-network WiFi streaming to a nearby PC. For field deployments, centralized multi-device collection, and cloud processing pipelines. Use whenever the user asks about remote streaming, streaming over the internet, cloud collection servers, or streaming without a laptop on hand.

Jak działa

  1. When to use
  2. Architecture
  3. Setup (one-time per server)
  4. What the server receives per POST
  5. Thermal management
  6. VPN / firewall limitation
  7. Certificate security
  8. Troubleshooting
  9. Related plugin skills
Sekcje z nagłówków SKILL.md, w oryginale · 131 linii, 918 słów
Podgląd SKILL.md
---
name: cloud-streaming
description: Use when configuring Aria Gen 2 glasses to stream sensor data directly to an internet-accessible HTTPS endpoint — instead of the default local USB / same-network WiFi streaming to a nearby PC. For field deployments, centralized multi-device collection, and cloud processing pipelines. Use whenever the user asks about remote streaming, streaming over the internet, cloud collection servers, or streaming without a laptop on hand.
---

# Aria Cloud Streaming

Remote (cloud) streaming sends Aria Gen 2 data straight to your internet-reachable HTTPS server, bypassing the default local USB / same-network WiFi streaming. The glasses POST data over HTTPS to whatever URL you supply.

> Reference: https://facebookresearch.github.io/projectaria_tools/gen2/ark/client-sdk/remote-streaming
> For local USB / same-network streaming: use the **`client-sdk`** skill.

## When to use

- **Field deployments** — collect data without carrying a laptop.
- **Centralized collection** — many devices → one cloud server.
- **Cloud processing** — feed real-time pipelines (decoders, indexers, alerters) in the cloud.
- **Remote monitoring** — observe device streams from anywhere.

If your collection point is on the **same WiFi** as the glasses, plain local streaming via the Client SDK is simpler — use that.

## Architecture

```text
Aria Glasses  ──(WiFi → internet)──►  Your HTTPS Server :6768
                  HTTPS POST              (decode / store / forward)
```

The glasses open an HTTPS connection to a URL you provide and POST sensor data chunks. The server uses Aria's streaming TLS certificates so the connection is mutually trusted.

## Setup (one-time per server)

### 1. Prerequisites

- Client SDK installed and device authenticated (`aria_gen2 auth pair`) — see the `client-sdk` skill.
- Glasses on a WiFi network with **internet access**.
- A server reachable from the public internet on **port 6768**.

### 2. Copy streaming certificates to the server

The certificates were generated when the SDK was first set up. They live on the PC where the SDK was installed at:

```text
~/.aria/streaming-certs/persistent/
├── subscriber.pem        # server cert (PEM)
├── subscriber-key.pem    # server private key
└── root_ca.pem
```

Copy `subscriber.pem` and `subscriber-key.pem` to a secure path on the cloud server (e.g. `/etc/aria-certs/`, with `chmod 600`).

### 3. Open inbound port 6768

Open TCP port 6768 in the server's firewall and any cloud-provider security group. Restrict the source to known IP ranges if you can; otherwise allow `0.0.0.0/0`.

### 4. Run an HTTPS server on port 6768

Use any HTTP framework that supports custom TLS — the cert chain is loaded via:

```python
ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
ctx.load_cert_chain("/path/to/subscriber.pem", "/path/to/subscriber-key.pem")
server.socket = ctx.wrap_socket(server.socket, server_side=True)
```

A complete minimal Python server (HTTPServer + BaseHTTPRequestHandler) is shown in the reference page. The handler reads metadata from request headers, reads the binary body, and responds with `200 OK`.

### 5. Start streaming from the glasses pointing at your URL

Both the CLI and Python SDK accept a custom endpoint URL. Run `aria_gen2 streaming start --help` for current flag names, or see the reference page for the Python SDK equivalents (`HttpStreamingConfig.advanced_config.endpoint.url`, `verify_server_certificates`).

## What the server receives per POST

**Headers** carry session and device metadata:

| Header | Value |
|---|---|
| `session-id` | UUID for this streaming session |
| `device-serial` | Device serial number |
| `device-build` | Firmware version |
| `oatmeal-calibration` | JSON with camera + IMU + barometer calibration |
| `Transfer-Encoding` | `chunked` |

**Body** carries binary streaming data: IMU samples, camera frames, audio, eye / hand tracking, VIO poses, etc.

Respond with `200 OK` and any small JSON body (e.g. `{"status":"ok"}`).

## Thermal management

Remote streaming over WiFi generates heat. The single most important setting is **`--batch-period-ms`** (CLI) / `batch_period_ms` (Python config). It batches messages on-device before sending; longer periods = less radio activity = less heat.

| Environment | Suggested batch period |
|---|---|
| Cool (< 25 °C) | 100–200 ms |
| Normal room | 200–400 ms (start here) |
| Warm (> 28 °C) | 400–800 ms |

Without batching, the device will hit its thermal shutdown threshold (~44 °C) — typically within ~20 min of continuous streaming.

## VPN / firewall limitation

**Aria glasses cannot use VPNs.** If your collection server is behind a corporate VPN, the glasses cannot reach it directly.

**Workaround**: deploy a **public relay** — a small VM with a public IP that the glasses POST to — and forward via SSH / WireGuard tunnel into your internal server:

```text
Aria Glasses ──► Public Relay (VM, public IP)  ─tunnel─►  Your Internal Server
                  HTTPS POST :6768               SSH /                (behind VPN)
                                                 WireGuard
```

## Certificate security

Treat the streaming certificates like secrets:

- Anyone with both cert files can stand up a server that accepts streams from your devices.
- Limit file permissions on the server (`chmod 600`).
- For production, layer your own application-level authentication on top (e.g. require a bearer token header in the handler).
- Rotate certs periodically for sensitive deployments.

## Troubleshooting

| Symptom | Likely cause | Fix |
|---|---|---|
| No data reaches server | Glasses not on internet WiFi, server unreachable, or wrong URL | Verify WiFi connection from the Companion App or `aria_gen2 device wifi …`; test the URL from another machine with `curl -k https://your-server:6768`; double-check the URL is HTTPS and includes the port |
| SSL / TLS handshake error | Wrong cert paths, file permissions, or missing `--no-verify-server-certs` on the client | Verify cert paths on server, `chmod 600`, add the flag (or set the equivalent Python config field) |
| Connection timeouts | High-latency network, profile too heavy for the link | Use a lighter profile (`profile9`), increase batch period |
| Device overheating | Batch period too short, profile too heavy | Increase `--batch-period-ms`, drop to a lighter profile, allow cooling breaks |
| Firewall blocks 6768 | Port not open inbound on server / security group | Open inbound TCP 6768 |

## Related plugin skills

- `client-sdk` — local streaming, authentication, recording, multi-device basics.
- `aria-knowledge` — Aria platform concepts including streaming certificate model.

Wersje

W bazie nie ma innych skilli o nazwie cloud-streaming.

Migawka bazy z 13.11.2026 · wersja paczki 6138e7e380de (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100client-sdk
    Prowadzi przez pracę z Aria Client SDK: parowanie urządzeń, nagrywanie, streaming, polecenia CLI aria_gen2, Python SDK aria.sdk_gen2 i zarządzanie okularami Aria Gen2.
  • 100client-sdk-ros2-integration
    Pomaga zintegrować strumienie czujników Aria Gen 2 z ROS2: publikowanie danych przez tematy, dekodowanie w węzłach subskrybujących i współdzielenie kalibracji urządzenia.
  • 100react-aria
    Pomaga budować dostępne komponenty UI z React Aria: kontrolki formularzy, wzorce ARIA, systemy projektowe i naprawa problemów z dostępnością.
  • 100streaming
    Pilnuje niezmienników strumieniowania między klientem, serwerem i pakietem wspólnym, przy zmianach w elementach streamingu.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.