Surveillance System Wiki

version: '3'

services:
  object_recognizer:
    image: object_recognizer:latest
    ports:
      - "9999:9999"
      - "5000:5000"

  motion_detector_1:
    image: motion_detector:latest
    ports:
      - "9998:9998"
    depends_on:
      - object_recognizer
      - jaeger
    environment:
      - INDEX=1
      - OR_HOST=object_recognizer
      - OR_PORT=9999
    command: python src/motion_detection.py

  motion_detector_2:
    image: motion_detector:latest
    ports:
      - "9997:9998"
    depends_on:
      - object_recognizer
      - jaeger
    environment:
      - INDEX=2
      - OR_HOST=object_recognizer
      - OR_PORT=9999
    command: python src/motion_detection.py

  motion_detector_3:
    image: motion_detector:latest
    ports:
      - "9996:9998"
    depends_on:
      - object_recognizer
      - jaeger
    environment:
      - INDEX=3
      - OR_HOST=object_recognizer
      - OR_PORT=9999
    command: python src/motion_detection.py

  camera_1:
    image: camera:latest
    depends_on:
      - motion_detector_1
      - otel-collector
    environment:
      - CAMERA=true
      - ANIMAL_NAME=tiger
      - APPEARANCE_RATE=600
      - MDHOST=motion_detector_1
      - MDPORT=9998
      - INDEX=1
    command: /bin/sh -c "python src/camera.py"

  camera_2:
    image: camera:latest
    depends_on:
      - motion_detector_2
      - otel-collector
    environment:
      - CAMERA=true
      - ANIMAL_NAME=bear
      - APPEARANCE_RATE=500
      - MDHOST=motion_detector_2
      - MDPORT=9998
      - INDEX=2
    command: /bin/sh -c "python src/camera.py"

  camera_3:
    image: camera:latest
    depends_on:
      - motion_detector_3
      - otel-collector
    environment:
      - CAMERA=true
      - ANIMAL_NAME=wolf
      - APPEARANCE_RATE=700
      - MDHOST=motion_detector_3
      - MDPORT=9998
      - INDEX=3
    command: /bin/sh -c "python src/camera.py"

  jaeger:
    image: jaegertracing/all-in-one
    ports:
      - "16686:16686"
      - "6831:6831/udp"
      - "14268"
      - "14250"

  zipkin-all-in-one:
    image: openzipkin/zipkin:latest
    environment:
      - JAVA_OPTS=-Xms1024m -Xmx1024m -XX:+ExitOnOutOfMemoryError
    restart: always
    ports:
      - "9411:9411"

  otel-collector:
    image: otel/opentelemetry-collector-contrib
    restart: always
    command: ["--config=/etc/otel-collector-config.yaml", "${OTELCOL_ARGS}"]
    volumes:
      - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml
    ports:
      - "1888:1888"   # pprof extension
      - "8888:8888"   # Prometheus metrics exposed by the collector
      - "8889:8889"   # Prometheus exporter metrics
      - "13133:13133" # health_check extension
      - "4317:4317"   # OTLP gRPC receiver
      - "55679:55679" # zpages extension
    depends_on:
      - jaeger
      - zipkin-all-in-one

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    hostname: cadvisor
    platform: linux/aarch64
    volumes:
      - "/:/rootfs:ro"
      - "/var/run:/var/run:ro"
      - "/sys:/sys:ro"
      - "/var/lib/docker/:/var/lib/docker:ro"
      - "/dev/disk/:/dev/disk:ro"
    ports:
      - "8080:8080"

  prometheus:
    image: prom/prometheus:latest
    restart: always
    volumes:
      - ./prometheus.yaml:/etc/prometheus/prometheus.yml
      - ./rules.yml:/etc/prometheus/rules.yml
    ports:
      - "9090:9090"

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    restart: unless-stopped
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro"
    command:
      - '--path.procfs=/host/proc'
      - '--path.rootfs=/rootfs'
      - '--path.sysfs=/host/sys'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
    expose:
      - 9100

import enoslib as en
from datetime import datetime

# Initialize logging
_ = en.init_logging()

# Generate a timestamp for the job name
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
job_name = f"usecase_{timestamp}"

cluster = "parasilo"
conf = (
    en.VMonG5kConf
    .from_settings(job_name=job_name, walltime="04:00:00")
    .add_machine(roles=["master"], cluster=cluster, number=1, flavour="large")
    .add_machine(roles=["agent", "object_recognizer"], cluster=cluster, number=1, flavour_desc={"core": 8, "mem": 8192})
    .add_machine(roles=["agent", "motion_detector"], cluster=cluster, number=3, flavour_desc={"core": 4, "mem": 4096})
    .add_machine(roles=["agent", "camera"], cluster=cluster, number=3, flavour_desc={"core": 1, "mem": 1024})
    .finalize()
)

# Initialize the provider
provider = en.VMonG5k(conf)
roles, networks = provider.init()
en.wait_for(roles)

# Initialize K3s with master and agent nodes
k3s = en.K3s(master=roles["master"], agent=roles["agent"])
k3s.deploy()

