diff --git a/src/emuvim/api/rest/compute.py b/src/emuvim/api/rest/compute.py
index dc2b611..8d46aa2 100755
--- a/src/emuvim/api/rest/compute.py
+++ b/src/emuvim/api/rest/compute.py
@@ -29,6 +29,7 @@
 from flask_restful import Resource
 from flask import request
 import json
+from copy import deepcopy
 
 logging.basicConfig(level=logging.INFO)
 
@@ -51,10 +52,6 @@
     global dcs
 
     def put(self, dc_label, compute_name, resource=None, value=None):
-        # check if resource update
-        if resource and value:
-           c = self._update_resource(dc_label, compute_name, resource, value)
-           return c.getStatus(), 200
 
         # deploy new container
         # check if json data is a dict
@@ -79,20 +76,6 @@
             logging.exception("API error.")
             return ex.message, 500, CORS_HEADER
 
-    def _update_resource(self, dc_label, compute_name, resource, value):
-        #check if container exists
-        d = dcs.get(dc_label).net.getNodeByName(compute_name)
-        if resource == 'cpu':
-            cpu_period = int(dcs.get(dc_label).net.cpu_period)
-            cpu_quota = int(cpu_period * float(value))
-            #put default values back
-            if float(value) <= 0:
-                cpu_period = 100000
-                cpu_quota = -1
-            d.updateCpuLimit(cpu_period=cpu_period, cpu_quota=cpu_quota)
-        return d
-
-
     def get(self, dc_label, compute_name):
 
         logging.debug("API CALL: compute status")
@@ -151,6 +134,74 @@
             logging.exception("API error.")
             return ex.message, 500, CORS_HEADER
 
+class ComputeResources(Resource):
+    """
+    Update the container's resources using the docker.update function
+    re-using the same parameters:
+        url params:
+           blkio_weight
+           cpu_period, cpu_quota, cpu_shares
+           cpuset_cpus
+           cpuset_mems
+           mem_limit
+           mem_reservation
+           memswap_limit
+           kernel_memory
+           restart_policy
+    see https://docs.docker.com/engine/reference/commandline/update/
+    or API docs: https://docker-py.readthedocs.io/en/stable/api.html#module-docker.api.container
+    :param dc_label: name of the DC
+    :param compute_name: compute container name
+
+    :return: docker inspect dict of deployed docker
+    """
+    global dcs
+
+    def put(self, dc_label, compute_name):
+        logging.debug("REST CALL: update container resources")
+
+        try:
+            c = self._update_resources(dc_label, compute_name)
+            return c.getStatus(), 200, CORS_HEADER
+        except Exception as ex:
+            logging.exception("API error.")
+            return ex.message, 500, CORS_HEADER
+
+    def _update_resources(self, dc_label, compute_name):
+
+        # get URL parameters
+        params = request.args
+        # then no data
+        if params is None:
+            params = {}
+        logging.debug("REST CALL: update container resources {0}".format(params))
+        #check if container exists
+        d = dcs.get(dc_label).net.getNodeByName(compute_name)
+
+        # general request of cpu percentage
+        # create a mutable copy
+        params = params.to_dict()
+        if 'cpu_bw' in params:
+            cpu_period = int(dcs.get(dc_label).net.cpu_period)
+            value = params.get('cpu_bw')
+            cpu_quota = int(cpu_period * float(value))
+            #put default values back
+            if float(value) <= 0:
+                cpu_period = 100000
+                cpu_quota = -1
+            params['cpu_period'] = cpu_period
+            params['cpu_quota'] = cpu_quota
+            #d.updateCpuLimit(cpu_period=cpu_period, cpu_quota=cpu_quota)
+
+        # only pass allowed keys to docker
+        allowed_keys = ['blkio_weight', 'cpu_period', 'cpu_quota', 'cpu_shares', 'cpuset_cpus',
+                        'cpuset_mems', 'mem_limit', 'mem_reservation', 'memswap_limit',
+                        'kernel_memory', 'restart_policy']
+        filtered_params = {key:params[key] for key in allowed_keys if key in params}
+
+        d.update_resources(**filtered_params)
+
+        return d
 
 class DatacenterList(Resource):
     global dcs
diff --git a/src/emuvim/api/rest/rest_api_endpoint.py b/src/emuvim/api/rest/rest_api_endpoint.py
index 0ecf548..fc48a33 100755
--- a/src/emuvim/api/rest/rest_api_endpoint.py
+++ b/src/emuvim/api/rest/rest_api_endpoint.py
@@ -32,7 +32,7 @@
 
 # need to import total module to set its global variable dcs
 import compute
