added metrics

faas/commands.txt

+ssh cs695@http://10.129.131.202
+passwd:1234
+
+sudo vi /etc/nginx/conf.d/loadbalancer.conf
+
+systemctl restart nginx

faas/example2/Dockerfile

+FROM python:3.9-slim
+
+RUN mkdir /app
+# Set the working directory in the container
+WORKDIR /app
+
+ADD . /app/
+# Copy the function code into the container
+COPY function.py .
+
+# Install any dependencies
+RUN pip install -r requirements.txt
+RUN pip install prometheus_client
+RUN pip install psutil
+
+EXPOSE 5000
+# Define the command to run the function
+CMD ["python", "/app/function.py"]
+

faas/example2/function.py

+from flask import Flask
+from prometheus_client import Counter, Gauge, start_http_server
+from prometheus_client import generate_latest, CONTENT_TYPE_LATEST, CollectorRegistry
+import psutil
+import time
+
+app = Flask(__name__)
+
+# Define Prometheus metrics
+function_requests_total = Counter('function_requests_total', 'Total number of requests to the function')
+cpu_utilization_gauge = Gauge('cpu_utilization_percentage', 'CPU utilization percentage')
+request_rate_gauge = Gauge('function_request_rate', 'Function request rate (requests per second)')
+service_time_gauge = Gauge('function_service_time_seconds', 'Service time of the function in seconds')
+network_bytes_sent = Counter('network_bytes_sent_total', 'Total number of bytes sent over the network')
+network_bytes_recv = Counter('network_bytes_received_total', 'Total number of bytes received over the network')
+
+
+start_time=time.time()
+
+@app.route("/clear_metrics")
+def clear_metrics():
+    function_requests_total._value.set(0)
+    cpu_utilization_gauge.set(0)
+    service_time_gauge.set(0)
+    network_bytes_sent._value.set(0)
+    network_bytes_recv._value.set(0)
+    start_time=time.time()
+    registry = CollectorRegistry()
+    return generate_latest(registry), 200, {"Content-Type": CONTENT_TYPE_LATEST}
+
+
+@app.route("/")
+def hello():
+    time_invoked=time.time()
+
+    # Increment request counter
+    function_requests_total.inc()
+
+    time.sleep(0.1)
+    
+
+    service_time = time.time() - time_invoked
+
+    service_time_gauge.set(service_time)
+    
+    # Collect CPU utilization
+    cpu_utilization = psutil.cpu_percent()
+    cpu_utilization_gauge.set(cpu_utilization)
+
+
+    return "Hello from Python function"
+
+@app.route("/metrics")
+def metrics():
+    registry = CollectorRegistry()
+    # Register your Prometheus metrics collectors here
+    # For example:
+    # registry.register(...)
+
+    elapsed_time = time.time() - start_time
+
+    registry.register(function_requests_total)
+    registry.register(cpu_utilization_gauge)
+    registry.register(service_time_gauge)
+    registry.register(network_bytes_sent)
+    registry.register(network_bytes_recv)
+    
+
+    metric=generate_latest(registry)
+    for line in metric.decode().split("\n"):
+        if "function_requests_total" in line:
+            try:
+                value = float(line.split()[1])
+                request_rate = value/elapsed_time
+            except:
+                pass
+        if "function_requests_total" in line:
+            try:
+                no_of_requests = float(line.split()[1])
+            except:
+                pass
+        if "cpu_utilization_percentage" in line:
+            try:
+                cpu_utilization = float(line.split()[1])
+            except:
+                pass
+        if "function_service_time_seconds" in line:
+            try:
+                service_time= float(line.split()[1])
+            except:
+                pass
+
+        if "network_bytes_sent_total" in line:
+            try:
+                bytes_sent= float(line.split()[1])
+            except:
+                pass
+        if "network_bytes_received_total" in line:
+            try:
+                bytes_received= float(line.split()[1])
+            except:
+                pass
+    request_rate_gauge.set(request_rate)
+    registry.register(request_rate_gauge)
+
+
+    network_stats = psutil.net_io_counters()
+    network_bytes_sent.inc(network_stats.bytes_sent)
+    network_bytes_recv.inc(network_stats.bytes_recv)
+
+
+    print("Number of Requests: ",no_of_requests)
+    print("Request_rate: ",request_rate)
+    print("Service Time: ",service_time)
+    print("CPU utilization: ",cpu_utilization)
+    print("Bytes send: ",bytes_sent)
+    print("Bytes received: ",bytes_received)
+
+    return generate_latest(registry), 200, {"Content-Type": CONTENT_TYPE_LATEST}
+
+
+if __name__ == "__main__":
+    # Start Prometheus HTTP server to expose metrics
+    start_http_server(8000)
+    
+    # Run Flask app
+    app.run(host='0.0.0.0')

