feat(controller): add KUBERNETES_CPU_MEMORY_RATIO parameter

Author: duanhongyi

rootfs/api/models/app.py

@@ -640,8 +640,8 @@ def deploy(self, release, force_deploy=False, rollback_on_failure=True):  # noqa
         release.cleanup_old()
 
     def _set_default_config(self):
-        default_cpu = "{}m".format(settings.KUBERNETES_LIMITS_DEFAULT_CPU)
-        default_memory = "{}M".format(settings.KUBERNETES_LIMITS_DEFAULT_MEMORY)
+        default_cpu = "{}m".format(settings.KUBERNETES_LIMITS_MIN_CPU)
+        default_memory = "{}M".format(settings.KUBERNETES_LIMITS_MIN_MEMORY)
         config = self.config_set.latest()
         new_cpu, new_memory = {}, {}
         for _type in self.types:

rootfs/api/models/config.py

@@ -1,8 +1,11 @@
 import json
+import math
 import logging
+from decimal import Decimal
 from django.conf import settings
 from django.db import models
 from django.contrib.auth import get_user_model
+from api.utils import unit_to_bytes, unit_to_millicpu
 from api.models.release import Release
 from api.models import UuidAuditedModel
 from api.exceptions import DryccException, UnprocessableEntity
@@ -84,6 +87,55 @@ def get_healthcheck(self):
             return {'web/cmd': self.healthcheck}
         return self.healthcheck
 
+    def _set_cpu_memory(self):
+        """
+        According to settings.KUBERNETES_CPU_MEMORY_RATIO corrects cpu and memory
+        """
+        radio = settings.KUBERNETES_CPU_MEMORY_RATIO
+        limit_min_cpu = settings.KUBERNETES_LIMITS_MIN_CPU
+        limit_max_cpu = settings.KUBERNETES_LIMITS_MAX_CPU
+        limit_min_memory = Decimal(settings.KUBERNETES_LIMITS_MIN_MEMORY * math.pow(1024, 2))
+        limit_max_memory = Decimal(settings.KUBERNETES_LIMITS_MAX_MEMORY * math.pow(1024, 2))
+        memory_cpu_min_radio = Decimal(unit_to_bytes(radio[0])) / Decimal(unit_to_millicpu('1'))
+        memory_cpu_max_radio = Decimal(unit_to_bytes(radio[1])) / Decimal(unit_to_millicpu('1'))
+        cpu_memory_min_radio = Decimal(unit_to_millicpu('1')) / Decimal(unit_to_bytes(radio[1]))
+        cpu_memory_max_radio = Decimal(unit_to_millicpu('1')) / Decimal(unit_to_bytes(radio[0]))
+        for container_type in set(
+                self.app.structure.keys()).union(set(self.cpu)).union(set(self.memory)):
+            if container_type in self.cpu:
+                cpu = unit_to_millicpu(self.cpu[container_type])
+                min_memory = cpu * memory_cpu_min_radio
+                min_memory = limit_min_memory if min_memory < limit_min_memory else min_memory
+                max_memory = cpu * memory_cpu_max_radio
+                max_memory = limit_max_memory if max_memory > limit_max_memory else max_memory
+                if self.memory.get(container_type):
+                    memory = unit_to_bytes(self.memory.get(container_type))
+                    if memory < min_memory:
+                        memory = min_memory
+                    elif memory > max_memory:
+                        memory = max_memory
+                else:
+                    memory = min_memory
+                if memory % Decimal(math.pow(1024, 3)) == 0:
+                    self.memory[container_type] = f'{round(memory / Decimal(math.pow(1024, 3)))}G'
+                else:
+                    self.memory[container_type] = f'{round(memory / Decimal(math.pow(1024, 2)))}M'
+            elif container_type in self.memory:
+                memory = Decimal(unit_to_bytes(self.memory[container_type]))
+                if container_type not in self.cpu:
+                    min_cpu = memory * cpu_memory_min_radio
+                    min_cpu = limit_min_cpu if min_cpu < limit_min_cpu else min_cpu
+                    max_cpu = memory * cpu_memory_max_radio
+                    max_cpu = limit_max_cpu if max_cpu > limit_max_cpu else max_cpu
+                    cpu = max_cpu if min_cpu < 1000 else min_cpu
+                    if cpu % 1000 == 0:
+                        self.cpu[container_type] = f'{round(cpu / 1000)}'
+                    else:
+                        self.cpu[container_type] = f'{round(cpu)}m'
+            else:
+                self.cpu[container_type] = f"{settings.KUBERNETES_LIMITS_MIN_CPU}m"
+                self.memory[container_type] = f"{settings.KUBERNETES_LIMITS_MIN_MEMORY}M"
+
     def set_registry(self):
         # lower case all registry options for consistency
         self.registry = {key.lower(): value for key, value in self.registry.copy().items()}