-from compute import dcs, ComputeList, Compute, DatacenterList, DatacenterStatus
+from compute import dcs, ComputeList, Compute, ComputeResources, DatacenterList, DatacenterStatus
 
 # need to import total module to set its global variable net
 import network
@@ -62,12 +62,11 @@
         # setup endpoints
 
         # compute related actions (start/stop VNFs, get info)
-        self.api.add_resource(Compute,
-                              "/restapi/compute/<dc_label>/<compute_name>",
-                              "/restapi/compute/<dc_label>/<compute_name>/<resource>/<value>")
+        self.api.add_resource(Compute, "/restapi/compute/<dc_label>/<compute_name>")
         self.api.add_resource(ComputeList,
                       "/restapi/compute",
                       "/restapi/compute/<dc_label>")
+        self.api.add_resource(ComputeResources, "/restapi/compute/resources/<dc_label>/<compute_name>")
 
         self.api.add_resource(DatacenterStatus, "/restapi/datacenter/<dc_label>")
         self.api.add_resource(DatacenterList, "/restapi/datacenter")
diff --git a/src/emuvim/dcemulator/monitoring.py b/src/emuvim/dcemulator/monitoring.py
index de96e37..269a7e0 100755
--- a/src/emuvim/dcemulator/monitoring.py
+++ b/src/emuvim/dcemulator/monitoring.py
@@ -606,6 +606,7 @@
             while not started:
                 list1 = self.dockercli.containers.list(filters={'status': 'running', 'name': 'prometheus'})
                 if len(list1) >= 1:
+                    time.sleep(1)
                     started = True
                 if wait_time > 5:
                     return 'skewmon not started'
diff --git a/src/emuvim/dcemulator/node.py b/src/emuvim/dcemulator/node.py
index 2702bf5..c5ac9b3 100755
--- a/src/emuvim/dcemulator/node.py
+++ b/src/emuvim/dcemulator/node.py
@@ -82,12 +82,12 @@
         status["docker_network"] = self.dcinfo['NetworkSettings']['IPAddress']
         status["image"] = self.dimage
         status["flavor_name"] = self.flavor_name
-        status["cpu_quota"] = self.cpu_quota
-        status["cpu_period"] = self.cpu_period
-        status["cpu_shares"] = self.cpu_shares
-        status["cpuset"] = self.cpuset
-        status["mem_limit"] = self.mem_limit
-        status["memswap_limit"] = self.memswap_limit
+        status["cpu_quota"] = self.resources.get('cpu_quota')
+        status["cpu_period"] = self.resources.get('cpu_period')
+        status["cpu_shares"] = self.resources.get('cpu_shares')
+        status["cpuset"] = self.resources.get('cpuset_cpus')
+        status["mem_limit"] = self.resources.get('mem_limit')
+        status["memswap_limit"] = self.resources.get('memswap_limit')
         status["state"] = self.dcli.inspect_container(self.dc)["State"]
         status["id"] = self.dcli.inspect_container(self.dc)["Id"]
         status["short_id"] = self.dcli.inspect_container(self.dc)["Id"][:12]
diff --git a/src/emuvim/dcemulator/resourcemodel/upb/simple.py b/src/emuvim/dcemulator/resourcemodel/upb/simple.py
index 5f260d6..79db24a 100755
--- a/src/emuvim/dcemulator/resourcemodel/upb/simple.py
+++ b/src/emuvim/dcemulator/resourcemodel/upb/simple.py
@@ -164,7 +164,7 @@
         # calculate input values for CFS scheduler bandwidth limitation
         cpu_period, cpu_quota = self._calculate_cpu_cfs_values(cpu_time_percentage)
         # apply limits to container if changed
-        if d.cpu_period != cpu_period or d.cpu_quota != cpu_quota:
+        if d.resources['cpu_period'] != cpu_period or d.resources['cpu_quota'] != cpu_quota:
             LOG.debug("Setting CPU limit for %r: cpu_quota = cpu_period * limit = %f * %f = %f (op_factor=%f)" % (
                       d.name, cpu_period, cpu_time_percentage, cpu_quota, self.cpu_op_factor))
             d.updateCpuLimit(cpu_period=int(cpu_period), cpu_quota=int(cpu_quota))
@@ -210,7 +210,7 @@
         mem_limit = self.single_mu * number_mu
         mem_limit = self._calculate_mem_limit_value(mem_limit)
         # apply to container if changed
-        if d.mem_limit != mem_limit:
+        if d.resources['mem_limit'] != mem_limit:
             LOG.debug("Setting MEM limit for %r: mem_limit = %f MB (op_factor=%f)" %
                       (d.name, mem_limit/1024/1024, self.mem_op_factor))
             d.updateMemoryLimit(mem_limit=mem_limit)
