skypilot-nightly 1.0.0.dev2024053101__py3-none-any.whl → 1.0.0.dev2025022801__py3-none-any.whl

sky/serve/load_balancer.py

@@ -2,7 +2,7 @@
 import asyncio
 import logging
 import threading
-from typing import Dict, Union
+from typing import Dict, Optional, Union
 
 import aiohttp
 import fastapi
@@ -27,20 +27,34 @@ class SkyServeLoadBalancer:
     policy.
     """
 
-    def __init__(self, controller_url: str, load_balancer_port: int) -> None:
+    def __init__(
+            self,
+            controller_url: str,
+            load_balancer_port: int,
+            load_balancing_policy_name: Optional[str] = None,
+            tls_credential: Optional[serve_utils.TLSCredential] = None) -> None:
         """Initialize the load balancer.
 
         Args:
             controller_url: The URL of the controller.
             load_balancer_port: The port where the load balancer listens to.
+            load_balancing_policy_name: The name of the load balancing policy
+                to use. Defaults to None.
+            tls_credentials: The TLS credentials for HTTPS endpoint. Defaults
+                to None.
         """
         self._app = fastapi.FastAPI()
         self._controller_url: str = controller_url
         self._load_balancer_port: int = load_balancer_port
-        self._load_balancing_policy: lb_policies.LoadBalancingPolicy = (
-            lb_policies.RoundRobinPolicy())
+        # Use the registry to create the load balancing policy
+        self._load_balancing_policy = lb_policies.LoadBalancingPolicy.make(
+            load_balancing_policy_name)
+        logger.info('Starting load balancer with policy '
+                    f'{load_balancing_policy_name}.')
         self._request_aggregator: serve_utils.RequestsAggregator = (
             serve_utils.RequestTimestamp())
+        self._tls_credential: Optional[serve_utils.TLSCredential] = (
+            tls_credential)
         # TODO(tian): httpx.Client has a resource limit of 100 max connections
         # for each client. We should wait for feedback on the best max
         # connections.
@@ -79,7 +93,7 @@ class SkyServeLoadBalancer:
                                 'request_aggregator':
                                     self._request_aggregator.to_dict()
                             },
-                            timeout=5,
+                            timeout=aiohttp.ClientTimeout(5),
                     ) as response:
                         # Clean up after reporting request info to avoid OOM.
                         self._request_aggregator.clear()
@@ -122,6 +136,7 @@ class SkyServeLoadBalancer:
             encountered if anything goes wrong.
         """
         logger.info(f'Proxy request to {url}')
+        self._load_balancing_policy.pre_execute_hook(url, request)
         try:
             # We defer the get of the client here on purpose, for case when the
             # replica is ready in `_proxy_with_retries` but refreshed before
@@ -141,11 +156,16 @@ class SkyServeLoadBalancer:
                 content=await request.body(),
                 timeout=constants.LB_STREAM_TIMEOUT)
             proxy_response = await client.send(proxy_request, stream=True)
+
+            async def background_func():
+                await proxy_response.aclose()
+                self._load_balancing_policy.post_execute_hook(url, request)
+
             return fastapi.responses.StreamingResponse(
                 content=proxy_response.aiter_raw(),
                 status_code=proxy_response.status_code,
                 headers=proxy_response.headers,
-                background=background.BackgroundTask(proxy_response.aclose))
+                background=background.BackgroundTask(background_func))
         except (httpx.RequestError, httpx.HTTPStatusError) as e:
             logger.error(f'Error when proxy request to {url}: '
                          f'{common_utils.format_exception(e)}')
@@ -217,15 +237,38 @@ class SkyServeLoadBalancer:
             # Register controller synchronization task
             asyncio.create_task(self._sync_with_controller())
 
