paasta-tools 1.4.22__tar.gz → 1.4.24__tar.gz

{paasta-tools-1.4.22/paasta_tools.egg-info → paasta-tools-1.4.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.2
 Name: paasta-tools
-Version: 1.4.22
+Version: 1.4.24
 Summary: Tools for Yelps SOA infrastructure
 Home-page: UNKNOWN
 Author: Compute Infrastructure @ Yelp

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/__init__.py

@@ -17,4 +17,4 @@
 # setup phase, the dependencies may not exist on disk yet.
 #
 # Don't bump version manually. See `make release` docs in ./Makefile
-__version__ = "1.4.22"
+__version__ = "1.4.24"

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/cli/cmds/local_run.py

@@ -1209,7 +1209,10 @@ def configure_and_run_docker_container(
     if pull_image:
         docker_pull_image(docker_url)
 
-    for volume in instance_config.get_volumes(system_paasta_config.get_volumes()):
+    for volume in instance_config.get_volumes(
+        system_paasta_config.get_volumes(),
+        system_paasta_config.get_uses_bulkdata_default(),
+    ):
         if os.path.exists(volume["hostPath"]):
             volumes.append(
                 "{}:{}:{}".format(

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/cli/cmds/spark_run.py

@@ -1189,7 +1189,10 @@ def paasta_spark_run(args: argparse.Namespace) -> int:
     if docker_image_digest is None:
         return 1
 
-    volumes = instance_config.get_volumes(system_paasta_config.get_volumes())
+    volumes = instance_config.get_volumes(
+        system_paasta_config.get_volumes(),
+        system_paasta_config.get_uses_bulkdata_default(),
+    )
     app_base_name = get_spark_app_name(args.cmd or instance_config.get_cmd())
 
     user_spark_opts = _parse_user_spark_args(args.spark_args)

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/cli/cmds/status.py

@@ -95,14 +95,18 @@ from paasta_tools.utils import load_system_paasta_config
 from paasta_tools.utils import PaastaColors
 from paasta_tools.utils import remove_ansi_escape_sequences
 from paasta_tools.utils import SystemPaastaConfig
-from paasta_tools.vitesscluster_tools import VitessDeploymentConfig
+from paasta_tools.vitesscell_tools import VitessCellConfig
+from paasta_tools.vitesscluster_tools import VitessClusterConfig
+from paasta_tools.vitesskeyspace_tools import VitessKeyspaceConfig
 
 FLINK_STATUS_MAX_THREAD_POOL_WORKERS = 50
 ALLOWED_INSTANCE_CONFIG: Sequence[Type[InstanceConfig]] = [
     FlinkDeploymentConfig,
     FlinkEksDeploymentConfig,
     CassandraClusterDeploymentConfig,
-    VitessDeploymentConfig,
+    VitessClusterConfig,
+    VitessCellConfig,
+    VitessKeyspaceConfig,
     KafkaClusterDeploymentConfig,
     KubernetesDeploymentConfig,
     EksDeploymentConfig,
@@ -115,7 +119,9 @@ DEPLOYMENT_INSTANCE_CONFIG: Sequence[Type[InstanceConfig]] = [
     FlinkDeploymentConfig,
     FlinkEksDeploymentConfig,
     CassandraClusterDeploymentConfig,
-    VitessDeploymentConfig,
+    VitessClusterConfig,
+    VitessCellConfig,
+    VitessKeyspaceConfig,
     KafkaClusterDeploymentConfig,
     KubernetesDeploymentConfig,
     EksDeploymentConfig,
@@ -137,7 +143,9 @@ InstanceStatusWriter = Callable[
 EKS_DEPLOYMENT_CONFIGS = [
     EksDeploymentConfig,
     FlinkEksDeploymentConfig,
-    VitessDeploymentConfig,
+    VitessClusterConfig,
+    VitessCellConfig,
+    VitessKeyspaceConfig,
 ]
 FLINK_DEPLOYMENT_CONFIGS = [FlinkDeploymentConfig, FlinkEksDeploymentConfig]
 

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/cli/schemas/tron_schema.json

@@ -418,8 +418,17 @@
                             ]
                         },
                         "spark.driver.maxResultSize": {
-                            "type": "string",
-                            "pattern": "^[1-9]+[0-9]*[kmgt]$"
+                            "oneOf": [
+                                {
+                                    "type": "string",
+                                    "pattern": "^[1-9]+[0-9]*[kmgt]$"
+                                },
+                                {
+                                    "type": "number",
+                                    "minimum": 0,
+                                    "exclusiveMinimum": true
+                                }
+                            ]
                         },
                         "spark.scheduler.minRegisteredResourcesRatio": {
                             "type": "number",

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/cli/utils.py

@@ -76,7 +76,9 @@ from paasta_tools.utils import PAASTA_K8S_INSTANCE_TYPES
 from paasta_tools.utils import PaastaColors
 from paasta_tools.utils import SystemPaastaConfig
 from paasta_tools.utils import validate_service_instance
-from paasta_tools.vitesscluster_tools import load_vitess_instance_config
+from paasta_tools.vitesscell_tools import load_vitess_cell_instance_config
+from paasta_tools.vitesscluster_tools import load_vitess_cluster_instance_config
+from paasta_tools.vitesskeyspace_tools import load_vitess_keyspace_instance_config
 
 try:
     from vault_tools.paasta_secret import get_client as get_vault_client
@@ -680,7 +682,13 @@ INSTANCE_TYPE_HANDLERS: Mapping[str, InstanceTypeHandler] = defaultdict(
         get_service_instance_list, load_kafkacluster_instance_config
     ),
     vitesscluster=InstanceTypeHandler(
-        get_service_instance_list, load_vitess_instance_config
+        get_service_instance_list, load_vitess_cluster_instance_config
+    ),
+    vitesscell=InstanceTypeHandler(
+        get_service_instance_list, load_vitess_cell_instance_config
+    ),
+    vitesskeyspace=InstanceTypeHandler(
+        get_service_instance_list, load_vitess_keyspace_instance_config
     ),
     nrtsearchservice=InstanceTypeHandler(
         get_service_instance_list, load_nrtsearchservice_instance_config
@@ -713,7 +721,13 @@ LONG_RUNNING_INSTANCE_TYPE_HANDLERS: Mapping[
         get_service_instance_list, load_kafkacluster_instance_config
     ),
     vitesscluster=LongRunningInstanceTypeHandler(
-        get_service_instance_list, load_vitess_instance_config
+        get_service_instance_list, load_vitess_cluster_instance_config
+    ),
+    vitesscell=LongRunningInstanceTypeHandler(
+        get_service_instance_list, load_vitess_cell_instance_config
+    ),
+    vitesskeyspace=LongRunningInstanceTypeHandler(
+        get_service_instance_list, load_vitess_keyspace_instance_config
     ),
     nrtsearchservice=LongRunningInstanceTypeHandler(
         get_service_instance_list, load_nrtsearchservice_instance_config

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/frameworks/native_service_config.py

@@ -171,7 +171,8 @@ class NativeServiceConfig(LongRunningServiceConfig):
         computed separately.
         """
         docker_volumes = self.get_volumes(
-            system_volumes=system_paasta_config.get_volumes()
+            system_volumes=system_paasta_config.get_volumes(),
+            uses_bulkdata_default=system_paasta_config.get_uses_bulkdata_default(),
         )
         task: TaskInfo = {
             "name": "",

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/instance/kubernetes.py

@@ -33,7 +33,9 @@ from paasta_tools import kubernetes_tools
 from paasta_tools import monkrelaycluster_tools
 from paasta_tools import nrtsearchservice_tools
 from paasta_tools import smartstack_tools
+from paasta_tools import vitesscell_tools
 from paasta_tools import vitesscluster_tools
+from paasta_tools import vitesskeyspace_tools
 from paasta_tools.cli.utils import LONG_RUNNING_INSTANCE_TYPE_HANDLERS
 from paasta_tools.instance.hpa_metrics_parser import HPAMetricsDict
 from paasta_tools.instance.hpa_metrics_parser import HPAMetricsParser
@@ -57,6 +59,8 @@ INSTANCE_TYPES_CR = {
     "cassandracluster",
     "kafkacluster",
     "vitesscluster",
+    "vitesscell",
+    "vitesskeyspace",
 }
 INSTANCE_TYPES_K8S = {
     "cassandracluster",
@@ -72,6 +76,8 @@ INSTANCE_TYPE_CR_ID = dict(
     cassandracluster=cassandracluster_tools.cr_id,
     kafkacluster=kafkacluster_tools.cr_id,
     vitesscluster=vitesscluster_tools.cr_id,
+    vitesscell=vitesscell_tools.cr_id,
+    vitesskeyspace=vitesskeyspace_tools.cr_id,
     nrtsearchservice=nrtsearchservice_tools.cr_id,
     nrtsearchserviceeks=nrtsearchservice_tools.cr_id,
     monkrelaycluster=monkrelaycluster_tools.cr_id,

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/kubernetes_tools.py

@@ -2142,7 +2142,8 @@ class KubernetesDeploymentConfig(LongRunningServiceConfig):
             service=self.service, namespace=self.get_nerve_namespace()
         )
         docker_volumes = self.get_volumes(
-            system_volumes=system_paasta_config.get_volumes()
+            system_volumes=system_paasta_config.get_volumes(),
+            uses_bulkdata_default=system_paasta_config.get_uses_bulkdata_default(),
         )
 
         hacheck_sidecar_volumes = system_paasta_config.get_hacheck_sidecar_volumes()

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/setup_kubernetes_cr.py

@@ -49,13 +49,19 @@ from paasta_tools.utils import get_config_hash
 from paasta_tools.utils import get_git_sha_from_dockerurl
 from paasta_tools.utils import load_all_configs
 from paasta_tools.utils import load_system_paasta_config
-from paasta_tools.vitesscluster_tools import load_vitess_service_instance_configs
+from paasta_tools.vitesscell_tools import load_vitess_cell_instance_configs
+from paasta_tools.vitesscluster_tools import load_vitess_cluster_instance_configs
+from paasta_tools.vitesskeyspace_tools import load_vitess_keyspace_instance_configs
 
 
 log = logging.getLogger(__name__)
 
 
-INSTANCE_TYPE_TO_CONFIG_LOADER = {"vitesscluster": load_vitess_service_instance_configs}
+INSTANCE_TYPE_TO_CONFIG_LOADER = {
+    "vitesscluster": load_vitess_cluster_instance_configs,
+    "vitesscell": load_vitess_cell_instance_configs,
+    "vitesskeyspace": load_vitess_keyspace_instance_configs,
+}
 
 
 class StdoutKubeClient:

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/tron_tools.py

@@ -357,7 +357,10 @@ class TronActionConfig(InstanceConfig):
             paasta_service=self.get_service(),
             paasta_instance=self.get_instance(),
             docker_img=docker_img_url,
-            extra_volumes=self.get_volumes(system_paasta_config.get_volumes()),
+            extra_volumes=self.get_volumes(
+                system_paasta_config.get_volumes(),
+                uses_bulkdata_default=system_paasta_config.get_uses_bulkdata_default(),
+            ),
             use_eks=True,
             k8s_server_address=get_k8s_url_for_cluster(self.get_cluster()),
             force_spark_resource_configs=self.config_dict.get(

{paasta-tools-1.4.22 → paasta-tools-1.4.24}/paasta_tools/utils.py

@@ -137,6 +137,8 @@ INSTANCE_TYPES = (
     "cassandracluster",
     "kafkacluster",
     "vitesscluster",
+    "vitesscell",
+    "vitesskeyspace",
     "monkrelays",
     "nrtsearchservice",
     "nrtsearchserviceeks",
@@ -156,6 +158,8 @@ INSTANCE_TYPE_TO_K8S_NAMESPACE = {
     "cassandracluster": "paasta-cassandraclusters",
     "kafkacluster": "paasta-kafkaclusters",
     "vitesscluster": "paasta-vitessclusters",
+    "vitesscell": "paasta-vitessclusters",
+    "vitesskeyspace": "paasta-vitessclusters",
     "nrtsearchservice": "paasta-nrtsearchservices",
     "nrtsearchserviceeks": "paasta-nrtsearchservices",
 }
@@ -624,7 +628,8 @@ class InstanceConfig:
 
         Defaults to 1024 (1GiB) if no value is specified in the config.
 
-        :returns: The amount of disk space specified by the config, 1024 MiB if not specified"""
+        :returns: The amount of disk space specified by the config, 1024 MiB if not specified
+        """
         disk = self.config_dict.get("disk", default)
         return disk
 
@@ -979,7 +984,8 @@ class InstanceConfig:
 
         Eventually this may be implemented with Mesos roles, once a framework can register under multiple roles.
 
-        :returns: the "pool" attribute in your config dict, or the string "default" if not specified."""
+        :returns: the "pool" attribute in your config dict, or the string "default" if not specified.
+        """
         return self.config_dict.get("pool", "default")
 
     def get_pool_constraints(self) -> List[Constraint]:
@@ -998,17 +1004,17 @@ class InstanceConfig:
         """
         return self.config_dict.get("net", "bridge")
 
-    def has_bulkdata(
-        self,
-    ) -> bool:
-        return self.config_dict.get("uses_bulkdata", True)
-
-    def get_volumes(self, system_volumes: Sequence[DockerVolume]) -> List[DockerVolume]:
+    def get_volumes(
+        self, system_volumes: Sequence[DockerVolume], uses_bulkdata_default: bool = True
+    ) -> List[DockerVolume]:
         volumes = list(system_volumes) + list(self.get_extra_volumes())
         # we used to add bulkdata as a default mount - but as part of the
         # effort to deprecate the entire system, we're swapping to an opt-in
         # model so that we can shrink the blast radius of any changes
-        if self.has_bulkdata():
+        if self.config_dict.get(
+            "uses_bulkdata",
+            uses_bulkdata_default,
+        ):
             # bulkdata is mounted RO as the data is produced by another
             # system and we want to ensure that there are no inadvertent
             # changes by misbehaved code
@@ -1038,7 +1044,8 @@ class InstanceConfig:
 
         Defaults to None if not specified in the config.
 
-        :returns: A list of dictionaries specified in the dependencies_dict, None if not specified"""
+        :returns: A list of dictionaries specified in the dependencies_dict, None if not specified
+        """
         dependencies = self.config_dict.get("dependencies")
         if not dependencies:
             return None
@@ -1119,7 +1126,6 @@ def compose(
 
 
 class PaastaColors:
-
     """Collection of static variables and methods to assist in coloring text."""
 
     # ANSI color codes
@@ -2048,6 +2054,7 @@ class SystemPaastaConfigDict(TypedDict, total=False):
     vitess_tablet_types: List[str]
     vitess_tablet_pool_type_mapping: Dict
     vitess_throttling_config: Dict
+    uses_bulkdata_default: bool
 
 
 def load_system_paasta_config(
@@ -2418,7 +2425,8 @@ class SystemPaastaConfig:
         """Get a format string for the URL to query for haproxy-synapse state. This format string gets two keyword
         arguments, host and port. Defaults to "http://{host:s}:{port:d}/;csv;norefresh".
 
-        :returns: A format string for constructing the URL of haproxy-synapse's status page."""
+        :returns: A format string for constructing the URL of haproxy-synapse's status page.
+        """
         return self.config_dict.get(
             "synapse_haproxy_url_format", DEFAULT_SYNAPSE_HAPROXY_URL_FORMAT
         )
@@ -2433,7 +2441,8 @@ class SystemPaastaConfig:
         """Get a format string that constructs a DNS name pointing at the paasta masters in a cluster. This format
         string gets one parameter: cluster. Defaults to 'paasta-{cluster:s}.yelp'.
 
-        :returns: A format string for constructing the FQDN of the masters in a given cluster."""
+        :returns: A format string for constructing the FQDN of the masters in a given cluster.
+        """
         return self.config_dict.get("cluster_fqdn_format", "paasta-{cluster:s}.yelp")
 
     def get_paasta_status_version(self) -> str:
@@ -2805,6 +2814,9 @@ class SystemPaastaConfig:
             },
         )
 
+    def get_uses_bulkdata_default(self) -> bool:
+        return self.config_dict.get("uses_bulkdata_default", True)
+
 
 def _run(
     command: Union[str, List[str]],

paasta-tools-1.4.24/paasta_tools/vitesscell_tools.py

@@ -0,0 +1,289 @@
+import logging
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Mapping
+from typing import Optional
+from typing import TypedDict
+from typing import Union
+
+import service_configuration_lib
+
+from paasta_tools.kubernetes_tools import KubernetesDeploymentConfigDict
+from paasta_tools.kubernetes_tools import sanitised_cr_name
+from paasta_tools.utils import BranchDictV2
+from paasta_tools.utils import deep_merge_dictionaries
+from paasta_tools.utils import DEFAULT_SOA_DIR
+from paasta_tools.utils import load_service_instance_config
+from paasta_tools.utils import load_system_paasta_config
+from paasta_tools.utils import load_v2_deployments_json
+from paasta_tools.vitesscluster_tools import get_formatted_environment_variables
+from paasta_tools.vitesscluster_tools import KVEnvVar
+from paasta_tools.vitesscluster_tools import KVEnvVarValueFrom
+from paasta_tools.vitesscluster_tools import RequestsDict
+from paasta_tools.vitesscluster_tools import ResourceConfigDict
+from paasta_tools.vitesscluster_tools import VitessDeploymentConfig
+from paasta_tools.vitesscluster_tools import VitessDeploymentConfigDict
+
+
+log = logging.getLogger(__name__)
+log.addHandler(logging.NullHandler())
+
+
+KUBERNETES_NAMESPACE = "paasta-vitessclusters"
+
+
+# Global variables
+TOPO_IMPLEMENTATION = "zk2"
+TOPO_GLOBAL_ROOT = "/vitess-paasta/global"
+
+VTGATE_EXTRA_ENV = {
+    "VAULT_ROLEID": {
+        "secretKeyRef": {
+            "name": "paasta-vitessclusters-secret-vitess-k8s-vault-vtgate-approle-roleid",
+            "key": "vault-vtgate-approle-roleid",
+        }
+    },
+    "VAULT_SECRETID": {
+        "secretKeyRef": {
+            "name": "paasta-vitessclusters-secret-vitess-k8s-vault-vtgate-approle-secretid",
+            "key": "vault-vtgate-approle-secretid",
+        }
+    },
+}
+
+
+class GatewayConfigDict(TypedDict, total=False):
+    affinity: Dict[str, Any]
+    extraEnv: List[Union[KVEnvVar, KVEnvVarValueFrom]]
+    extraFlags: Dict[str, str]
+    extraLabels: Dict[str, str]
+    replicas: int
+    resources: Dict[str, Any]
+    annotations: Mapping[str, Any]
+
+
+class VitessCellConfigDict(VitessDeploymentConfigDict, total=False):
+    name: str
+    allCells: List[str]
+    globalLockserver: Dict[str, str]
+    gateway: GatewayConfigDict
+
+
+def get_cell_config(
+    cell: str,
+    images: Dict[str, str],
+    allCells: List[str],
+    global_lock_server: Dict[str, str],
+    region: str,
+    vtgate_resources: ResourceConfigDict,
+    env: List[Union[KVEnvVar, KVEnvVarValueFrom]],
+    labels: Dict[str, str],
+    node_affinity: dict,
+    annotations: Mapping[str, Any],
+) -> VitessCellConfigDict:
+    """
+    get vtgate config
+    """
+    replicas = vtgate_resources.get("replicas")
+    requests = vtgate_resources.get(
+        "requests", RequestsDict(cpu="100m", memory="256Mi")
+    )
+    environment_overrides: Dict[str, Any] = {
+        "VAULT_ADDR": f"https://vault-dre.{region}.yelpcorp.com:8200",
+        "VAULT_CACERT": f"/etc/vault/all_cas/acm-privateca-{region}.crt",
+    }
+    environment_overrides.update(VTGATE_EXTRA_ENV)
+    updated_vtgate_extra_env = (
+        get_formatted_environment_variables(environment_overrides) + env
+    )
+
+    config = VitessCellConfigDict(
+        name=cell,
+        images=images,
+        allCells=allCells,
+        globalLockserver=global_lock_server,
+        gateway=GatewayConfigDict(
+            affinity={"nodeAffinity": node_affinity},
+            extraEnv=updated_vtgate_extra_env,
+            extraFlags={
+                "mysql_auth_server_impl": "vault",
+                "mysql_auth_vault_addr": f"https://vault-dre.{region}.yelpcorp.com:8200",
+                "mysql_auth_vault_path": "secrets/vitess/vt-gate/vttablet_credentials.json",
+                "mysql_auth_vault_tls_ca": f"/etc/vault/all_cas/acm-privateca-{region}.crt",
+                "mysql_auth_vault_ttl": "60s",
+            },
+            extraLabels=labels,
+            replicas=replicas,
+            resources={
+                "requests": requests,
+                "limits": requests,
+            },
+            annotations=annotations,
+        ),
+    )
+    return config
+
+
+class VitessCellInstanceConfigDict(KubernetesDeploymentConfigDict, total=False):
+    cell: str
+    cells: List[str]
+    zk_address: str
+    vtgate_resources: ResourceConfigDict
+    images: Dict[str, str]
+
+
+class VitessCellConfig(VitessDeploymentConfig):
+    config_dict: VitessCellInstanceConfigDict
+
+    config_filename_prefix = "vitesscell"
+
+    def __init__(
+        self,
+        service: str,
+        cluster: str,
+        instance: str,
+        config_dict: VitessCellConfigDict,
+        branch_dict: Optional[BranchDictV2],
+        soa_dir: str = DEFAULT_SOA_DIR,
+    ) -> None:
+        super().__init__(
+            cluster=cluster,  # superregion
+            instance=instance,  # host-1
+            service=service,  # vitess
+            soa_dir=soa_dir,
+            config_dict=config_dict,
+            branch_dict=branch_dict,
+        )
+
+    def get_images(self) -> Dict[str, str]:
+        vitess_images = self.config_dict.get(
+            "images", load_system_paasta_config().get_vitess_images()
+        )
+        return {
+            "vtctld": vitess_images["vtctld_image"],
+            "vtadmin": vitess_images["vtadmin_image"],
+            "vtgate": vitess_images["vtgate_image"],
+            "vttablet": vitess_images["vttablet_image"],
+        }
+
+    def get_global_lock_server(self) -> Dict[str, str]:
+        zk_address = self.config_dict.get("zk_address")
+        return {
+            "implementation": TOPO_IMPLEMENTATION,
+            "address": zk_address,
+            "rootPath": TOPO_GLOBAL_ROOT,
+        }
+
+    def get_vitess_cell_config(self) -> VitessCellConfigDict:
+        cell = self.config_dict.get("cell")
+        all_cells = self.config_dict.get("cells")
+        images = self.get_images()
+        global_lock_server = self.get_global_lock_server()
+        region = self.get_region()
+        vtgate_resources = self.config_dict.get("vtgate_resources")
+
+        formatted_env = self.get_env_variables()
+        labels = self.get_labels()
+        node_affinity = self.get_vitess_node_affinity()
+        annotations = self.get_annotations()
+
+        return get_cell_config(
+            cell,
+            images,
+            all_cells,
+            global_lock_server,
+            region,
+            vtgate_resources,
+            formatted_env,
+            labels,
+            node_affinity,
+            annotations,
+        )
+
+    def validate(
+        self,
+        params: List[str] = [
+            "cpus",
+            "security",
+            "dependencies_reference",
+            "deploy_group",
+        ],
+    ) -> List[str]:
+        # Use InstanceConfig to validate shared config keys like cpus and mem
+        # TODO: add mem back to this list once we fix PAASTA-15582 and
+        # move to using the same units as flink/marathon etc.
+        error_msgs = super().validate(params=params)
+
+        if error_msgs:
+            name = self.get_instance()
+            return [f"{name}: {msg}" for msg in error_msgs]
+        else:
+            return []
+
+
+def load_vitess_cell_instance_config(
+    service: str,
+    instance: str,
+    cluster: str,
+    load_deployments: bool = True,
+    soa_dir: str = DEFAULT_SOA_DIR,
+) -> VitessCellConfig:
+    general_config = service_configuration_lib.read_service_configuration(
+        service, soa_dir=soa_dir
+    )
+    instance_config = load_service_instance_config(
+        service, instance, "vitesscell", cluster, soa_dir=soa_dir
+    )
+    general_config = deep_merge_dictionaries(
+        overrides=instance_config, defaults=general_config
+    )
+
+    branch_dict: Optional[BranchDictV2] = None
+    if load_deployments:
+        deployments_json = load_v2_deployments_json(service, soa_dir=soa_dir)
+        temp_instance_config = VitessCellConfig(
+            service=service,
+            cluster=cluster,
+            instance=instance,
+            config_dict=general_config,
+            branch_dict=None,
+            soa_dir=soa_dir,
+        )
+        branch = temp_instance_config.get_branch()
+        deploy_group = temp_instance_config.get_deploy_group()
+        branch_dict = deployments_json.get_branch_dict(service, branch, deploy_group)
+
+    vitess_cell_config = VitessCellConfig(
+        service=service,
+        cluster=cluster,
+        instance=instance,
+        config_dict=general_config,
+        branch_dict=branch_dict,
+        soa_dir=soa_dir,
+    )
+
+    return vitess_cell_config
+
+
+def load_vitess_cell_instance_configs(
+    service: str,
+    instance: str,
+    cluster: str,
+    soa_dir: str = DEFAULT_SOA_DIR,
+) -> VitessCellConfigDict:
+    vitess_cell_instance_configs = load_vitess_cell_instance_config(
+        service, instance, cluster, soa_dir=soa_dir
+    ).get_vitess_cell_config()
+    return vitess_cell_instance_configs
+
+
+# TODO: read this from CRD in service configs
+def cr_id(service: str, instance: str) -> Mapping[str, str]:
+    return dict(
+        group="planetscale.com",
+        version="v2",
+        namespace=KUBERNETES_NAMESPACE,
+        plural="vitesscells",
+        name=sanitised_cr_name(service, instance),
+    )