faas/example2/requirements.txt

+Flask

faas/ingress.yaml

+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: example-ingress
+spec:
+  rules:
+  - host: exmample1-service.com
+    http:
+      paths:
+      - path: /example1
+        pathType: Prefix
+        backend:
+          service:
+            name: example1-service
+            port:
+              number: 8080

faas/public_key.asc

+-----BEGIN PGP PUBLIC KEY BLOCK-----
+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+=I71U
+-----END PGP PUBLIC KEY BLOCK-----

faas/test-deploy.py

@@ -10,81 +10,117 @@ config.load_kube_config()
 k8s_client = client.ApiClient()
 
 # Docker Hub username (replace with your Docker Hub username)
-docker_username = "msanth"
+docker_username = "gsiva333"
 
 def build_and_push_image(function_name):
     """
     Build the Docker image and push it to Docker Hub.
     """
-    # Change directory to function directory
-    os.chdir(function_name)
+    try:
+        # Change directory to function directory
+        os.chdir(function_name)
     
-    # Build Docker image
-    subprocess.run(["docker", "build", "-t", f"{docker_username}/{function_name}:latest", "."], check=True)
+        # Build Docker image
+        subprocess.run(["docker", "build", "-t", f"{docker_username}/{function_name}:latest", "."], check=True)
     
-    # Push Docker image to Docker Hub
-    subprocess.run(["docker", "push", f"{docker_username}/{function_name}:latest"], check=True)
+        # Push Docker image to Docker Hub
+        subprocess.run(["docker", "push", f"{docker_username}/{function_name}:latest"], check=True)
     
-    # Change back to original directory
-    os.chdir("..")
+    except subprocess.CalledProcessError as e:
+        print(f"Error occurred while building/pushing Docker image: {e}")
+
+    finally:
+        # Change back to original directory
+        os.chdir("..")
+
 
 def create_deployment(function_name):
     """
     Create a Kubernetes Deployment resource for the function.
     """