@@ -185,6 +237,7 @@ def save(self, **kwargs):
                     else:
                         data[key] = value
                 setattr(self, attr, data)
+            self._set_cpu_memory()
             self.set_healthcheck(previous_config)
             self._migrate_legacy_healthcheck()
             self.set_registry()

rootfs/api/serializers.py

@@ -310,7 +310,7 @@ def validate_values(data):
     def validate_memory(data):
         max_memory = settings.KUBERNETES_LIMITS_MAX_MEMORY
         # The minimum limit memory is equal to the memory allocated by default
-        min_memory = settings.KUBERNETES_LIMITS_DEFAULT_MEMORY
+        min_memory = settings.KUBERNETES_LIMITS_MIN_MEMORY
         for key, value in data.items():
             if value is None:  # use NoneType to unset an item
                 continue
@@ -336,7 +336,7 @@ def validate_memory(data):
     def validate_cpu(data):
         max_cpu = settings.KUBERNETES_LIMITS_MAX_CPU
         # The minimum CPU limit is equal to the CPU allocated by default
-        min_cpu = settings.KUBERNETES_LIMITS_DEFAULT_CPU
+        min_cpu = settings.KUBERNETES_LIMITS_MIN_CPU
         for key, value in data.items():
             if value is None:  # use NoneType to unset an item
                 continue

rootfs/api/settings/production.py

@@ -13,7 +13,7 @@
 sys.path.insert(0, os.path.join(BASE_DIR, 'apps_extra'))
 # A boolean that turns on/off debug mode.
 # https://docs.djangoproject.com/en/1.11/ref/settings/#debug
-DEBUG = bool(os.environ.get('DRYCC_DEBUG', False))
+DEBUG = bool(strtobool(os.environ.get('DRYCC_DEBUG', 'false')))
 
 # If set to True, Django's normal exception handling of view functions
 # will be suppressed, and exceptions will propagate upwards
@@ -277,7 +277,7 @@
 
 PLATFORM_DOMAIN = os.environ.get('DRYCC_PLATFORM_DOMAIN', 'local.drycc.cc')
 
-IMAGE_PULL_POLICY = os.environ.get('IMAGE_PULL_POLICY', "IfNotPresent")  # noqa
+IMAGE_PULL_POLICY = os.environ.get('IMAGE_PULL_POLICY', "IfNotPresent")
 
 # True, true, yes, y and more evaluate to True
 # False, false, no, n and more evaluate to False
@@ -290,7 +290,8 @@
 # If the user has a Procfile in both deploys then processes are scaled up / down as per usual
 #
 # By default the process types are scaled down unless this setting is turned on
-DRYCC_DEPLOY_PROCFILE_MISSING_REMOVE = bool(strtobool(os.environ.get('DRYCC_DEPLOY_PROCFILE_MISSING_REMOVE', 'true')))  # noqa
+DRYCC_DEPLOY_PROCFILE_MISSING_REMOVE = bool(strtobool(os.environ.get(
+    'DRYCC_DEPLOY_PROCFILE_MISSING_REMOVE', 'true')))
 
 # True, true, yes, y and more evaluate to True
 # False, false, no, n and more evaluate to False
@@ -300,7 +301,8 @@
 # If a previous deploy had a Procfile but then the following deploy has no Procfile then it will
 # result in a 406 - Not Acceptable
 # Has priority over DRYCC_DEPLOY_PROCFILE_MISSING_REMOVE
-DRYCC_DEPLOY_REJECT_IF_PROCFILE_MISSING = bool(strtobool(os.environ.get('DRYCC_DEPLOY_REJECT_IF_PROCFILE_MISSING', 'false')))  # noqa
+DRYCC_DEPLOY_REJECT_IF_PROCFILE_MISSING = bool(strtobool(os.environ.get(
+    'DRYCC_DEPLOY_REJECT_IF_PROCFILE_MISSING', 'false')))
 
 # Define a global default on how many pods to bring up and then
 # take down sequentially during a deploy
@@ -324,29 +326,31 @@
 
 DRYCC_APP_STORAGE_CLASS = os.environ.get('DRYCC_APP_STORAGE_CLASS', "")
 
-KUBERNETES_DEPLOYMENTS_REVISION_HISTORY_LIMIT = os.environ.get('KUBERNETES_DEPLOYMENTS_REVISION_HISTORY_LIMIT', None)  # noqa
-
 DRYCC_DEFAULT_CONFIG_TAGS = os.environ.get('DRYCC_DEFAULT_CONFIG_TAGS', '')
 