+        uvicorn_tls_kwargs = ({} if self._tls_credential is None else
+                              self._tls_credential.dump_uvicorn_kwargs())
+
+        protocol = 'https' if self._tls_credential is not None else 'http'
+
         logger.info('SkyServe Load Balancer started on '
-                    f'http://0.0.0.0:{self._load_balancer_port}')
+                    f'{protocol}://0.0.0.0:{self._load_balancer_port}')
+
+        uvicorn.run(self._app,
+                    host='0.0.0.0',
+                    port=self._load_balancer_port,
+                    **uvicorn_tls_kwargs)
 
-        uvicorn.run(self._app, host='0.0.0.0', port=self._load_balancer_port)
 
+def run_load_balancer(
+        controller_addr: str,
+        load_balancer_port: int,
+        load_balancing_policy_name: Optional[str] = None,
+        tls_credential: Optional[serve_utils.TLSCredential] = None) -> None:
+    """ Run the load balancer.
 
-def run_load_balancer(controller_addr: str, load_balancer_port: int):
-    load_balancer = SkyServeLoadBalancer(controller_url=controller_addr,
-                                         load_balancer_port=load_balancer_port)
+    Args:
+        controller_addr: The address of the controller.
+        load_balancer_port: The port where the load balancer listens to.
+        policy_name: The name of the load balancing policy to use. Defaults to
+            None.
+    """
+    load_balancer = SkyServeLoadBalancer(
+        controller_url=controller_addr,
+        load_balancer_port=load_balancer_port,
+        load_balancing_policy_name=load_balancing_policy_name,
+        tls_credential=tls_credential)
     load_balancer.run()
 
 
@@ -241,5 +284,13 @@ if __name__ == '__main__':
                         required=True,
                         default=8890,
                         help='The port where the load balancer listens to.')
+    available_policies = list(lb_policies.LB_POLICIES.keys())
+    parser.add_argument(
+        '--load-balancing-policy',
+        choices=available_policies,
+        default=lb_policies.DEFAULT_LB_POLICY,
+        help=f'The load balancing policy to use. Available policies: '
+        f'{", ".join(available_policies)}.')
     args = parser.parse_args()
-    run_load_balancer(args.controller_addr, args.load_balancer_port)
+    run_load_balancer(args.controller_addr, args.load_balancer_port,
+                      args.load_balancing_policy)

sky/serve/load_balancing_policies.py

@@ -1,7 +1,9 @@
 """LoadBalancingPolicy: Policy to select endpoint."""
+import collections
 import random
+import threading
 import typing
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from sky import sky_logging
 
@@ -10,6 +12,14 @@ if typing.TYPE_CHECKING:
 
 logger = sky_logging.init_logger(__name__)
 
