code: def start(
      detached: bool = True,
      proxy_location: Union[None, str, ProxyLocation] = None,
      http_options: Union[None, dict, HTTPOptions] = None,
      dedicated_cpu: bool = False,
      grpc_options: Union[None, dict, gRPCOptions] = None,
      logging_config: Union[None, dict, LoggingConfig] = None,
      **kwargs,
  ):
      """Start Serve on the cluster.
  
      Used to set cluster-scoped configurations such as HTTP options. In most cases, this
      does not need to be called manually and Serve will be started when an application is
      first deployed to the cluster.
  
      These cluster-scoped options cannot be updated dynamically. To update them, start a
      new cluster or shut down Serve on the cluster and start it again.
  
      These options can also be set in the config file deployed via REST API.
  
      Args:
          proxy_location: Where to run proxies that handle ingress traffic to the
            cluster (defaults to every node in the cluster with at least one replica on
            it). See `ProxyLocation` for supported options.
          http_options: HTTP config options for the proxies. These can be passed as an
            unstructured dictionary or the structured `HTTPOptions` class. See
            `HTTPOptions` for supported options.
          grpc_options: [EXPERIMENTAL] gRPC config options for the proxies. These can
            be passed as an unstructured dictionary or the structured `gRPCOptions`
            class See `gRPCOptions` for supported options.
          logging_config: logging config options for the serve component (
              controller & proxy).
      """
  
      if detached is not True:
          raise ValueError(
              "`detached=False` is no longer supported. "
              "In a future release, it will be removed altogether."
          )
  
      if dedicated_cpu is not False:
          raise ValueError(
              "`dedicated_cpu=True` is no longer supported. "
              "In a future release, it will be removed altogether."
          )
  
      if proxy_location is None:
          if http_options is None:
              http_options = HTTPOptions(
                  location=DeploymentMode.EveryNode
              )
      else:
          if http_options is None:
              http_options = HTTPOptions()
          elif isinstance(http_options, dict):
              http_options = HTTPOptions(**http_options)
  
          if isinstance(proxy_location, str):
              proxy_location = ProxyLocation(proxy_location)
  
          http_options.location = ProxyLocation._to_deployment_mode(
              proxy_location
          )
  
      _private_api.serve_start(
          http_options=http_options,
          grpc_options=grpc_options,
          global_logging_config=logging_config,
          **kwargs,
      )
  
imports: import collections
  import inspect
  import logging
  import warnings
  from functools import wraps
  from typing import Any, Callable, Dict, List, Optional, Union
  from fastapi import APIRouter, FastAPI
  import ray
  from ray import cloudpickle
  from ray._private.serialization import pickle_dumps
  from ray.dag import DAGNode
  from ray.serve._private.config import DeploymentConfig, ReplicaConfig
  from ray.serve._private.constants import DEFAULT_HTTP_HOST, DEFAULT_HTTP_PORT, SERVE_DEFAULT_APP_NAME
  from ray.serve._private.deployment_graph_build import build
  from ray.serve._private.deployment_graph_build import get_and_validate_ingress_deployment
  from ray.serve._private.http_util import ASGIAppReplicaWrapper, make_fastapi_class_based_view
  from ray.serve._private.usage import ServeUsageTag
  from ray.serve._private.utils import DEFAULT, Default, ensure_serialization_context, extract_self_if_method_call, get_random_string
  from ray.serve.config import AutoscalingConfig, DeploymentMode, HTTPOptions, ProxyLocation, gRPCOptions
  from ray.serve.context import ReplicaContext, _get_global_client, _get_internal_replica_context, _set_global_client
  from ray.serve.deployment import Application, Deployment
  from ray.serve.exceptions import RayServeException
  from ray.serve.handle import DeploymentHandle
  from ray.serve.multiplex import _ModelMultiplexWrapper
  from ray.serve.schema import LoggingConfig, ServeInstanceDetails, ServeStatus
  from ray.util.annotations import Deprecated, DeveloperAPI, PublicAPI
  from ray.serve._private import api
label_desc: Use image node_id 1 for calling a global function with example usage: start(detached, proxy_location, http_options, dedicated_cpu, grpc_options, logging_config) without return types