[BUG]: RuntimeError when using zenml up

[sriengchhunchheang]

System Information

What happened?

I encountered a RuntimeError when attempting to initialize the rest store using the command 'zenml up'.
Error message:
RuntimeError: Error initializing rest store with URL 'http://127.0.0.1:8237': HTTPConnectionPool(host='127.0.0.1', port=8237): Max retries exceeded with url: /api/v1/info (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f0d11f31e80>: Failed to establish a new connection: [Errno 111] Connection refused'))

Reproduction steps

Run the command zenml up.

Relevant log output

zenml up
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/urllib3/connection.py:203 in    │
│ _new_conn                                                                                        │
│                                                                                                  │
│   200 │   │   :return: New socket connection.                                                    │
│   201 │   │   """                                                                                │
│   202 │   │   try:                                                                               │
│ ❱ 203 │   │   │   sock = connection.create_connection(                                           │
│   204 │   │   │   │   (self._dns_host, self.port),                                               │
│   205 │   │   │   │   self.timeout,                                                              │
│   206 │   │   │   │   source_address=self.source_address,                                        │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/urllib3/util/connection.py:85   │
│ in create_connection                                                                             │
│                                                                                                  │
│    82 │                                                                                          │
│    83 │   if err is not None:                                                                    │
│    84 │   │   try:                                                                               │
│ ❱  85 │   │   │   raise err                                                                      │
│    86 │   │   finally:                                                                           │
│    87 │   │   │   # Break explicitly a reference cycle                                           │
│    88 │   │   │   err = None                                                                     │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/urllib3/util/connection.py:73   │
│ in create_connection                                                                             │
│                                                                                                  │
│    70 │   │   │   │   sock.settimeout(timeout)                                                   │
│    71 │   │   │   if source_address:                                                             │
│    72 │   │   │   │   sock.bind(source_address)                                                  │
│ ❱  73 │   │   │   sock.connect(sa)                                                               │
│    74 │   │   │   # Break explicitly a reference cycle                                           │
│    75 │   │   │   err = None                                                                     │
│    76 │   │   │   return sock                                                                    │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
ConnectionRefusedError: [Errno 111] Connection refused

The above exception was the direct cause of the following exception:

╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/urllib3/connectionpool.py:790   │
│ in urlopen                                                                                       │
│                                                                                                  │
│    787 │   │   │   response_conn = conn if not release_conn else None                            │
│    788 │   │   │                                                                                 │
│    789 │   │   │   # Make the request on the HTTPConnection object                               │
│ ❱  790 │   │   │   response = self._make_request(                                                │
│    791 │   │   │   │   conn,                                                                     │
│    792 │   │   │   │   method,                                                                   │
│    793 │   │   │   │   url,                                                                      │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/urllib3/connectionpool.py:496   │
│ in _make_request                                                                                 │
│                                                                                                  │
│    493 │   │   # conn.request() calls http.client.*.request, not the method in                   │
│    494 │   │   # urllib3.request. It also calls makefile (recv) on the socket.                   │
│    495 │   │   try:                                                                              │
│ ❱  496 │   │   │   conn.request(                                                                 │
│    497 │   │   │   │   method,                                                                   │
│    498 │   │   │   │   url,                                                                      │
│    499 │   │   │   │   body=body,                                                                │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/urllib3/connection.py:395 in    │
│ request                                                                                          │
│                                                                                                  │
│   392 │   │   │   self.putheader("User-Agent", _get_default_user_agent())                        │
│   393 │   │   for header, value in headers.items():                                              │
│   394 │   │   │   self.putheader(header, value)                                                  │
│ ❱ 395 │   │   self.endheaders()                                                                  │
│   396 │   │                                                                                      │
│   397 │   │   # If we're given a body we start sending that in chunks.                           │
│   398 │   │   if chunks is not None:                                                             │
│                                                                                                  │
│ /usr/lib/python3.8/http/client.py:1251 in endheaders                                             │
│                                                                                                  │
│   1248 │   │   │   self.__state = _CS_REQ_SENT                                                   │
│   1249 │   │   else:                                                                             │
│   1250 │   │   │   raise CannotSendHeader()                                                      │
│ ❱ 1251 │   │   self._send_output(message_body, encode_chunked=encode_chunked)                    │
│   1252 │                                                                                         │
│   1253 │   def request(self, method, url, body=None, headers={}, *,                              │
│   1254 │   │   │   │   encode_chunked=False):                                                    │
│                                                                                                  │
│ /usr/lib/python3.8/http/client.py:1011 in _send_output                                           │
│                                                                                                  │
│   1008 │   │   self._buffer.extend((b"", b""))                                                   │
│   1009 │   │   msg = b"\r\n".join(self._buffer)                                                  │
│   1010 │   │   del self._buffer[:]                                                               │
│ ❱ 1011 │   │   self.send(msg)                                                                    │
│   1012 │   │                                                                                     │
│   1013 │   │   if message_body is not None:                                                      │
│   1014                                                                                           │
│                                                                                                  │
│ /usr/lib/python3.8/http/client.py:951 in send                                                    │
│                                                                                                  │
│    948 │   │                                                                                     │
│    949 │   │   if self.sock is None:                                                             │
│    950 │   │   │   if self.auto_open:                                                            │
│ ❱  951 │   │   │   │   self.connect()                                                            │
│    952 │   │   │   else:                                                                         │
│    953 │   │   │   │   raise NotConnected()                                                      │
│    954                                                                                           │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/urllib3/connection.py:243 in    │
│ connect                                                                                          │
│                                                                                                  │
│   240 │   │   self._tunnel_scheme = scheme                                                       │
│   241 │                                                                                          │
│   242 │   def connect(self) -> None:                                                             │
│ ❱ 243 │   │   self.sock = self._new_conn()                                                       │
│   244 │   │   if self._tunnel_host:                                                              │
│   245 │   │   │   # If we're tunneling it means we're connected to our proxy.                    │
│   246 │   │   │   self._has_connected_to_proxy = True                                            │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/urllib3/connection.py:218 in    │
│ _new_conn                                                                                        │
│                                                                                                  │
│   215 │   │   │   ) from e                                                                       │
│   216 │   │                                                                                      │
│   217 │   │   except OSError as e:                                                               │
│ ❱ 218 │   │   │   raise NewConnectionError(                                                      │
│   219 │   │   │   │   self, f"Failed to establish a new connection: {e}"                         │
│   220 │   │   │   ) from e                                                                       │
│   221                                                                                            │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
NewConnectionError: <urllib3.connection.HTTPConnection object at 0x7f41bcef7eb0>: Failed to establish a new connection: [Errno 111] Connection refused

The above exception was the direct cause of the following exception:

╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/requests/adapters.py:486 in     │
│ send                                                                                             │
│                                                                                                  │
│   483 │   │   │   timeout = TimeoutSauce(connect=timeout, read=timeout)                          │
│   484 │   │                                                                                      │
│   485 │   │   try:                                                                               │
│ ❱ 486 │   │   │   resp = conn.urlopen(                                                           │
│   487 │   │   │   │   method=request.method,                                                     │
│   488 │   │   │   │   url=url,                                                                   │
│   489 │   │   │   │   body=request.body,                                                         │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/urllib3/connectionpool.py:844   │
│ in urlopen                                                                                       │
│                                                                                                  │
│    841 │   │   │   elif isinstance(new_e, (OSError, HTTPException)):                             │
│    842 │   │   │   │   new_e = ProtocolError("Connection aborted.", new_e)                       │
│    843 │   │   │                                                                                 │
│ ❱  844 │   │   │   retries = retries.increment(                                                  │
│    845 │   │   │   │   method, url, error=new_e, _pool=self, _stacktrace=sys.exc_info()[2]       │
│    846 │   │   │   )                                                                             │
│    847 │   │   │   retries.sleep()                                                               │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/urllib3/util/retry.py:515 in    │
│ increment                                                                                        │
│                                                                                                  │
│   512 │   │                                                                                      │
│   513 │   │   if new_retry.is_exhausted():                                                       │
│   514 │   │   │   reason = error or ResponseError(cause)                                         │
│ ❱ 515 │   │   │   raise MaxRetryError(_pool, url, reason) from reason  # type: ignore[arg-type   │
│   516 │   │                                                                                      │
│   517 │   │   log.debug("Incremented Retry for (url='%s'): %r", url, new_retry)                  │
│   518                                                                                            │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
MaxRetryError: HTTPConnectionPool(host='127.0.0.1', port=8237): Max retries exceeded with url: /api/v1/info (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f41bcef7eb0>: 
Failed to establish a new connection: [Errno 111] Connection refused'))

During handling of the above exception, another exception occurred:

╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/zen_stores/base_zen_store │
│ .py:144 in __init__                                                                              │
│                                                                                                  │
│   141 │   │   super().__init__(**kwargs)                                                         │
│   142 │   │                                                                                      │
│   143 │   │   try:                                                                               │
│ ❱ 144 │   │   │   self._initialize()                                                             │
│   145 │   │   except Exception as e:                                                             │
│   146 │   │   │   raise RuntimeError(                                                            │
│   147 │   │   │   │   f"Error initializing {self.type.value} store with URL "                    │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/zen_stores/rest_zen_store │
│ .py:417 in _initialize                                                                           │
│                                                                                                  │
│    414 │   def _initialize(self) -> None:                                                        │
│    415 │   │   """Initialize the REST store."""                                                  │
│    416 │   │   client_version = zenml.__version__                                                │
│ ❱  417 │   │   server_version = self.get_store_info().version                                    │
│    418 │   │                                                                                     │
│    419 │   │   if not DISABLE_CLIENT_SERVER_MISMATCH_WARNING and (                               │
│    420 │   │   │   server_version != client_version                                              │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/zen_stores/rest_zen_store │
│ .py:438 in get_store_info                                                                        │
│                                                                                                  │
│    435 │   │   Returns:                                                                          │
│    436 │   │   │   Information about the server.                                                 │
│    437 │   │   """                                                                               │
│ ❱  438 │   │   body = self.get(INFO)                                                             │
│    439 │   │   return ServerModel.parse_obj(body)                                                │
│    440 │                                                                                         │
│    441 │   # ------                                                                              │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/zen_stores/rest_zen_store │
│ .py:2480 in get                                                                                  │
│                                                                                                  │
│   2477 │   │   │   The response body.                                                            │
│   2478 │   │   """                                                                               │
│   2479 │   │   logger.debug(f"Sending GET request to {path}...")                                 │
│ ❱ 2480 │   │   return self._request(                                                             │
│   2481 │   │   │   "GET", self.url + API + VERSION_1 + path, params=params, **kwargs             │
│   2482 │   │   )                                                                                 │
│   2483                                                                                           │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/zen_stores/rest_zen_store │
│ .py:2442 in _request                                                                             │
│                                                                                                  │
│   2439 │   │                                                                                     │
│   2440 │   │   try:                                                                              │
│   2441 │   │   │   return self._handle_response(                                                 │
│ ❱ 2442 │   │   │   │   self.session.request(                                                     │
│   2443 │   │   │   │   │   method,                                                               │
│   2444 │   │   │   │   │   url,                                                                  │
│   2445 │   │   │   │   │   params=params,                                                        │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/requests/sessions.py:589 in     │
│ request                                                                                          │
│                                                                                                  │
│   586 │   │   │   "allow_redirects": allow_redirects,                                            │
│   587 │   │   }                                                                                  │
│   588 │   │   send_kwargs.update(settings)                                                       │
│ ❱ 589 │   │   resp = self.send(prep, **send_kwargs)                                              │
│   590 │   │                                                                                      │
│   591 │   │   return resp                                                                        │
│   592                                                                                            │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/requests/sessions.py:703 in     │
│ send                                                                                             │
│                                                                                                  │
│   700 │   │   start = preferred_clock()                                                          │
│   701 │   │                                                                                      │
│   702 │   │   # Send the request                                                                 │
│ ❱ 703 │   │   r = adapter.send(request, **kwargs)                                                │
│   704 │   │                                                                                      │
│   705 │   │   # Total elapsed time of the request (approximately)                                │
│   706 │   │   elapsed = preferred_clock() - start                                                │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/requests/adapters.py:519 in     │
│ send                                                                                             │
│                                                                                                  │
│   516 │   │   │   │   # This branch is for urllib3 v1.22 and later.                              │
│   517 │   │   │   │   raise SSLError(e, request=request)                                         │
│   518 │   │   │                                                                                  │
│ ❱ 519 │   │   │   raise ConnectionError(e, request=request)                                      │
│   520 │   │                                                                                      │
│   521 │   │   except ClosedPoolError as e:                                                       │
│   522 │   │   │   raise ConnectionError(e, request=request)                                      │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
ConnectionError: HTTPConnectionPool(host='127.0.0.1', port=8237): Max retries exceeded with url: /api/v1/info (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f41bcef7eb0>:
Failed to establish a new connection: [Errno 111] Connection refused'))

The above exception was the direct cause of the following exception:

╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /home/chhun/Zenml/Covid19_V2/myZenml/bin/zenml:8 in <module>                                     │
│                                                                                                  │
│   5 from zenml.cli.cli import cli                                                                │
│   6 if __name__ == '__main__':                                                                   │
│   7 │   sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])                         │
│ ❱ 8 │   sys.exit(cli())                                                                          │
│   9                                                                                              │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/click/core.py:1130 in __call__  │
│                                                                                                  │
│   1127 │                                                                                         │
│   1128 │   def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Any:                           │
│   1129 │   │   """Alias for :meth:`main`."""                                                     │
│ ❱ 1130 │   │   return self.main(*args, **kwargs)                                                 │
│   1131                                                                                           │
│   1132                                                                                           │
│   1133 class Command(BaseCommand):                                                               │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/click/core.py:1055 in main      │
│                                                                                                  │
│   1052 │   │   try:                                                                              │
│   1053 │   │   │   try:                                                                          │
│   1054 │   │   │   │   with self.make_context(prog_name, args, **extra) as ctx:                  │
│ ❱ 1055 │   │   │   │   │   rv = self.invoke(ctx)                                                 │
│   1056 │   │   │   │   │   if not standalone_mode:                                               │
│   1057 │   │   │   │   │   │   return rv                                                         │
│   1058 │   │   │   │   │   # it's not safe to `ctx.exit(rv)` here!                               │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/click/core.py:1657 in invoke    │
│                                                                                                  │
│   1654 │   │   │   │   super().invoke(ctx)                                                       │
│   1655 │   │   │   │   sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)                    │
│   1656 │   │   │   │   with sub_ctx:                                                             │
│ ❱ 1657 │   │   │   │   │   return _process_result(sub_ctx.command.invoke(sub_ctx))               │
│   1658 │   │                                                                                     │
│   1659 │   │   # In chain mode we create the contexts step by step, but after the                │
│   1660 │   │   # base command has been invoked.  Because at that point we do not                 │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/click/core.py:1404 in invoke    │
│                                                                                                  │
│   1401 │   │   │   echo(style(message, fg="red"), err=True)                                      │
│   1402 │   │                                                                                     │
│   1403 │   │   if self.callback is not None:                                                     │
│ ❱ 1404 │   │   │   return ctx.invoke(self.callback, **ctx.params)                                │
│   1405 │                                                                                         │
│   1406 │   def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:  │
│   1407 │   │   """Return a list of completions for the incomplete value. Looks                   │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/click/core.py:760 in invoke     │
│                                                                                                  │
│    757 │   │                                                                                     │
│    758 │   │   with augment_usage_errors(__self):                                                │
│    759 │   │   │   with ctx:                                                                     │
│ ❱  760 │   │   │   │   return __callback(*args, **kwargs)                                        │
│    761 │                                                                                         │
│    762 │   def forward(                                                                          │
│    763 │   │   __self, __cmd: "Command", *args: t.Any, **kwargs: t.Any  # noqa: B902             │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/cli/server.py:176 in up   │
│                                                                                                  │
│   173 │   │                                                                                      │
│   174 │   │   server_config = ServerDeploymentConfig(**config_attrs)                             │
│   175 │   │                                                                                      │
│ ❱ 176 │   │   server = deployer.deploy_server(server_config)                                     │
│   177 │   │                                                                                      │
│   178 │   │   assert gc.store is not None                                                        │
│   179                                                                                            │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/zen_server/deploy/deploye │
│ r.py:112 in deploy_server                                                                        │
│                                                                                                  │
│   109 │   │   # may require access to the local store configuration or database.                 │
│   110 │   │   gc = GlobalConfiguration()                                                         │
│   111 │   │                                                                                      │
│ ❱ 112 │   │   _ = gc.zen_store                                                                   │
│   113 │   │                                                                                      │
│   114 │   │   try:                                                                               │
│   115 │   │   │   self.get_server(config.name)                                                   │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/config/global_config.py:2 │
│ 69 in __custom_getattribute__                                                                    │
│                                                                                                  │
│   266 │   │   Returns:                                                                           │
│   267 │   │   │   The attribute value.                                                           │
│   268 │   │   """                                                                                │
│ ❱ 269 │   │   value = super().__getattribute__(key)                                              │
│   270 │   │   if key.startswith("_") or key not in type(self).__fields__:                        │
│   271 │   │   │   return value                                                                   │
│   272                                                                                            │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/config/global_config.py:6 │
│ 84 in zen_store                                                                                  │
│                                                                                                  │
│   681 │   │   if not self.store:                                                                 │
│   682 │   │   │   self.set_default_store()                                                       │
│   683 │   │   elif self._zen_store is None:                                                      │
│ ❱ 684 │   │   │   self._configure_store(self.store)                                              │
│   685 │   │                                                                                      │
│   686 │   │   assert self._zen_store is not None                                                 │
│   687                                                                                            │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/config/global_config.py:3 │
│ 97 in _configure_store                                                                           │
│                                                                                                  │
│   394 │   │                                                                                      │
│   395 │   │   # TODO: Revisit the flow regarding the registration of the default                 │
│   396 │   │   #  entities once the analytics v1 is removed.                                      │
│ ❱ 397 │   │   store = BaseZenStore.create_store(config, True, **kwargs)                          │
│   398 │   │                                                                                      │
│   399 │   │   logger.debug(f"Configuring the global store to {store.config}")                    │
│   400 │   │   self.store = store.config                                                          │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/zen_stores/base_zen_store │
│ .py:241 in create_store                                                                          │
│                                                                                                  │
│   238 │   │   """                                                                                │
│   239 │   │   logger.debug(f"Creating store with config '{config}'...")                          │
│   240 │   │   store_class = BaseZenStore.get_store_class(config.type)                            │
│ ❱ 241 │   │   store = store_class(                                                               │
│   242 │   │   │   config=config,                                                                 │
│   243 │   │   │   skip_default_registrations=skip_default_registrations,                         │
│   244 │   │   │   **kwargs,                                                                      │
│                                                                                                  │
│ /home/chhun/Zenml/Covid19_V2/myZenml/lib/python3.8/site-packages/zenml/zen_stores/base_zen_store │
│ .py:146 in __init__                                                                              │
│                                                                                                  │
│   143 │   │   try:                                                                               │
│   144 │   │   │   self._initialize()                                                             │
│   145 │   │   except Exception as e:                                                             │
│ ❱ 146 │   │   │   raise RuntimeError(                                                            │
│   147 │   │   │   │   f"Error initializing {self.type.value} store with URL "                    │
│   148 │   │   │   │   f"'{self.url}': {str(e)}"                                                  │
│   149 │   │   │   ) from e                                                                       │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
RuntimeError: Error initializing rest store with URL 'http://127.0.0.1:8237': HTTPConnectionPool(host='127.0.0.1', port=8237): Max retries exceeded with url: /api/v1/info (Caused by 
NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f41bcef7eb0>: Failed to establish a new connection: [Errno 111] Connection refused'))

Code of Conduct

• I agree to follow this project's Code of Conduct

[sriengchhunchheang]

Now I can fix this bug:

1. Upgrade ZenML to the latest version (0.43.0) using the command:
   pip install --upgrade zenml
2. Disconnect from the ZenML server with the following command:
   zenml disconnect
3. Run the zenml up command:
   zenml up (it's working now)