writing and streaming containers

Author: gwbischof

Dockerfile.streaming-client

@@ -0,0 +1,18 @@
+FROM ghcr.io/prefix-dev/pixi:latest
+
+WORKDIR /app
+
+# Copy pixi files
+COPY pixi.toml pixi.lock ./
+
+# Install dependencies using pixi
+RUN pixi install
+
+# Copy the streaming client
+COPY streaming_client.py .
+
+# Set default environment variable
+ENV REDIS_WS_API_URL=localhost:8000
+
+# Run the streaming client
+CMD ["pixi", "run", "python", "streaming_client.py"]

Dockerfile.writing-client

@@ -0,0 +1,20 @@
+FROM ghcr.io/prefix-dev/pixi:latest
+
+WORKDIR /app
+
+# Copy pixi files
+COPY pixi.toml pixi.lock ./
+
+# Install dependencies using pixi
+RUN pixi install
+
+# Copy the writing client
+COPY writing_client.py .
+
+# Set default environment variables
+ENV REDIS_WS_API_URL=localhost:8000
+ENV WRITE_DELAY=0.5
+ENV NUM_WRITES=10
+
+# Run the writing client
+CMD ["pixi", "run", "python", "writing_client.py"]

kube/README.md

@@ -1,21 +1,44 @@
-# Redis Kubernetes Deployment
+# Kubernetes Deployments
 
-This directory contains Kubernetes manifests for deploying Redis.
+This directory contains Kubernetes manifests for deploying Redis and the test-redis-ws application.
 
 ## Files
 - `redis-deployment.yaml` - Redis deployment with 1 replica
-- `redis-service.yaml` - ClusterIP service exposing port 6379
+- `redis-service.yaml` - ClusterIP service exposing Redis on port 6379
+- `test-redis-ws-deployment.yaml` - test-redis-ws deployment with 3 replicas
+- `test-redis-ws-service.yaml` - ClusterIP service exposing test-redis-ws on port 8000
 
 ## Deploy
 ```bash
+# Deploy everything
 kubectl apply -f .
+
+# Or deploy individually
+kubectl apply -f redis-deployment.yaml
+kubectl apply -f redis-service.yaml
+kubectl apply -f test-redis-ws-deployment.yaml
+kubectl apply -f test-redis-ws-service.yaml
 ```
 
-## Test
+## Container Image
+The test-redis-ws image is automatically built and pushed to GitHub Container Registry on push to main branch.
+- Image: `ghcr.io/nsls2/test-redis-ws:latest`
+- Build workflow: `.github/workflows/build-push.yml`
+
+## Test Redis
 ```bash
 # Connect to a netshoot container
 kubectl run netshoot --image=nicolaka/netshoot --rm -it --restart=Never -- /bin/bash
 
 # Test Redis connection from inside the container
 echo -e "PING\r\n" | nc redis 6379
+```
+
+## Test test-redis-ws
+```bash
+# Connect to a netshoot container
+kubectl run netshoot --image=nicolaka/netshoot --rm -it --restart=Never -- /bin/bash
+
+# Test the service from inside the container
+curl http://test-redis-ws:8000/
 ```

kube/test-redis-ws-deployment.yaml

@@ -16,7 +16,7 @@ spec:
     spec:
       containers:
       - name: test-redis-ws
-        image: ghcr.io/nsls2/test-redis-ws:latest
+        image: ghcr.io/nsls2/test-redis-ws:kube
         imagePullPolicy: Always
         ports:
         - containerPort: 8000
@@ -28,8 +28,8 @@ spec:
           value: "6379"
         resources:
           requests:
-            memory: "256Mi"
-            cpu: "250m"
+            memory: "64Mi"
+            cpu: "50m"
           limits:
-            memory: "512Mi"
-            cpu: "500m"
+            memory: "256Mi"
+            cpu: "200m"

streaming_client.py

@@ -4,6 +4,7 @@
 import numpy as np
 import json
 import msgpack
+import os
 # from httpx_ws import aconnect_ws
 # from httpx_ws.transport import ASGIWebSocketTransport
 
@@ -25,15 +26,18 @@
 #         transport=ASGIWebSocketTransport(app=app), base_url="http://localhost"
 #     )
 
-client = AsyncClient(base_url="http://localhost:8000")
+# Get base URL from environment variable, default to localhost
+REDIS_WS_API_URL = os.getenv("REDIS_WS_API_URL", "localhost:8000")
+client = AsyncClient(base_url=f"http://{REDIS_WS_API_URL}")
 
 
 async def get_live():
     result = await client.get("/stream/live")
     return result.json()
 
 async def stream_node(node_id: str, envelope_format="json"):
-    websocket_url = f"ws://localhost:8000/stream/single/{node_id}?envelope_format={envelope_format}&seq_num=1"
+    # Create WebSocket URL from base URL
+    websocket_url = f"ws://{REDIS_WS_API_URL}/stream/single/{node_id}?envelope_format={envelope_format}&seq_num=1"
 
     async with websockets.connect(websocket_url) as websocket:
         print(f"Connected to {websocket_url}")

writing_client.py

@@ -2,17 +2,26 @@
 import httpx
 import time
 import sys
+import os
 
-client = httpx.Client(base_url="http://localhost:8000")
+# Get base URL from environment variable, default to localhost
+REDIS_WS_API_URL = os.getenv("REDIS_WS_API_URL", "localhost:8000")
+client = httpx.Client(base_url=f"http://{REDIS_WS_API_URL}")
+
+# Get write delay from environment variable, default to 0.5 seconds
+WRITE_DELAY = float(os.getenv("WRITE_DELAY", "0.5"))
+
+# Get number of writes from environment variable, default to 10
+NUM_WRITES = int(os.getenv("NUM_WRITES", "10"))
 
 
 def main():
     for _ in range(3):
         #content = client.post("/upload").raise_for_status().json()
         #node_id = content["node_id"]
         node_id = 481980
-        for i in range(10):
-            time.sleep(0.5)
+        for i in range(NUM_WRITES):
+            time.sleep(WRITE_DELAY)
             binary_data = (np.ones(5) * i).tobytes()
             client.post(
                 f"/upload/{node_id}",