+KUBERNETES_DEPLOYMENTS_REVISION_HISTORY_LIMIT = os.environ.get(
+    'KUBERNETES_DEPLOYMENTS_REVISION_HISTORY_LIMIT', None)
+
 # How long k8s waits for a pod to finish work after a SIGTERM before sending SIGKILL
-KUBERNETES_POD_TERMINATION_GRACE_PERIOD_SECONDS = int(os.environ.get('KUBERNETES_POD_TERMINATION_GRACE_PERIOD_SECONDS', 30))  # noqa
+KUBERNETES_POD_TERMINATION_GRACE_PERIOD_SECONDS = int(os.environ.get(
+    'KUBERNETES_POD_TERMINATION_GRACE_PERIOD_SECONDS', 30))
 
+# min and max memory for a CPU
+KUBERNETES_CPU_MEMORY_RATIO = tuple(map(lambda x: x.strip(), os.environ.get(
+    'DRYCC_CPU_MEMORY_DISTRIBUTION_RATIO', '1G,4G').split(",")))
 # CPU request ratio
 KUBERNETES_REQUEST_CPU_RATIO = int(os.environ.get('KUBERNETES_REQUEST_CPU_RATIO', '10'))
 # Memory request ratio
 KUBERNETES_REQUEST_MEMORY_RATIO = int(os.environ.get('KUBERNETES_REQUEST_MEMORY_RATIO', '2'))
-# Minimum limits cpu, units are represented in the millicpu of CPUs
-KUBERNETES_LIMITS_MIN_CPU = int(os.environ.get('KUBERNETES_LIMITS_MIN_CPU', '9'))
-# Minimum limits memory, units are represented in Megabytes(M)
-KUBERNETES_LIMITS_MIN_MEMORY = int(os.environ.get('KUBERNETES_LIMITS_MIN_MEMORY', '63'))
-# Maximum limits cpu, units are represented in the millicpu of CPUs
-KUBERNETES_LIMITS_MAX_CPU = int(os.environ.get('KUBERNETES_LIMITS_MAX_CPU', '32000'))
-# Maximum limits memory, units are represented in Megabytes(M)
-KUBERNETES_LIMITS_MAX_MEMORY = int(os.environ.get('KUBERNETES_LIMITS_MAX_MEMORY', '131072'))
-# Default CPU limit, units are represented in the millicpu of CPUs
-KUBERNETES_LIMITS_DEFAULT_CPU = (KUBERNETES_LIMITS_MIN_CPU + 1) * KUBERNETES_REQUEST_CPU_RATIO
-# Default Memory limit, units are represented in Megabytes(M)
-KUBERNETES_LIMITS_DEFAULT_MEMORY = (KUBERNETES_LIMITS_MIN_MEMORY + 1) * KUBERNETES_REQUEST_MEMORY_RATIO  # noqa
+
+# Minimum CPU limit, units are represented in the millicpu of CPUs
+KUBERNETES_LIMITS_MIN_CPU = 125
+# Minimum CPU limit, units are represented in the millicpu of CPUs
+KUBERNETES_LIMITS_MAX_CPU = 32 * 1000
+# Minimum Memory limit, units are represented in Megabytes(M)
+KUBERNETES_LIMITS_MIN_MEMORY = 128
+# Minimum Memory limit
+KUBERNETES_LIMITS_MAX_MEMORY = 128 * 1024
 
 # Default pod spec for application.
 KUBERNETES_POD_DEFAULT_RESOURCES = os.environ.get(
@@ -366,39 +370,7 @@
 )
 # Default limit range spec for application namespace
 KUBERNETES_NAMESPACE_DEFAULT_LIMIT_RANGES_SPEC = os.environ.get(
-    'KUBERNETES_NAMESPACE_DEFAULT_LIMIT_RANGES_SPEC',
-    json.dumps({
-        "limits": [
-            {
-                "default": {
-                    "cpu": "%sm" % KUBERNETES_LIMITS_DEFAULT_CPU,
-                    "memory": "%sMi" % KUBERNETES_LIMITS_DEFAULT_MEMORY
-                },
-                "defaultRequest": {
-                    "cpu": "%sm" % (KUBERNETES_LIMITS_MIN_CPU + 1),
-                    "memory": "%sMi" % (KUBERNETES_LIMITS_MIN_MEMORY + 1)
-                },
-                "max": {
-                    "cpu": "%sm" % KUBERNETES_LIMITS_MAX_CPU,
-                    "memory": "%sMi" % KUBERNETES_LIMITS_MAX_MEMORY
-                },
-                "min": {
-                    "cpu": "%sm" % KUBERNETES_LIMITS_MIN_CPU,
-                    "memory": "%sMi" % KUBERNETES_LIMITS_MIN_MEMORY
-                },
-                "type": "Container"
-            },
-            {
-                "max": {
-                    "storage": "100Gi"
-                },
-                "min": {
-                    "storage": "100Mi"
-                },
-                "type": "PersistentVolumeClaim"
-            }
-        ]
-    })
+    'KUBERNETES_NAMESPACE_DEFAULT_LIMIT_RANGES_SPEC', ''
 )
 
 # registry settings
