STACK-RESEARCH-GROUP
Software
Edge-to-cloud video processing

Repository

git clone https://gitlab.inria.fr/sikaddou/surveillance-system-edge-to-cloud-video-processing.git
cd surveillance-system-edge-to-cloud-video-processing
docker build -t camera:latest ./services/camera
docker build -t motion_detector:latest ./services/motion_detector
docker build -t object_recognizer:latest ./services/object_recognizer
docker tag camera:latest <your-username>/camera:latest
docker tag motion_detector:latest <your-username>/motion_detector:latest
docker tag object_recognizer:latest <your-username>/object_recognizer:latest
docker login
docker push <your-username>/camera:latest
docker push <your-username>/motion_detector:latest
docker push <your-username>/object_recognizer:latest
docker pull <your-username>/camera:latest
docker pull <your-username>/motion_detector:latest
docker pull <your-username>/object_recognizer:latest
cd deploy/docker-compose
docker-compose up -d --build --force-recreate
docker-compose down --volumes --remove-orphans
docker ps
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()