+# Define a registry for load balancing policies
+LB_POLICIES = {}
+DEFAULT_LB_POLICY = None
+# Prior to #4439, the default policy was round_robin. We store the legacy
+# default policy here to maintain backwards compatibility. Remove this after
+# 2 minor release, i.e., 0.9.0.
+LEGACY_DEFAULT_POLICY = 'round_robin'
+
 
 def _request_repr(request: 'fastapi.Request') -> str:
     return ('<Request '
@@ -25,6 +35,30 @@ class LoadBalancingPolicy:
     def __init__(self) -> None:
         self.ready_replicas: List[str] = []
 
+    def __init_subclass__(cls, name: str, default: bool = False):
+        LB_POLICIES[name] = cls
+        if default:
+            global DEFAULT_LB_POLICY
+            assert DEFAULT_LB_POLICY is None, (
+                'Only one policy can be default.')
+            DEFAULT_LB_POLICY = name
+
+    @classmethod
+    def make_policy_name(cls, policy_name: Optional[str]) -> str:
+        """Return the policy name."""
+        assert DEFAULT_LB_POLICY is not None, 'No default policy set.'
+        if policy_name is None:
+            return DEFAULT_LB_POLICY
+        return policy_name
+
+    @classmethod
+    def make(cls, policy_name: Optional[str] = None) -> 'LoadBalancingPolicy':
+        """Create a load balancing policy from a name."""
+        policy_name = cls.make_policy_name(policy_name)
+        if policy_name not in LB_POLICIES:
+            raise ValueError(f'Unknown load balancing policy: {policy_name}')
+        return LB_POLICIES[policy_name]()
+
     def set_ready_replicas(self, ready_replicas: List[str]) -> None:
         raise NotImplementedError
 
@@ -43,8 +77,16 @@ class LoadBalancingPolicy:
     def _select_replica(self, request: 'fastapi.Request') -> Optional[str]:
         raise NotImplementedError
 
+    def pre_execute_hook(self, replica_url: str,
+                         request: 'fastapi.Request') -> None:
+        pass
+
+    def post_execute_hook(self, replica_url: str,
+                          request: 'fastapi.Request') -> None:
+        pass
 
-class RoundRobinPolicy(LoadBalancingPolicy):
+
+class RoundRobinPolicy(LoadBalancingPolicy, name='round_robin'):
     """Round-robin load balancing policy."""
 
     def __init__(self) -> None:
@@ -68,3 +110,43 @@ class RoundRobinPolicy(LoadBalancingPolicy):
         ready_replica_url = self.ready_replicas[self.index]
         self.index = (self.index + 1) % len(self.ready_replicas)
         return ready_replica_url
+
+
+class LeastLoadPolicy(LoadBalancingPolicy, name='least_load', default=True):
+    """Least load load balancing policy."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.load_map: Dict[str, int] = collections.defaultdict(int)
+        self.lock = threading.Lock()
+
+    def set_ready_replicas(self, ready_replicas: List[str]) -> None:
+        if set(self.ready_replicas) == set(ready_replicas):
+            return
+        with self.lock:
+            self.ready_replicas = ready_replicas
+            for r in self.ready_replicas:
+                if r not in ready_replicas:
+                    del self.load_map[r]
+            for replica in ready_replicas:
+                self.load_map[replica] = self.load_map.get(replica, 0)
+
+    def _select_replica(self, request: 'fastapi.Request') -> Optional[str]:
+        del request  # Unused.
+        if not self.ready_replicas:
+            return None
+        with self.lock:
+            return min(self.ready_replicas,
+                       key=lambda replica: self.load_map.get(replica, 0))
+
+    def pre_execute_hook(self, replica_url: str,
+                         request: 'fastapi.Request') -> None:
+        del request  # Unused.
+        with self.lock:
+            self.load_map[replica_url] += 1
+
+    def post_execute_hook(self, replica_url: str,
+                          request: 'fastapi.Request') -> None:
+        del request  # Unused.
+        with self.lock:
+            self.load_map[replica_url] -= 1

sky/serve/replica_managers.py

@@ -19,9 +19,9 @@ import sky
 from sky import backends
 from sky import core
 from sky import exceptions
+from sky import execution
 from sky import global_user_state
 from sky import sky_logging
-from sky import status_lib
 from sky.backends import backend_utils
 from sky.serve import constants as serve_constants
 from sky.serve import serve_state
@@ -33,9 +33,11 @@ from sky.usage import usage_lib
 from sky.utils import common_utils
 from sky.utils import controller_utils
 from sky.utils import env_options
+from sky.utils import status_lib
 from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
+    from sky import resources
     from sky.serve import service_spec
 
 logger = sky_logging.init_logger(__name__)
@@ -94,12 +96,10 @@ def launch_cluster(replica_id: int,
         retry_cnt += 1
         try:
             usage_lib.messages.usage.set_internal()
-            sky.launch(task,
-                       cluster_name,
-                       detach_setup=True,
-                       detach_run=True,
-                       retry_until_up=True,
-                       _is_launched_by_sky_serve_controller=True)
+            execution.launch(task,
+                             cluster_name,
+                             retry_until_up=True,
+                             _is_launched_by_sky_serve_controller=True)
             logger.info(f'Replica cluster {cluster_name} launched.')
         except (exceptions.InvalidClusterNameError,
                 exceptions.NoCloudAccessError,
@@ -147,7 +147,7 @@ def terminate_cluster(cluster_name: str,
         retry_cnt += 1
         try:
             usage_lib.messages.usage.set_internal()
-            sky.down(cluster_name)
+            core.down(cluster_name)
             return
         except ValueError:
             # The cluster is already terminated.
@@ -170,12 +170,11 @@ def terminate_cluster(cluster_name: str,
 def _get_resources_ports(task_yaml: str) -> str:
     """Get the resources ports used by the task."""
     task = sky.Task.from_yaml(task_yaml)
-    # Already checked all ports are the same in sky.serve.core.up
-    assert len(task.resources) >= 1, task
-    task_resources = list(task.resources)[0]
-    # Already checked the resources have and only have one port
-    # before upload the task yaml.
-    return task_resources.ports[0]
+    # Already checked all ports are valid in sky.serve.core.up
+    assert task.resources, task
+    assert task.service is not None, task
+    assert task.service.ports is not None, task
+    return task.service.ports
 
 
 def _should_use_spot(task_yaml: str,
@@ -245,6 +244,8 @@ class ReplicaStatusProperty:
     is_scale_down: bool = False
     # The replica's spot instance was preempted.
     preempted: bool = False
+    # Whether the replica is purged.
+    purged: bool = False
 
     def remove_terminated_replica(self) -> bool:
         """Whether to remove the replica record from the replica table.
@@ -305,6 +306,8 @@ class ReplicaStatusProperty:
             return False
         if self.preempted:
             return False
+        if self.purged:
+            return False
         return True
 
     def to_replica_status(self) -> serve_state.ReplicaStatus:
@@ -488,6 +491,7 @@ class ReplicaInfo:
         self,
         readiness_path: str,
         post_data: Optional[Dict[str, Any]],
+        timeout: int,
         headers: Optional[Dict[str, str]],
     ) -> Tuple['ReplicaInfo', bool, float]:
         """Probe the readiness of the replica.
@@ -512,17 +516,15 @@ class ReplicaInfo:
             logger.info(f'Probing {replica_identity} with {readiness_path}.')
             if post_data is not None:
                 msg += 'POST'
-                response = requests.post(
-                    readiness_path,
-                    headers=headers,
-                    json=post_data,
-                    timeout=serve_constants.READINESS_PROBE_TIMEOUT_SECONDS)
+                response = requests.post(readiness_path,
+                                         json=post_data,
+                                         headers=headers,
+                                         timeout=timeout)
             else:
                 msg += 'GET'
-                response = requests.get(
-                    readiness_path,
-                    headers=headers,
-                    timeout=serve_constants.READINESS_PROBE_TIMEOUT_SECONDS)
+                response = requests.get(readiness_path,
+                                        headers=headers,
+                                        timeout=timeout)
             msg += (f' request to {replica_identity} returned status '
                     f'code {response.status_code}')
             if response.status_code == 200:
@@ -580,8 +582,6 @@ class ReplicaManager:
         self.latest_version: int = serve_constants.INITIAL_VERSION
         # Oldest version among the currently provisioned and launched replicas
         self.least_recent_version: int = serve_constants.INITIAL_VERSION
-        serve_state.add_or_update_version(self._service_name,
-                                          self.latest_version, spec)
 
     def scale_up(self,
                  resources_override: Optional[Dict[str, Any]] = None) -> None:
@@ -591,7 +591,7 @@ class ReplicaManager:
         """
         raise NotImplementedError
 