diff --git a/src/emuvim/test/unittests/test_resourcemodel.py b/src/emuvim/test/unittests/test_resourcemodel.py
index b15fed0..4a21fee 100755
--- a/src/emuvim/test/unittests/test_resourcemodel.py
+++ b/src/emuvim/test/unittests/test_resourcemodel.py
@@ -96,17 +96,24 @@
     class DummyContainer(object):
 
         def __init__(self):
-            self.cpu_period = -1
-            self.cpu_quota = -1
-            self.mem_limit = -1
-            self.memswap_limit = -1
+            # take defaukt values from son-emu
+            self.resources = dict(
+            cpu_period = -1,
+            cpu_quota = -1,
+            mem_limit = -1,
+            memswap_limit = -1
+            )
+            #self.cpu_period = self.resources['cpu_period']
+            #self.cpu_quota = self.resources['cpu_quota']
+            #self.mem_limit = self.resources['mem_limit']
+            #self.memswap_limit = self.resources['memswap_limit']
 
         def updateCpuLimit(self, cpu_period, cpu_quota):
-            self.cpu_period = cpu_period
-            self.cpu_quota = cpu_quota
+            self.resources['cpu_period'] = cpu_period
+            self.resources['cpu_quota'] = cpu_quota
 
         def updateMemoryLimit(self, mem_limit):
-            self.mem_limit = mem_limit
+            self.resources['mem_limit'] = mem_limit
 
     d = DummyContainer()
     d.name = name
@@ -138,28 +145,28 @@
 
         c1 = createDummyContainerObject("c1", flavor="tiny")
         rm.allocate(c1)  # calculate allocation
