Install (Kubernetes / Helm)

Caution

The current app source includes a Helm chart, but it is intentionally conservative. It is single-replica only, requires a persistent /config volume, and should be treated as a careful operator path rather than a horizontally scalable deployment model.

A Helm chart exists in the app source at deploy/helm/channelwatch/. This page documents what that chart actually shows today.

If you want the simplest deployment path, the Docker Compose install is still the lighter-weight option.

Caution

ChannelWatch is a single-replica application. The chart validates replicaCount=1, and multi-replica operation is unsupported because /config is shared state with concurrent-writer risks.

Prerequisites

Current chart assumptions:

• a Kubernetes cluster with Helm available
• a PersistentVolume or StorageClass that supports ReadWriteOnce access mode
• network access from the pod to your Channels DVR server

Install from the chart source

The source-backed chart can be installed from a checked-out ChannelWatch repository:

helm install channelwatch ./deploy/helm/channelwatch \
  --namespace channelwatch \
  --create-namespace

This docs page does not assume a published Helm repository URL. If the project later publishes one, check the release notes or app repo for the authoritative install path.

Example install overrides

The chart’s current values.yaml includes these defaults:

• replicaCount: 1
• service.type: ClusterIP
• service.port: 8501
• persistence.enabled: true
• persistence.size: 10Gi
• probe paths for /healthz/startup, /healthz/ready, and /healthz/live

Example install with a few overrides:

helm install channelwatch ./deploy/helm/channelwatch \
  --namespace channelwatch \
  --create-namespace \
  --set persistence.size=20Gi \
  --set config.tz="America/New_York" \
  --set config.channelsDvrHost="192.168.1.50" \
  --set config.channelsDvrPort="8089"

After the pod reaches Running, forward the service locally if needed:

kubectl port-forward -n channelwatch svc/channelwatch 8501:8501

Then open http://localhost:8501 and complete the web-based setup.

Key values

The current chart exposes these values in values.yaml:

Value	Default	Description
image.repository	coderluii/channelwatch	Container image repository
image.tag	latest	Image tag
image.pullPolicy	IfNotPresent	Image pull policy
replicaCount	1	Must remain 1
persistence.enabled	true	Enable PVC for /config
persistence.size	10Gi	PVC size
persistence.storageClassName	""	StorageClass name; empty uses the cluster default
service.type	ClusterIP	Service type
service.port	8501	Service port
config.tz	America/New_York	Container timezone
config.channelsDvrHost	""	Single-DVR host passed through the chart config map
config.channelsDvrPort	"8089"	Single-DVR port passed through the chart config map
config.channelsDvrServers	""	Raw multi-DVR env payload if you prefer the env-driven server list
config.disableAuth	"false"	Disable auth toggle passed via env
resources	{}	Container resource requests and limits
secretConfig.apiKey	""	Shared API key secret
secretConfig.adminUser	""	Optional bootstrap admin username
secretConfig.adminPass	""	Optional bootstrap admin password

Example values.yaml

replicaCount: 1

image:
  repository: coderluii/channelwatch
  tag: latest
  pullPolicy: IfNotPresent

persistence:
  enabled: true
  size: 20Gi
  storageClassName: "local-path"

service:
  type: LoadBalancer
  port: 8501

config:
  tz: America/Chicago
  channelsDvrHost: "192.168.1.50"
  channelsDvrPort: "8089"

secretConfig:
  apiKey: "replace-me"

resources:
  requests:
    memory: "64Mi"
    cpu: "50m"
  limits:
    memory: "256Mi"
    cpu: "500m"

Apply a custom values file with:

helm install channelwatch ./deploy/helm/channelwatch \
  --namespace channelwatch \
  --create-namespace \
  -f values.yaml

Note

The chart also seeds CW_API_KEY, CW_ADMIN_USER, and CW_ADMIN_PASS from the generated Secret, and it validates replicaCount=1 plus persistence.enabled=true at template-render time.

Health probes

The current chart wires probes directly to the app’s health endpoints:

Probe	Path	Purpose
Liveness	/healthz/live	Basic process alive check
Readiness	/healthz/ready	Monitoring readiness summary for configured DVRs
Startup	/healthz/startup	Startup completion gate

Equivalent raw manifest example:

livenessProbe:
  httpGet:
    path: /healthz/live
    port: 8501
  initialDelaySeconds: 0
  periodSeconds: 30
  timeoutSeconds: 3
  failureThreshold: 3

readinessProbe:
  httpGet:
    path: /healthz/ready
    port: 8501
  initialDelaySeconds: 0
  periodSeconds: 10
  timeoutSeconds: 3
  failureThreshold: 3

startupProbe:
  httpGet:
    path: /healthz/startup
    port: 8501
  initialDelaySeconds: 0
  periodSeconds: 5
  timeoutSeconds: 3
  failureThreshold: 30

/api/health also exists for a higher-level service summary, but the chart uses the /healthz/* endpoints for Kubernetes-native probes.

Note

/healthz/ready reflects DVR monitoring readiness, not just process liveness. If every configured DVR is temporarily unreachable, the pod can go unready without the process being dead.

Upgrading

Upgrade from the same chart source:

helm upgrade channelwatch ./deploy/helm/channelwatch \
  --namespace channelwatch \
  -f values.yaml

ChannelWatch migrates /config/settings.json on startup and writes timestamped backups under /config/backups/ before migration work runs.

Uninstalling

helm uninstall channelwatch --namespace channelwatch

Caution

The chart does not delete your PersistentVolumeClaim by default. Remove the PVC separately only if you want to delete /config permanently.

Current limits

• Multi-replica deployments are blocked by chart validation and are unsupported by the app design.
• This page does not claim a separately published Helm repository.
• mDNS discovery limits still apply on Kubernetes networks; see mDNS Auto-Discovery.

Next steps

• Install (Docker Compose) — the simplest deployment path
• First-Run Configuration — add your Channels DVR server and configure alerts
• Health Probes — detailed probe behavior and Prometheus metrics
• mDNS Auto-Discovery — why discovery is usually a manual-add workflow on Kubernetes