-    def scale_down(self, replica_id: int) -> None:
+    def scale_down(self, replica_id: int, purge: bool = False) -> None:
         """Scale down replica with replica_id."""
         raise NotImplementedError
 
@@ -680,7 +680,8 @@ class SkyPilotReplicaManager(ReplicaManager):
                            replica_id: int,
                            sync_down_logs: bool,
                            replica_drain_delay_seconds: int,
-                           is_scale_down: bool = False) -> None:
+                           is_scale_down: bool = False,
+                           purge: bool = False) -> None:
 
         if replica_id in self._launch_process_pool:
             info = serve_state.get_replica_info_from_id(self._service_name,
@@ -737,7 +738,8 @@ class SkyPilotReplicaManager(ReplicaManager):
                 logger.info(f'\n== End of logs (Replica: {replica_id}) ==')
                 with open(log_file_name, 'a',
                           encoding='utf-8') as replica_log_file, open(
-                              job_log_file_name, 'r',
+                              os.path.expanduser(job_log_file_name),
+                              'r',
                               encoding='utf-8') as job_file:
                     replica_log_file.write(job_file.read())
             else:
@@ -764,16 +766,18 @@ class SkyPilotReplicaManager(ReplicaManager):
         )
         info.status_property.sky_down_status = ProcessStatus.RUNNING
         info.status_property.is_scale_down = is_scale_down