@@ -463,8 +435,10 @@
 CACHES = {
     "default": {
         "BACKEND": "django_redis.cache.RedisCache",
-        "LOCATION": ['redis://:{}@{}'.format(DRYCC_REDIS_PASSWORD, DRYCC_REDIS_ADDR) \
-                     for DRYCC_REDIS_ADDR in DRYCC_REDIS_ADDRS],  # noqa
+        "LOCATION": [
+            'redis://:{}@{}'.format(
+                DRYCC_REDIS_PASSWORD, DRYCC_REDIS_ADDR) for DRYCC_REDIS_ADDR in DRYCC_REDIS_ADDRS
+        ],
         "OPTIONS": {
             "CLIENT_CLASS": "django_redis.client.ShardClient",
         }

rootfs/api/tests/test_config.py

@@ -195,7 +195,7 @@ def test_response_data_types_converted(self, mock_requests):
             'owner': self.user.username,
             'app': app_id,
             'values': {'PORT': '5000'},
-            'memory': {},
+            'memory': {'web': '1G'},
             'cpu': {'web': "1000m"},
             'tags': {},
             'registry': {}

rootfs/api/tests/test_limits.py

@@ -104,7 +104,7 @@ def test_request_limit(self, mock_requests):
         self.assertNotEqual(limit1['uuid'], limit2['uuid'])
         memory = response.data['memory']
         self.assertIn('worker', memory)
-        self.assertEqual(memory['worker'], '512M')
+        self.assertEqual(memory['worker'], '2G')
         self.assertIn('web', memory)
         self.assertEqual(memory['web'], '1G')
         cpu = response.data['cpu']
@@ -120,7 +120,7 @@ def test_request_limit(self, mock_requests):
         self.assertEqual(limit2, limit3)
         memory = response.data['memory']
         self.assertIn('worker', memory)
-        self.assertEqual(memory['worker'], '512M')
+        self.assertEqual(memory['worker'], '2G')
         self.assertIn('web', memory)
         self.assertEqual(memory['web'], '1G')
         cpu = response.data['cpu']
@@ -141,7 +141,7 @@ def test_request_limit(self, mock_requests):
         self.assertEqual(response.status_code, 200, response.data)
         memory = response.data['memory']
         self.assertIn('worker', memory)
-        self.assertEqual(memory['worker'], '512M')
+        self.assertEqual(memory['worker'], '2G')
         self.assertIn('web', memory)
         self.assertEqual(memory['web'], '1G')
         cpu = response.data['cpu']
@@ -160,7 +160,7 @@ def test_request_limit(self, mock_requests):
         self.assertEqual(response.status_code, 200, response.data)
         memory = response.data['memory']
         self.assertIn('worker', memory)
-        self.assertEqual(memory['worker'], '512M')
+        self.assertEqual(memory['worker'], '2G')
         self.assertIn('web', memory)
         self.assertEqual(memory['web'], '1G')
         self.assertIn('db', memory)
@@ -183,7 +183,7 @@ def test_request_limit(self, mock_requests):
         self.assertEqual(response.status_code, 200, response.data)
         memory = response.data['memory']
         self.assertIn('worker', memory)
-        self.assertEqual(memory['worker'], '512M')
+        self.assertEqual(memory['worker'], '2G')
         self.assertIn('web', memory)
         self.assertEqual(memory['web'], '3G')
         self.assertIn('db', memory)
@@ -206,7 +206,10 @@ def test_request_limit(self, mock_requests):
         self.assertEqual(cpu['db'], '1000m')
 
         # unset a value
-        body = {'memory': json.dumps({'worker': None})}
+        body = {
+            'cpu': json.dumps({'worker': None}),
+            'memory': json.dumps({'worker': None})
+        }
         response = self.client.post(url, body)
         self.assertEqual(response.status_code, 201, response.data)
         limit4 = response.data
@@ -240,7 +243,7 @@ def test_request_limit(self, mock_requests):
         body = {'cpu': json.dumps({'web': '1000'})}
         response = self.client.post(url, body)
         self.assertEqual(response.status_code, 400, response.data)
-        body = {'cpu': json.dumps({'web': '100m'})}
+        body = {'cpu': json.dumps({'web': '125m'})}
         response = self.client.post(url, body)
         self.assertEqual(response.status_code, 201, response.data)