-    deployment_manifest = {
-        "apiVersion": "apps/v1",
-        "kind": "Deployment",
-        "metadata": {"name": function_name},
-        "spec": {
-            "replicas": 1,
-            "selector": {"matchLabels": {"app": function_name}},
-            "template": {
-                "metadata": {"labels": {"app": function_name}},
-                "spec": {
-                    "containers": [{
-                        "name": function_name,
-                        "image": f"{docker_username}/{function_name}:latest",
-                        "ports": [{"containerPort": 5000}]  # Assuming function listens on port 8080
-                    }]
+    try:
+        deployment_manifest = {
+            "apiVersion": "apps/v1",
+            "kind": "Deployment",
+            "metadata": {"name": function_name},
+            "spec": {
+                "replicas": 1,
+                "selector": {"matchLabels": {"app": function_name}},
+                "template": {
+                    "metadata": {"labels": {"app": function_name}},
+                    "spec": {
+                        "containers": [{
+                            "name": function_name,
+                            "image": f"{docker_username}/{function_name}:latest",
+                            "ports": [{"containerPort": 5000}]  # Assuming function listens on port 8080
+                        }]
+                    }
                 }
             }
         }
-    }
 
-    #yourusername Create Deployment in Kubernetes
-    api_instance = client.AppsV1Api(k8s_client)
-    api_instance.create_namespaced_deployment(namespace="default", body=deployment_manifest)
-    print(f"Deployment created for {function_name}.")
+        #yourusername Create Deployment in Kubernetes
+        api_instance = client.AppsV1Api(k8s_client)
+        api_instance.create_namespaced_deployment(namespace="default", body=deployment_manifest)
+        print(f"Deployment created for {function_name}.")
+    except client.rest.ApiException as e:
+        print(f"Error occurred while creating Deployment: {e}")
 
 def create_service(function_name):
     """
     Create a Kubernetes Service resource for the function.
     """
-    service_manifest = {
-        "apiVersion": "v1",
-        "kind": "Service",
-        "metadata": {"name": f"{function_name}-service"},
-        "spec": {
-            "selector": {"app": function_name},
-            "ports": [{"protocol": "TCP", "port": 8080, "targetPort": 5000}],  # Assuming function listens on port 8080
-            "type": "LoadBalancer"  # Expose service only within the cluster
+    try:
+        service_manifest = {
+            "apiVersion": "v1",
+            "kind": "Service",
+            "metadata": {"name": f"{function_name}-service"},
+            "spec": {
+                "selector": {"app": function_name},
+                "ports": [{"protocol": "TCP", "port": 8080, "targetPort": 5000}],  # Assuming function listens on port 8080
+                "type": "LoadBalancer"  # Expose service only within the cluster
+            }
         }
-    }
 
-    # Create Service in Kubernetes
-    #k8s_client.create_namespaced_service(namespace="default", body=service_manifest)
-    api_instance = client.CoreV1Api()
-    api_instance.create_namespaced_service(namespace="default", body=service_manifest)
-    print(f"Service created for {function_name}.")
+        # Create Service in Kubernetes
+        #k8s_client.create_namespaced_service(namespace="default", body=service_manifest)
+        api_instance = client.CoreV1Api()
+        api_instance.create_namespaced_service(namespace="default", body=service_manifest)
+        print(f"Service created for {function_name}.")
+    except client.rest.ApiException as e:
+        print(f"Error occurred while creating Service: {e}")
 
+"""
+def get_external_ip(service_name):
+   
+    try:
+        # Wait for the external IP to be assigned
+        while True:
+            service = api_instance.read_namespaced_service(name=service_name, namespace="default")
+            if service.status.load_balancer.ingress:
+                external_ip = service.status.load_balancer.ingress[0].ip
+                if external_ip:
+                    return external_ip
+            time.sleep(5)  # Wait for 5 seconds before checking again
+    except client.rest.ApiException as e:
+        print(f"Error occurred while getting external IP: {e}")
+"""
 def deploy_function(function_name):
     """
     Deploy the function to Kubernetes.
     """
-    build_and_push_image(function_name)
-    create_deployment(function_name)
-    create_service(function_name)
+    try:
+        build_and_push_image(function_name)
+        create_deployment(function_name)
+        create_service(function_name)
+
+        # Wait for the external IP to be assigned
+        #external_ip = get_external_ip(f"{function_name}-service")
+        #print(f"External IP for {function_name}-service: {external_ip}")
+
+        
+    except Exception as e:
+        print(f"Error occurred during deployment of {function_name}: {e}")
 
 if __name__ == "__main__":
     function_name = input("Enter the name of the function directory: ")

faas/test-deploy1.py

+import os
+import subprocess
+import yaml
+import time
+from kubernetes import client, config
+
+# Load Kubernetes configuration from default location
+config.load_kube_config()
+
+# Kubernetes API client
+k8s_client = client.ApiClient()
+
+# Docker Hub username (replace with your Docker Hub username)
+docker_username = "gsiva333"
+
+def build_and_push_image(function_name):
+    """
+    Build the Docker image and push it to Docker Hub.
+    """
+    try:
+        # Change directory to function directory
+        os.chdir(function_name)
+    
+        # Build Docker image
+        subprocess.run(["docker", "build", "-t", f"{docker_username}/{function_name}:latest", "."], check=True)
+    
+        # Push Docker image to Docker Hub
+        subprocess.run(["docker", "push", f"{docker_username}/{function_name}:latest"], check=True)
+    
+    except subprocess.CalledProcessError as e:
+        print(f"Error occurred while building/pushing Docker image: {e}")
+
+    finally:
+        # Change back to original directory
+        os.chdir("..")
+
+
+def create_deployment(function_name):
+    """
+    Create a Kubernetes Deployment resource for the function.
+    """
+    try:
+        deployment_manifest = {
+            "apiVersion": "apps/v1",
+            "kind": "Deployment",
+            "metadata": {"name": function_name},
+            "spec": {
+                "replicas": 1,
+                "selector": {"matchLabels": {"app": function_name}},
+                "template": {
+                    "metadata": {"labels": {"app": function_name}},
+                    "spec": {
+                        "containers": [{
+                            "name": function_name,
+                            "image": f"{docker_username}/{function_name}:latest",
+                            "ports": [{"containerPort": 5000}]  # Assuming function listens on port 8080
+                        }]
+                    }
+                }
+            }
+        }
+
+        #yourusername Create Deployment in Kubernetes
+        api_instance = client.AppsV1Api(k8s_client)
+        api_instance.create_namespaced_deployment(namespace="default", body=deployment_manifest)
+        print(f"Deployment created for {function_name}.")
+    except client.rest.ApiException as e:
+        print(f"Error occurred while creating Deployment: {e}")
+
+def create_service(function_name):
+    """
+    Create a Kubernetes Service resource for the function.
+    """
+    try:
+        service_manifest = {
+            "apiVersion": "v1",
+            "kind": "Service",
+            "metadata": {"name": f"{function_name}-service"},
+            "spec": {
+                "selector": {"app": function_name},
+                "ports": [{"protocol": "TCP", "port": 8080, "targetPort": 5000}],  # Assuming function listens on port 8080
+                "type": "LoadBalancer"  # Expose service only within the cluster
+            }
+        }
+
+        # Create Service in Kubernetes
+        #k8s_client.create_namespaced_service(namespace="default", body=service_manifest)
+        api_instance = client.CoreV1Api()
+        api_instance.create_namespaced_service(namespace="default", body=service_manifest)
+        print(f"Service created for {function_name}.")
+    except client.rest.ApiException as e:
+        print(f"Error occurred while creating Service: {e}")
+
+
+def get_external_ip(service_name):
+    """
+    Get the external IP of the service.
+    """
+    try:
+        # Wait for the external IP to be assigned
+        api_instance = client.CoreV1Api()
+
+        while True:
+            service = api_instance.read_namespaced_service(name=service_name, namespace="default")
+            if service.status.load_balancer.ingress:
+                external_ip = service.status.load_balancer.ingress[0].ip
+                if external_ip:
+                    return external_ip
+            time.sleep(5)  # Wait for 5 seconds before checking again
+    except client.rest.ApiException as e:
+        print(f"Error occurred while getting external IP: {e}")
+
+def deploy_function(function_name):
+    """
+    Deploy the function to Kubernetes.
+    """
+    try:
+        build_and_push_image(function_name)
+        create_deployment(function_name)
+        create_service(function_name)
+
+        # Wait for the external IP to be assigned
+        #external_ip = get_external_ip(f"{function_name}-service")
+        #print(f"External IP for {function_name}-service: {external_ip}")
+
+        
+    except Exception as e:
+        print(f"Error occurred during deployment of {function_name}: {e}")
+
+if __name__ == "__main__":
+    function_name = input("Enter the name of the function directory: ")
+    deploy_function(function_name)
+

faas/test.py

 from flask import Flask, request, jsonify
 from kubernetes import client, config, watch
-from prometheus_client import Counter, Gauge, generate_latest, CONTENT_TYPE_LATEST
+from prometheus_client import Counter, Gauge, generate_latest, CONTENT_TYPE_LATEST, Histogram
 from prometheus_client.exposition import make_wsgi_app
 from werkzeug.middleware.dispatcher import DispatcherMiddleware
 import threading
@@ -20,37 +20,43 @@ app = Flask(__name__)
 # Prometheus metrics
 function_invocation_counter = Counter('function_invocation_count', 'Number of function invocations', ['function_name'])
 function_request_rate_gauge = Gauge('function_request_rate', 'Request rate for functions', ['function_name'])
+cpu_utilization_gauge= Gauge('cpu_utilization','CPU utilization for functions',['function_name'])
+storage_utilization_gauge = Gauge('storage_utilization', 'Storage utilization for functions', ['function_name'])
+service_time_histogram = Histogram('service_time_seconds', 'Service time for functions', ['function_name'])
 
 
 def deploy_function(function_name, image):
-    """
+    """         
     Deploy a function to Kubernetes as a Deployment.
     """
     # Define deployment spec
-    deployment_spec = {
-        'apiVersion': 'apps/v1',
-        'kind': 'Deployment',
-        'metadata': {'name': function_name},
-        'spec': {
-            'replicas': 1,
-            'selector': {'matchLabels': {'app': function_name}},
-            'template': {
-                'metadata': {'labels': {'app': function_name}},
-                'spec': {
-                    'containers': [{
-                        'name': function_name,
-                        'image': image,
-                        'ports': [{'containerPort': 5000}]
-                    }]
+    try:
+        deployment_spec = {
+            'apiVersion': 'apps/v1',
+            'kind': 'Deployment',
+            'metadata': {'name': function_name},
+            'spec': {
+                'replicas': 1,
+                'selector': {'matchLabels': {'app': function_name}},
+                'template': {
+                    'metadata': {'labels': {'app': function_name}},
+                    'spec': {
+                        'containers': [{
+                            'name': function_name,
+                            'image': image,
+                            'ports': [{'containerPort': 5000}]
+                        }]
+                    }
                 }
             }
         }
-    }
 
-    # Create deployment in Kubernetes
-    api_instance = client.AppsV1Api(k8s_client)
-    api_instance.create_namespaced_deployment(namespace='default', body=deployment_spec)
-    print(f"Function {function_name} deployed with image {image}.")
+        # Create deployment in Kubernetes
+        api_instance = client.AppsV1Api(k8s_client)
+        api_instance.create_namespaced_deployment(namespace='default', body=deployment_spec)
+        print(f"Function {function_name} deployed with image {image}.")
+    except Exception as e:
+        print(f"Error deploying {function_name}: {e}")
 
 
 def scale_function(function_name, replicas):
@@ -58,27 +64,30 @@ def scale_function(function_name, replicas):
     Scale the number of replicas for a function in Kubernetes.
     """
     # Define HPA spec
-    hpa_spec = {
-        'apiVersion': 'autoscaling/v1',
-        'kind': 'HorizontalPodAutoscaler',
-        'metadata': {'name': f'{function_name}-hpa'},
-        'spec': {
-            'scaleTargetRef': {
-                'apiVersion': 'apps/v1',
-                'kind': 'Deployment',
-                'name': function_name
-            },
-            'minReplicas': 1,
-            'maxReplicas': replicas,
-            'targetCPUUtilizationPercentage': 50  # Adjust as needed
+    try:
+        hpa_spec = {
+            'apiVersion': 'autoscaling/v1',
+            'kind': 'HorizontalPodAutoscaler',
+            'metadata': {'name': f'{function_name}-hpa'},
+            'spec': {
+                'scaleTargetRef': {
+                    'apiVersion': 'apps/v1',
+                    'kind': 'Deployment',
+                    'name': function_name
+                },
+                'minReplicas': 1,
+                'maxReplicas': replicas,
+                'targetCPUUtilizationPercentage': 50  # Adjust as needed
+            }
         }
-    }
 
-    # Create HPA in Kubernetes
-    #api_instance = client.CoreV1Api()
-    api_instance = client.AutoscalingV1Api(k8s_client)
-    api_instance.create_namespaced_horizontal_pod_autoscaler(namespace='default', body=hpa_spec)
-    print(f"Function {function_name} auto-scaler created with max replicas {replicas}.")
+        # Create HPA in Kubernetes
+        #api_instance = client.CoreV1Api()
+        api_instance = client.AutoscalingV1Api(k8s_client)
+        api_instance.create_namespaced_horizontal_pod_autoscaler(namespace='default', body=hpa_spec)
+        print(f"Function {function_name} auto-scaler created with max replicas {replicas}.")
+    except Exception as e:
+        print(f"Error scaling {function_name}: {e}")
 
 
 def handle_function(event):
@@ -141,8 +150,12 @@ def invoke_function():
     function_request_rate_gauge.labels(function_name=function_name).inc()
     # Increment invocation count for function
     function_invocation_counter.labels(function_name=function_name).inc()
+    start_time=time.time()
     # Invoke function
     result = invoke_kubernetes_function(function_name)
+    end_time=time.time()
+    service_time=end_time-start_time
+    service_time_histogram.labels(function_name=function_name).observe(service_time)
     return jsonify({'message': f"Function {function_name} invoked. Result: {result}"})
 
 
@@ -168,6 +181,7 @@ def invoke_kubernetes_function(function_name):
     except requests.exceptions.RequestException as e:
         return f"Error: {e}"
 
+@app.route('/metrics')
 def metrics_app(environ, start_response):
     """
     Serve Prometheus metrics.