# Create a tunnel to the head node
print("Create a tunnel from your local machine to the head node:")
print(f"ssh -NL 8001:{roles['master'][0].address}:8001 {G5K_username}@access.grid5000.fr")

def label_nodes(node_names, labels):
    label_str = ",".join(f"{key}={value}" for key, value in labels.items())

    for node in node_names:
        command = f"kubectl label nodes {node} {label_str} --overwrite"
        try:
            result = en.run_command(command, roles=roles['master'])
            print(f"Successfully labeled {node} with {label_str}")
        except subprocess.CalledProcessError as e:
            print(f"Failed to label {node}. Error: {e.stderr.decode('utf-8')}")

# Label nodes
label_nodes([str(node.alias) for node in roles["object_recognizer"]], {"pos": "cloud"})
label_nodes([str(node.alias) for node in roles["motion_detector"]], {"pos": "edge"})
label_nodes([str(node.alias) for node in roles["camera"]], {"pos": "camera"})

docker_username = "username_placeholder"
docker_password = "password_placeholder"
docker_email = "email_placeholder"

# Create the Docker registry secret
en.run_command(f"kubectl create secret docker-registry dockerhub-secret \
  --docker-username={docker_username} \
  --docker-password={docker_password} \
  --docker-email={docker_email}", roles=roles['master'])

import os

def send_file(file_path, file_name):
    scp_command = f"scp {file_path} root@{roles['master'][0].address}:{file_name}"
    os.system(f"ssh-keygen -f /home/{G5k_username} /.ssh/known_hosts -R {roles['master'][0].address}")
    os.system(scp_command)
    return scp_command

# Send configuration files to the cluster
local_directory = "deploy/G5k/K3S/config"
for root, dirs, files in os.walk(local_directory):
    for file_name in files:
        send_file(local_directory + file_name, file_name)

# Apply Kubernetes manifests
en.run_command("kubectl apply -f deployement.yaml", roles=roles['master'])
en.run_command("kubectl apply -f configmap.yaml", roles=roles['master'])

with en.actions(roles=roles["master"]) as a:
    a.raw("curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3")
    a.raw("chmod 700 get_helm.sh")
    a.raw("./get_helm.sh")

    # Install Prometheus
    a.raw("helm --kubeconfig /etc/rancher/k3s/k3s.yaml repo add prometheus-community https://prometheus-community.github.io/helm-charts")
    a.raw("helm --kubeconfig /etc/rancher/k3s/k3s.yaml repo update")
    a.raw("helm --kubeconfig /etc/rancher/k3s/k3s.yaml install prometheus prometheus-community/prometheus -n default --set grafana.enabled=True -f costum-values.yaml")
    a.raw("helm --kubeconfig /etc/rancher/k3s/k3s.yaml upgrade --kubeconfig /etc/rancher/k3s/k3s.yaml prometheus prometheus-community/prometheus --namespace default --set prometheus-node-exporter.service.port=9500")

with en.actions(roles=roles["master"]) as a:
    a.raw("helm --kubeconfig /etc/rancher/k3s/k3s.yaml repo add chaos-mesh https://charts.chaos-mesh.org")
    a.raw("helm --kubeconfig /etc/rancher/k3s/k3s.yaml repo update")
    a.raw("helm --kubeconfig /etc/rancher/k3s/k3s.yaml install chaos-mesh chaos-mesh/chaos-mesh --set chaosDaemon.runtime=containerd --set chaosDaemon.containerdSocket=/run/containerd/containerd.sock -n default")
    a.raw("kubectl apply -f rbac.yaml")
    a.raw("kubectl create token account-default-admin-eechh")
    a.raw('kubectl patch svc chaos-dashboard -n default -p \'{"spec": {"ports": [{"name": "http", "protocol": "TCP", "port": 2333, "targetPort": 2333, "nodePort": 30312}]}}\'')

with en.actions(roles=roles["master"]) as a:
    a.raw('kubectl patch svc prometheus-server -n default -p \'{"spec": {"type": "NodePort", "ports": [{"name": "http", "port": 80, "targetPort": 9090, "nodePort": 30090}]}}\'')

def get_host(service):
    results = en.run_command(f"kubectl get pods -n kube-system -l app={service}", roles=roles['master'])
    import re
    pattern = r"host='([^']*)'"
    match = re.search(pattern, str(results))

    if match:
        host = match.group(1)
        print("Extracted host:", host)
    else:
        print("Host not found")
        return None

    results = en.run_command(f"kubectl describe node {host}", roles=roles['master'])
    pattern = r"InternalIP:\s*([\d.]+)"
    match = re.search(pattern, str(results))

    if match:
        return match.group(1)
    else:
        print("Host not found")
        return None

# Fetch the Prometheus and Chaos Dashboard IPs
url = f"http://{get_host('prometheus')}:30090"
print(f"Prometheus web page host: {url}")

url = f"http://{get_host('chaos-dashboard')}:30312"
print(f"Chaos-mesh web page host: {url}")

results = en.run_command("kubectl create token account-default-admin-eechh", roles=roles["master"])
for res in results:
    print(res.payload['stdout'])

# Cleanup the resources
provider.destroy()