+        info.status_property.purged = purge
         serve_state.add_or_update_replica(self._service_name, replica_id, info)
         p.start()
         self._down_process_pool[replica_id] = p
 
-    def scale_down(self, replica_id: int) -> None:
+    def scale_down(self, replica_id: int, purge: bool = False) -> None:
         self._terminate_replica(
             replica_id,
             sync_down_logs=False,
             replica_drain_delay_seconds=_DEFAULT_DRAIN_SECONDS,
-            is_scale_down=True)
+            is_scale_down=True,
+            purge=purge)
 
     def _handle_preemption(self, info: ReplicaInfo) -> bool:
         """Handle preemption of the replica if any error happened.
@@ -912,6 +916,8 @@ class SkyPilotReplicaManager(ReplicaManager):
                 # since user should fixed the error before update.
                 elif info.version != self.latest_version:
                     removal_reason = 'for version outdated'
+                elif info.status_property.purged:
+                    removal_reason = 'for purge'
                 else:
                     logger.info(f'Termination of replica {replica_id} '
                                 'finished. Replica info is kept since some '
@@ -972,7 +978,7 @@ class SkyPilotReplicaManager(ReplicaManager):
             if not info.status_property.should_track_service_status():
                 continue
             # We use backend API to avoid usage collection in the
-            # core.job_status.
+            # sdk.job_status.
             backend = backends.CloudVmRayBackend()
             handle = info.handle()
             assert handle is not None, info
@@ -990,9 +996,7 @@ class SkyPilotReplicaManager(ReplicaManager):
                 # Re-raise the exception if it is not preempted.
                 raise
             job_status = list(job_statuses.values())[0]
-            if job_status in [
-                    job_lib.JobStatus.FAILED, job_lib.JobStatus.FAILED_SETUP
-            ]:
+            if job_status in job_lib.JobStatus.user_code_failure_states():
                 info.status_property.user_app_failed = True
                 serve_state.add_or_update_replica(self._service_name,
                                                   info.replica_id, info)
@@ -1043,6 +1047,7 @@ class SkyPilotReplicaManager(ReplicaManager):
                         (
                             self._get_readiness_path(info.version),
                             self._get_post_data(info.version),
+                            self._get_readiness_timeout_seconds(info.version),
                             self._get_readiness_headers(info.version),
                         ),
                     ),)
@@ -1230,3 +1235,6 @@ class SkyPilotReplicaManager(ReplicaManager):
 
     def _get_initial_delay_seconds(self, version: int) -> int:
         return self._get_version_spec(version).initial_delay_seconds
+
+    def _get_readiness_timeout_seconds(self, version: int) -> int:
+        return self._get_version_spec(version).readiness_timeout_seconds

sky/serve/serve_state.py

@@ -11,22 +11,31 @@ from typing import Any, Dict, List, Optional, Tuple
 import colorama
 
 from sky.serve import constants
+from sky.serve import load_balancing_policies as lb_policies
 from sky.utils import db_utils
 
 if typing.TYPE_CHECKING:
     from sky.serve import replica_managers
     from sky.serve import service_spec
 
-_DB_PATH = pathlib.Path(constants.SKYSERVE_METADATA_DIR) / 'services.db'
-_DB_PATH = _DB_PATH.expanduser().absolute()
-_DB_PATH.parents[0].mkdir(parents=True, exist_ok=True)
-_DB_PATH = str(_DB_PATH)
+
+def _get_db_path() -> str:
+    """Workaround to collapse multi-step Path ops for type checker.
+    Ensures _DB_PATH is str, avoiding Union[Path, str] inference.
+    """
+    path = pathlib.Path(constants.SKYSERVE_METADATA_DIR) / 'services.db'
+    path = path.expanduser().absolute()
+    path.parents[0].mkdir(parents=True, exist_ok=True)
+    return str(path)
+
+
+_DB_PATH: str = _get_db_path()
 
 
 def create_table(cursor: 'sqlite3.Cursor', conn: 'sqlite3.Connection') -> None:
     """Creates the service and replica tables if they do not exist."""
 
-    # auto_restart column is deprecated.
+    # auto_restart and requested_resources column is deprecated.
     cursor.execute("""\
         CREATE TABLE IF NOT EXISTS services (
         name TEXT PRIMARY KEY,
@@ -46,28 +55,35 @@ def create_table(cursor: 'sqlite3.Cursor', conn: 'sqlite3.Connection') -> None:
         PRIMARY KEY (service_name, replica_id))""")
     cursor.execute("""\
         CREATE TABLE IF NOT EXISTS version_specs (
-        version INTEGER, 
+        version INTEGER,
         service_name TEXT,
         spec BLOB,
         PRIMARY KEY (service_name, version))""")
     conn.commit()
 
+    # Backward compatibility.
+    db_utils.add_column_to_table(cursor, conn, 'services',
+                                 'requested_resources_str', 'TEXT')
+    # Deprecated: switched to `active_versions` below for the version
+    # considered active by the load balancer. The
+    # authscaler/replica_manager version can be found in the
+    # version_specs table.
+    db_utils.add_column_to_table(
+        cursor, conn, 'services', 'current_version',
+        f'INTEGER DEFAULT {constants.INITIAL_VERSION}')
+    # The versions that is activated for the service. This is a list
+    # of integers in json format.
+    db_utils.add_column_to_table(cursor, conn, 'services', 'active_versions',
+                                 f'TEXT DEFAULT {json.dumps([])!r}')
+    db_utils.add_column_to_table(cursor, conn, 'services',
+                                 'load_balancing_policy', 'TEXT DEFAULT NULL')
+    # Whether the service's load balancer is encrypted with TLS.
+    db_utils.add_column_to_table(cursor, conn, 'services', 'tls_encrypted',
+                                 'INTEGER DEFAULT 0')
+    conn.commit()
+
 
-_DB = db_utils.SQLiteConn(_DB_PATH, create_table)
-# Backward compatibility.
-db_utils.add_column_to_table(_DB.cursor, _DB.conn, 'services',
-                             'requested_resources_str', 'TEXT')
-# Deprecated: switched to `active_versions` below for the version considered
-# active by the load balancer. The authscaler/replica_manager version can be
-# found in the version_specs table.
-db_utils.add_column_to_table(_DB.cursor, _DB.conn, 'services',
-                             'current_version',
-                             f'INTEGER DEFAULT {constants.INITIAL_VERSION}')
-# The versions that is activated for the service. This is a list of integers in
-# json format.
-db_utils.add_column_to_table(_DB.cursor, _DB.conn, 'services',
-                             'active_versions',
-                             f'TEXT DEFAULT {json.dumps([])!r}')
+db_utils.SQLiteConn(_DB_PATH, create_table)
 _UNIQUE_CONSTRAINT_FAILED_ERROR_MSG = 'UNIQUE constraint failed: services.name'
 
 
@@ -215,7 +231,7 @@ class ServiceStatus(enum.Enum):
                for status in ReplicaStatus.failed_statuses()) > 0:
             return cls.FAILED
         # When min_replicas = 0, there is no (provisioning) replica.
-        if len(replica_statuses) == 0:
+        if not replica_statuses:
             return cls.NO_REPLICA
         return cls.REPLICA_INIT
 
@@ -233,7 +249,8 @@ _SERVICE_STATUS_TO_COLOR = {
 
 
 def add_service(name: str, controller_job_id: int, policy: str,
-                requested_resources_str: str, status: ServiceStatus) -> bool:
+                requested_resources_str: str, load_balancing_policy: str,
+                status: ServiceStatus, tls_encrypted: bool) -> bool:
     """Add a service in the database.
 
     Returns:
@@ -246,10 +263,11 @@ def add_service(name: str, controller_job_id: int, policy: str,
                 """\
                 INSERT INTO services
                 (name, controller_job_id, status, policy,
-                requested_resources_str)
-                VALUES (?, ?, ?, ?, ?)""",
+                requested_resources_str, load_balancing_policy, tls_encrypted)
+                VALUES (?, ?, ?, ?, ?, ?, ?)""",
                 (name, controller_job_id, status.value, policy,
-                 requested_resources_str))
+                 requested_resources_str, load_balancing_policy,
+                 int(tls_encrypted)))
 
     except sqlite3.IntegrityError as e:
         if str(e) != _UNIQUE_CONSTRAINT_FAILED_ERROR_MSG:
@@ -315,8 +333,13 @@ def set_service_load_balancer_port(service_name: str,
 
 def _get_service_from_row(row) -> Dict[str, Any]:
     (current_version, name, controller_job_id, controller_port,
-     load_balancer_port, status, uptime, policy, _, requested_resources,
-     requested_resources_str, _, active_versions) = row[:13]
+     load_balancer_port, status, uptime, policy, _, _, requested_resources_str,
+     _, active_versions, load_balancing_policy, tls_encrypted) = row[:15]
+    if load_balancing_policy is None:
+        # This entry in database was added in #4439, and it will always be set
+        # to a str value. If it is None, it means it is an legacy entry and is
+        # using the legacy default policy.
+        load_balancing_policy = lb_policies.LEGACY_DEFAULT_POLICY
     return {
         'name': name,
         'controller_job_id': controller_job_id,
@@ -332,11 +355,9 @@ def _get_service_from_row(row) -> Dict[str, Any]:
         # The versions that is active for the load balancer. This is a list of
         # integers in json format. This is mainly for display purpose.
         'active_versions': json.loads(active_versions),
-        # TODO(tian): Backward compatibility.
-        # Remove after 2 minor release, 0.6.0.
-        'requested_resources': pickle.loads(requested_resources)
-                               if requested_resources is not None else None,
         'requested_resources_str': requested_resources_str,
+        'load_balancing_policy': load_balancing_policy,
+        'tls_encrypted': bool(tls_encrypted),
     }
 
 
@@ -525,3 +546,12 @@ def delete_version(service_name: str, version: int) -> None:
             DELETE FROM version_specs
             WHERE service_name=(?)
             AND version=(?)""", (service_name, version))
+
+
+def delete_all_versions(service_name: str) -> None:
+    """Deletes all versions from the database."""
+    with db_utils.safe_cursor(_DB_PATH) as cursor:
+        cursor.execute(
+            """\
+            DELETE FROM version_specs
+            WHERE service_name=(?)""", (service_name,))