-        self.assertEqual(float(c1.cpu_quota) / c1.cpu_period, E_CPU / MAX_CU * 0.5)   # validate compute result
-        self.assertEqual(float(c1.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 32)   # validate memory result
+        self.assertEqual(float(c1.resources['cpu_quota']) / c1.resources['cpu_period'], E_CPU / MAX_CU * 0.5)   # validate compute result
+        self.assertEqual(float(c1.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 32)   # validate memory result
 
         c2 = createDummyContainerObject("c2", flavor="small")
         rm.allocate(c2)  # calculate allocation
-        self.assertEqual(float(c2.cpu_quota) / c2.cpu_period, E_CPU / MAX_CU * 1)   # validate compute result
-        self.assertEqual(float(c2.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128)   # validate memory result
+        self.assertEqual(float(c2.resources['cpu_quota']) / c2.resources['cpu_period'], E_CPU / MAX_CU * 1)   # validate compute result
+        self.assertEqual(float(c2.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 128)   # validate memory result
 
         c3 = createDummyContainerObject("c3", flavor="medium")
         rm.allocate(c3)  # calculate allocation
-        self.assertEqual(float(c3.cpu_quota) / c3.cpu_period, E_CPU / MAX_CU * 4)   # validate compute result
-        self.assertEqual(float(c3.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 256)   # validate memory result
+        self.assertEqual(float(c3.resources['cpu_quota']) / c3.resources['cpu_period'], E_CPU / MAX_CU * 4)   # validate compute result
+        self.assertEqual(float(c3.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 256)   # validate memory result
 
         c4 = createDummyContainerObject("c4", flavor="large")
         rm.allocate(c4)  # calculate allocation
-        self.assertEqual(float(c4.cpu_quota) / c4.cpu_period, E_CPU / MAX_CU * 8)   # validate compute result
-        self.assertEqual(float(c4.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 512)   # validate memory result
+        self.assertEqual(float(c4.resources['cpu_quota']) / c4.resources['cpu_period'], E_CPU / MAX_CU * 8)   # validate compute result
+        self.assertEqual(float(c4.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 512)   # validate memory result
 
         c5 = createDummyContainerObject("c5", flavor="xlarge")
         rm.allocate(c5)  # calculate allocation
-        self.assertEqual(float(c5.cpu_quota) / c5.cpu_period, E_CPU / MAX_CU * 16)   # validate compute result
-        self.assertEqual(float(c5.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 1024)   # validate memory result
+        self.assertEqual(float(c5.resources['cpu_quota']) / c5.resources['cpu_period'], E_CPU / MAX_CU * 16)   # validate compute result
+        self.assertEqual(float(c5.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 1024)   # validate memory result
 
 
     def testAllocationCpuLimit(self):
@@ -273,7 +280,7 @@
 
         # check if there is a real limitation set for containers cgroup
         # deactivated for now, seems not to work in docker-in-docker setup used in CI
-        self.assertEqual(float(tc1.cpu_quota)/tc1.cpu_period, 0.005)
+        self.assertEqual(float(tc1.resources['cpu_quota'])/tc1.resources['cpu_period'], 0.005)
 
         # check if free was called during stopCompute
         self.dc[0].stopCompute("tc1")
@@ -306,33 +313,33 @@
 
         c1 = createDummyContainerObject("c1", flavor="small")
         rm.allocate(c1)  # calculate allocation
-        self.assertAlmostEqual(float(c1.cpu_quota) / c1.cpu_period, E_CPU / MAX_CU * 1.0, places=5)
-        self.assertAlmostEqual(float(c1.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128)
+        self.assertAlmostEqual(float(c1.resources['cpu_quota']) / c1.resources['cpu_period'], E_CPU / MAX_CU * 1.0, places=5)
+        self.assertAlmostEqual(float(c1.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 128)
         self.assertAlmostEqual(rm.cpu_op_factor, 1.0)
 
         c2 = createDummyContainerObject("c2", flavor="small")
         rm.allocate(c2)  # calculate allocation
-        self.assertAlmostEqual(float(c2.cpu_quota) / c2.cpu_period, E_CPU / MAX_CU * 1.0, places=5)
-        self.assertAlmostEqual(float(c2.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128)
+        self.assertAlmostEqual(float(c2.resources['cpu_quota']) / c2.resources['cpu_period'], E_CPU / MAX_CU * 1.0, places=5)
+        self.assertAlmostEqual(float(c2.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 128)
         self.assertAlmostEqual(rm.cpu_op_factor, 1.0)
 
         c3 = createDummyContainerObject("c3", flavor="small")
         rm.allocate(c3)  # calculate allocation
-        self.assertAlmostEqual(float(c3.cpu_quota) / c3.cpu_period, E_CPU / MAX_CU * 1.0, places=5)
-        self.assertAlmostEqual(float(c3.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128)
+        self.assertAlmostEqual(float(c3.resources['cpu_quota']) / c3.resources['cpu_period'], E_CPU / MAX_CU * 1.0, places=5)
+        self.assertAlmostEqual(float(c3.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 128)
         self.assertAlmostEqual(rm.cpu_op_factor, 1.0)
 
         # from this container onwards, we should go to over provisioning mode:
         c4 = createDummyContainerObject("c4", flavor="small")
         rm.allocate(c4)  # calculate allocation
-        self.assertAlmostEqual(float(c4.cpu_quota) / c4.cpu_period, E_CPU / MAX_CU * (float(3) / 4), places=5)
-        self.assertAlmostEqual(float(c4.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128, places=5)
+        self.assertAlmostEqual(float(c4.resources['cpu_quota']) / c4.resources['cpu_period'], E_CPU / MAX_CU * (float(3) / 4), places=5)
+        self.assertAlmostEqual(float(c4.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 128, places=5)
         self.assertAlmostEqual(rm.cpu_op_factor, 0.75)
 
         c5 = createDummyContainerObject("c5", flavor="small")
         rm.allocate(c5)  # calculate allocation
-        self.assertAlmostEqual(float(c5.cpu_quota) / c5.cpu_period, E_CPU / MAX_CU * (float(3) / 5), places=5)
-        self.assertAlmostEqual(float(c5.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128)
+        self.assertAlmostEqual(float(c5.resources['cpu_quota']) / c5.resources['cpu_period'], E_CPU / MAX_CU * (float(3) / 5), places=5)
+        self.assertAlmostEqual(float(c5.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 128)
         self.assertAlmostEqual(rm.cpu_op_factor, 0.6)
 
 
diff --git a/utils/docker/Dockerfile b/utils/docker/Dockerfile
index b5a94af..eac132c 100755
--- a/utils/docker/Dockerfile
+++ b/utils/docker/Dockerfile
@@ -51,8 +51,10 @@
 RUN echo 'install son-emu'
 RUN apt-get install -y  python-dev python-zmq libzmq-dev libffi-dev libssl-dev
 RUN pip install -U zerorpc tabulate argparse networkx six ryu oslo.config pytest Flask flask_restful requests prometheus_client pyaml
-WORKDIR / 
-RUN git clone https://github.com/sonata-nfv/son-emu.git
+WORKDIR /
+#avoid pulling not the latest git, copy the current dir, to run this from Jenkins
+#RUN git clone https://github.com/sonata-nfv/son-emu.git
+COPY . /son-emu
 WORKDIR son-emu/
 RUN python setup.py develop
 WORKDIR /