2 Copyright (c) 2015 SONATA-NFV and Paderborn University
5 Licensed under the Apache License, Version 2.0 (the "License");
6 you may not use this file except in compliance with the License.
7 You may obtain a copy of the License at
9 http://www.apache.org/licenses/LICENSE-2.0
11 Unless required by applicable law or agreed to in writing, software
12 distributed under the License is distributed on an "AS IS" BASIS,
13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 See the License for the specific language governing permissions and
15 limitations under the License.
17 Neither the name of the SONATA-NFV [, ANY ADDITIONAL AFFILIATION]
18 nor the names of its contributors may be used to endorse or promote
19 products derived from this software without specific prior written
22 This work has been performed in the framework of the SONATA project,
23 funded by the European Commission under Grant number 671517 through
24 the Horizon 2020 and 5G-PPP programmes. The authors would like to
25 acknowledge the contributions of their colleagues of the SONATA
26 partner consortium (www.sonata-nfv.eu).
29 This module implements a simple REST API that behaves like SONATA's gatekeeper.
31 It is only used to support the development of SONATA's SDK tools and to demonstrate
32 the year 1 version of the emulator until the integration with WP4's orchestrator is done.
42 from docker
import Client
as DockerClient
43 from flask
import Flask
, request
44 import flask_restful
as fr
45 from collections
import defaultdict
49 LOG
= logging
.getLogger("sonata-dummy-gatekeeper")
50 LOG
.setLevel(logging
.DEBUG
)
51 logging
.getLogger("werkzeug").setLevel(logging
.WARNING
)
53 GK_STORAGE
= "/tmp/son-dummy-gk/"
54 UPLOAD_FOLDER
= os
.path
.join(GK_STORAGE
, "uploads/")
55 CATALOG_FOLDER
= os
.path
.join(GK_STORAGE
, "catalog/")
57 # Enable Dockerfile build functionality
58 BUILD_DOCKERFILE
= False
60 # flag to indicate that we run without the emulator (only the bare API for integration testing)
61 GK_STANDALONE_MODE
= False
63 # should a new version of an image be pulled even if its available
66 # Automatically deploy SAPs (endpoints) of the service as new containers
67 # Attention: This is not a configuration switch but a global variable! Don't change its default value.
70 # flag to indicate if we use bidirectional forwarding rules in the automatic chaining process
71 BIDIRECTIONAL_CHAIN
= False
73 class Gatekeeper(object):
76 self
.services
= dict()
78 self
.vnf_counter
= 0 # used to generate short names for VNFs (Mininet limitation)
79 LOG
.info("Create SONATA dummy gatekeeper.")
81 def register_service_package(self
, service_uuid
, service
):
83 register new service package
87 self
.services
[service_uuid
] = service
88 # lets perform all steps needed to onboard the service
91 def get_next_vnf_name(self
):
93 return "vnf%d" % self
.vnf_counter
96 class Service(object):
98 This class represents a NS uploaded as a *.son package to the
100 Can have multiple running instances of this service.
107 self
.uuid
= service_uuid
108 self
.package_file_hash
= package_file_hash
109 self
.package_file_path
= package_file_path
110 self
.package_content_path
= os
.path
.join(CATALOG_FOLDER
, "services/%s" % self
.uuid
)
114 self
.local_docker_files
= dict()
115 self
.remote_docker_image_urls
= dict()
116 self
.instances
= dict()
117 self
.vnf_name2docker_name
= dict()
118 self
.sap_identifiers
= set()
119 # lets generate a set of subnet configurations used for e-line chaining setup
120 self
.eline_subnets_src
= generate_subnet_strings(50, start
=200, subnet_size
=24, ip
=1)
121 self
.eline_subnets_dst
= generate_subnet_strings(50, start
=200, subnet_size
=24, ip
=2)
126 Do all steps to prepare this service to be instantiated
129 # 1. extract the contents of the package and store them in our catalog
130 self
._unpack
_service
_package
()
131 # 2. read in all descriptor files
132 self
._load
_package
_descriptor
()
137 # 3. prepare container images (e.g. download or build Dockerfile)
139 self
._load
_docker
_files
()
140 self
._build
_images
_from
_dockerfiles
()
142 self
._load
_docker
_urls
()
143 self
._pull
_predefined
_dockerimages
()
144 LOG
.info("On-boarded service: %r" % self
.manifest
.get("name"))
146 def start_service(self
):
148 This methods creates and starts a new service instance.
149 It computes placements, iterates over all VNFDs, and starts
150 each VNFD as a Docker container in the data center selected
151 by the placement algorithm.
154 LOG
.info("Starting service %r" % self
.uuid
)
156 # 1. each service instance gets a new uuid to identify it
157 instance_uuid
= str(uuid
.uuid4())
158 # build a instances dict (a bit like a NSR :))
159 self
.instances
[instance_uuid
] = dict()
160 self
.instances
[instance_uuid
]["vnf_instances"] = list()
162 # 2. Configure the chaining of the network functions (currently only E-Line and E-LAN links supported)
163 vnf_id2vnf_name
= defaultdict(lambda: "NotExistingNode",
164 reduce(lambda x
, y
: dict(x
, **y
),
165 map(lambda d
: {d
["vnf_id"]: d
["vnf_name"]},
166 self
.nsd
["network_functions"])))
168 # 3. compute placement of this service instance (adds DC names to VNFDs)
169 if not GK_STANDALONE_MODE
:
170 #self._calculate_placement(FirstDcPlacement)
171 self
._calculate
_placement
(RoundRobinDcPlacement
)
172 # iterate over all vnfds that we have to start
173 for vnfd
in self
.vnfds
.itervalues():
175 if not GK_STANDALONE_MODE
:
176 vnfi
= self
._start
_vnfd
(vnfd
)
177 self
.instances
[instance_uuid
]["vnf_instances"].append(vnfi
)
179 vlinks
= self
.nsd
["virtual_links"]
180 fwd_links
= self
.nsd
["forwarding_graphs"][0]["constituent_virtual_links"]
181 eline_fwd_links
= [l
for l
in vlinks
if (l
["id"] in fwd_links
) and (l
["connectivity_type"] == "E-Line")]
182 elan_fwd_links
= [l
for l
in vlinks
if (l
["id"] in fwd_links
) and (l
["connectivity_type"] == "E-LAN")]
184 # 4a. deploy E-Line links
185 # cookie is used as identifier for the flowrules installed by the dummygatekeeper
186 # eg. different services get a unique cookie for their flowrules
188 for link
in eline_fwd_links
:
189 src_id
, src_if_name
= link
["connection_points_reference"][0].split(":")
190 dst_id
, dst_if_name
= link
["connection_points_reference"][1].split(":")
192 # check if there is a SAP in the link
193 if src_id
in self
.sap_identifiers
:
194 src_docker_name
= "{0}_{1}".format(src_id
, src_if_name
)
195 src_id
= src_docker_name
197 src_docker_name
= src_id
199 if dst_id
in self
.sap_identifiers
:
200 dst_docker_name
= "{0}_{1}".format(dst_id
, dst_if_name
)
201 dst_id
= dst_docker_name
203 dst_docker_name
= dst_id
205 src_name
= vnf_id2vnf_name
[src_id
]
206 dst_name
= vnf_id2vnf_name
[dst_id
]
209 "Setting up E-Line link. %s(%s:%s) -> %s(%s:%s)" % (
210 src_name
, src_id
, src_if_name
, dst_name
, dst_id
, dst_if_name
))
212 if (src_name
in self
.vnfds
) and (dst_name
in self
.vnfds
):
213 network
= self
.vnfds
[src_name
].get("dc").net
# there should be a cleaner way to find the DCNetwork
214 LOG
.debug(src_docker_name
)
215 ret
= network
.setChain(
216 src_docker_name
, dst_docker_name
,
217 vnf_src_interface
=src_if_name
, vnf_dst_interface
=dst_if_name
,
218 bidirectional
=BIDIRECTIONAL_CHAIN
, cmd
="add-flow", cookie
=cookie
, priority
=10)
220 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-Link
221 src_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, src_name
)
222 if src_vnfi
is not None:
223 self
._vnf
_reconfigure
_network
(src_vnfi
, src_if_name
, self
.eline_subnets_src
.pop(0))
224 dst_vnfi
= self
._get
_vnf
_instance
(instance_uuid
, dst_name
)
225 if dst_vnfi
is not None:
226 self
._vnf
_reconfigure
_network
(dst_vnfi
, dst_if_name
, self
.eline_subnets_dst
.pop(0))
228 # 4b. deploy E-LAN links
230 for link
in elan_fwd_links
:
231 # generate lan ip address
233 for intf
in link
["connection_points_reference"]:
234 ip_address
= generate_lan_string("10.0", base
, subnet_size
=24, ip
=ip
)
235 vnf_id
, intf_name
= intf
.split(":")
236 if vnf_id
in self
.sap_identifiers
:
237 src_docker_name
= "{0}_{1}".format(vnf_id
, intf_name
)
238 vnf_id
= src_docker_name
239 vnf_name
= vnf_id2vnf_name
[vnf_id
]
241 "Setting up E-LAN link. %s(%s:%s) -> %s" % (
242 vnf_name
, vnf_id
, intf_name
, ip_address
))
244 if vnf_name
in self
.vnfds
:
245 # re-configure the VNFs IP assignment and ensure that a new subnet is used for each E-LAN
246 # E-LAN relies on the learning switch capability of Ryu which has to be turned on in the topology
247 # (DCNetwork(controller=RemoteController, enable_learning=True)), so no explicit chaining is necessary.
248 vnfi
= self
._get
_vnf
_instance
(instance_uuid
, vnf_name
)
250 self
._vnf
_reconfigure
_network
(vnfi
, intf_name
, ip_address
)
251 # increase for the next ip address on this E-LAN
253 # increase the base ip address for the next E-LAN
256 # 5. run the emulator specific entrypoint scripts in the VNFIs of this service instance
257 self
._trigger
_emulator
_start
_scripts
_in
_vnfis
(self
.instances
[instance_uuid
]["vnf_instances"])
259 LOG
.info("Service started. Instance id: %r" % instance_uuid
)
262 def _start_vnfd(self
, vnfd
):
264 Start a single VNFD of this service
265 :param vnfd: vnfd descriptor dict
268 # iterate over all deployment units within each VNFDs
269 for u
in vnfd
.get("virtual_deployment_units"):
270 # 1. get the name of the docker image to start and the assigned DC
271 vnf_name
= vnfd
.get("name")
272 if vnf_name
not in self
.remote_docker_image_urls
:
273 raise Exception("No image name for %r found. Abort." % vnf_name
)
274 docker_name
= self
.remote_docker_image_urls
.get(vnf_name
)
275 target_dc
= vnfd
.get("dc")
276 # 2. perform some checks to ensure we can start the container
277 assert(docker_name
is not None)
278 assert(target_dc
is not None)
279 if not self
._check
_docker
_image
_exists
(docker_name
):
280 raise Exception("Docker image %r not found. Abort." % docker_name
)
281 # 3. do the dc.startCompute(name="foobar") call to run the container
282 # TODO consider flavors, and other annotations
283 intfs
= vnfd
.get("connection_points")
285 # TODO: get all vnf id's from the nsd for this vnfd and use those as dockername
286 # use the vnf_id in the nsd as docker name
287 # so deployed containers can be easily mapped back to the nsd
288 vnf_name2id
= defaultdict(lambda: "NotExistingNode",
289 reduce(lambda x
, y
: dict(x
, **y
),
290 map(lambda d
: {d
["vnf_name"]: d
["vnf_id"]},
291 self
.nsd
["network_functions"])))
292 self
.vnf_name2docker_name
[vnf_name
] = vnf_name2id
[vnf_name
]
293 # self.vnf_name2docker_name[vnf_name] = GK.get_next_vnf_name()
295 LOG
.info("Starting %r as %r in DC %r" % (vnf_name
, self
.vnf_name2docker_name
[vnf_name
], vnfd
.get("dc")))
296 LOG
.debug("Interfaces for %r: %r" % (vnf_name
, intfs
))
297 vnfi
= target_dc
.startCompute(self
.vnf_name2docker_name
[vnf_name
], network
=intfs
, image
=docker_name
, flavor_name
="small")
300 def _get_vnf_instance(self
, instance_uuid
, name
):
302 Returns the Docker object for the given VNF name (or Docker name).
303 :param instance_uuid: UUID of the service instance to search in.
304 :param name: VNF name or Docker name. We are fuzzy here.
308 if name
in self
.vnf_name2docker_name
:
309 dn
= self
.vnf_name2docker_name
[name
]
310 for vnfi
in self
.instances
[instance_uuid
]["vnf_instances"]:
313 LOG
.warning("No container with name: %r found.")
317 def _vnf_reconfigure_network(vnfi
, if_name
, net_str
):
319 Reconfigure the network configuration of a specific interface
320 of a running container.
321 :param vnfi: container instacne
322 :param if_name: interface name
323 :param net_str: network configuration string, e.g., 1.2.3.4/24
326 intf
= vnfi
.intf(intf
=if_name
)
329 LOG
.debug("Reconfigured network of %s:%s to %r" % (vnfi
.name
, if_name
, net_str
))
331 LOG
.warning("Interface not found: %s:%s. Network reconfiguration skipped." % (vnfi
.name
, if_name
))
334 def _trigger_emulator_start_scripts_in_vnfis(self
, vnfi_list
):
335 for vnfi
in vnfi_list
:
336 config
= vnfi
.dcinfo
.get("Config", dict())
337 env
= config
.get("Env", list())
339 if "SON_EMU_CMD=" in env_var
:
340 cmd
= str(env_var
.split("=")[1])
341 LOG
.info("Executing entry point script in %r: %r" % (vnfi
.name
, cmd
))
342 # execute command in new thread to ensure that GK is not blocked by VNF
343 t
= threading
.Thread(target
=vnfi
.cmdPrint
, args
=(cmd
,))
347 def _unpack_service_package(self
):
349 unzip *.son file and store contents in CATALOG_FOLDER/services/<service_uuid>/
351 LOG
.info("Unzipping: %r" % self
.package_file_path
)
352 with zipfile
.ZipFile(self
.package_file_path
, "r") as z
:
353 z
.extractall(self
.package_content_path
)
356 def _load_package_descriptor(self
):
358 Load the main package descriptor YAML and keep it as dict.
361 self
.manifest
= load_yaml(
363 self
.package_content_path
, "META-INF/MANIFEST.MF"))
367 Load the entry NSD YAML and keep it as dict.
370 if "entry_service_template" in self
.manifest
:
371 nsd_path
= os
.path
.join(
372 self
.package_content_path
,
373 make_relative_path(self
.manifest
.get("entry_service_template")))
374 self
.nsd
= load_yaml(nsd_path
)
375 LOG
.debug("Loaded NSD: %r" % self
.nsd
.get("name"))
377 def _load_vnfd(self
):
379 Load all VNFD YAML files referenced in MANIFEST.MF and keep them in dict.
382 if "package_content" in self
.manifest
:
383 for pc
in self
.manifest
.get("package_content"):
384 if pc
.get("content-type") == "application/sonata.function_descriptor":
385 vnfd_path
= os
.path
.join(
386 self
.package_content_path
,
387 make_relative_path(pc
.get("name")))
388 vnfd
= load_yaml(vnfd_path
)
389 self
.vnfds
[vnfd
.get("name")] = vnfd
390 LOG
.debug("Loaded VNFD: %r" % vnfd
.get("name"))
392 def _load_saps(self
):
393 # Each Service Access Point (connection_point) in the nsd is getting its own container
394 SAPs
= [p
["id"] for p
in self
.nsd
["connection_points"] if p
["type"] == "interface"]
396 # endpoints needed in this service
397 sap_vnf_id
, sap_vnf_interface
= sap
.split(':')
398 # set of the connection_point ids found in the nsd (in the examples this is 'ns')
399 self
.sap_identifiers
.add(sap_vnf_id
)
401 sap_docker_name
= "%s_%s" % (sap_vnf_id
, sap_vnf_interface
)
403 # add SAP to self.vnfds
404 sapfile
= pkg_resources
.resource_filename(__name__
, "sap_vnfd.yml")
405 sap_vnfd
= load_yaml(sapfile
)
406 sap_vnfd
["connection_points"][0]["id"] = sap_vnf_interface
407 sap_vnfd
["name"] = sap_docker_name
408 self
.vnfds
[sap_docker_name
] = sap_vnfd
409 # add SAP vnf to list in the NSD so it is deployed later on
410 # each SAP get a unique VNFD and vnf_id in the NSD
411 self
.nsd
["network_functions"].append({"vnf_id": sap_docker_name
, "vnf_name": sap_docker_name
})
412 LOG
.debug("Loaded SAP: %r" % sap_vnfd
.get("name"))
414 def _load_docker_files(self
):
416 Get all paths to Dockerfiles from VNFDs and store them in dict.
419 for k
, v
in self
.vnfds
.iteritems():
420 for vu
in v
.get("virtual_deployment_units"):
421 if vu
.get("vm_image_format") == "docker":
422 vm_image
= vu
.get("vm_image")
423 docker_path
= os
.path
.join(
424 self
.package_content_path
,
425 make_relative_path(vm_image
))
426 self
.local_docker_files
[k
] = docker_path
427 LOG
.debug("Found Dockerfile (%r): %r" % (k
, docker_path
))
429 def _load_docker_urls(self
):
431 Get all URLs to pre-build docker images in some repo.
434 for k
, v
in self
.vnfds
.iteritems():
435 for vu
in v
.get("virtual_deployment_units"):
436 if vu
.get("vm_image_format") == "docker":
437 url
= vu
.get("vm_image")
439 url
= url
.replace("http://", "")
440 self
.remote_docker_image_urls
[k
] = url
441 LOG
.debug("Found Docker image URL (%r): %r" % (k
, self
.remote_docker_image_urls
[k
]))
443 def _build_images_from_dockerfiles(self
):
445 Build Docker images for each local Dockerfile found in the package: self.local_docker_files
447 if GK_STANDALONE_MODE
:
448 return # do not build anything in standalone mode
450 LOG
.info("Building %d Docker images (this may take several minutes) ..." % len(self
.local_docker_files
))
451 for k
, v
in self
.local_docker_files
.iteritems():
452 for line
in dc
.build(path
=v
.replace("Dockerfile", ""), tag
=k
, rm
=False, nocache
=False):
453 LOG
.debug("DOCKER BUILD: %s" % line
)
454 LOG
.info("Docker image created: %s" % k
)
456 def _pull_predefined_dockerimages(self
):
458 If the package contains URLs to pre-build Docker images, we download them with this method.
461 for url
in self
.remote_docker_image_urls
.itervalues():
462 if not FORCE_PULL
: # only pull if not present (speedup for development)
463 if len(dc
.images(name
=url
)) > 0:
464 LOG
.debug("Image %r present. Skipping pull." % url
)
466 LOG
.info("Pulling image: %r" % url
)
468 insecure_registry
=True)
470 def _check_docker_image_exists(self
, image_name
):
472 Query the docker service and check if the given image exists
473 :param image_name: name of the docker image
476 return len(DockerClient().images(image_name
)) > 0
478 def _calculate_placement(self
, algorithm
):
480 Do placement by adding the a field "dc" to
481 each VNFD that points to one of our
482 data center objects known to the gatekeeper.
484 assert(len(self
.vnfds
) > 0)
485 assert(len(GK
.dcs
) > 0)
486 # instantiate algorithm an place
488 p
.place(self
.nsd
, self
.vnfds
, GK
.dcs
)
489 LOG
.info("Using placement algorithm: %r" % p
.__class
__.__name
__)
490 # lets print the placement result
491 for name
, vnfd
in self
.vnfds
.iteritems():
492 LOG
.info("Placed VNF %r on DC %r" % (name
, str(vnfd
.get("dc"))))
496 Some (simple) placement algorithms
500 class FirstDcPlacement(object):
502 Placement: Always use one and the same data center from the GK.dcs dict.
504 def place(self
, nsd
, vnfds
, dcs
):
505 for name
, vnfd
in vnfds
.iteritems():
506 vnfd
["dc"] = list(dcs
.itervalues())[0]
509 class RoundRobinDcPlacement(object):
511 Placement: Distribute VNFs across all available DCs in a round robin fashion.
513 def place(self
, nsd
, vnfds
, dcs
):
515 dcs_list
= list(dcs
.itervalues())
516 for name
, vnfd
in vnfds
.iteritems():
517 vnfd
["dc"] = dcs_list
[c
% len(dcs_list
)]
518 c
+= 1 # inc. c to use next DC
524 Resource definitions and API endpoints
528 class Packages(fr
.Resource
):
532 Upload a *.son service package to the dummy gatekeeper.
534 We expect request with a *.son file and store it in UPLOAD_FOLDER
540 # lets search for the package in the request
541 if "package" in request
.files
:
542 son_file
= request
.files
["package"]
543 # elif "file" in request.files:
544 # son_file = request.files["file"]
546 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed. file not found."}, 500
547 # generate a uuid to reference this package
548 service_uuid
= str(uuid
.uuid4())
549 file_hash
= hashlib
.sha1(str(son_file
)).hexdigest()
550 # ensure that upload folder exists
551 ensure_dir(UPLOAD_FOLDER
)
552 upload_path
= os
.path
.join(UPLOAD_FOLDER
, "%s.son" % service_uuid
)
553 # store *.son file to disk
554 son_file
.save(upload_path
)
555 size
= os
.path
.getsize(upload_path
)
556 # create a service object and register it
557 s
= Service(service_uuid
, file_hash
, upload_path
)
558 GK
.register_service_package(service_uuid
, s
)
559 # generate the JSON result
560 return {"service_uuid": service_uuid
, "size": size
, "sha1": file_hash
, "error": None}
561 except Exception as ex
:
562 LOG
.exception("Service package upload failed:")
563 return {"service_uuid": None, "size": 0, "sha1": None, "error": "upload failed"}, 500
567 Return a list of UUID's of uploaded service packages.
570 LOG
.info("GET /packages")
571 return {"service_uuid_list": list(GK
.services
.iterkeys())}
574 class Instantiations(fr
.Resource
):
578 Instantiate a service specified by its UUID.
579 Will return a new UUID to identify the running service instance.
582 # try to extract the service uuid from the request
583 json_data
= request
.get_json(force
=True)
584 service_uuid
= json_data
.get("service_uuid")
586 # lets be a bit fuzzy here to make testing easier
587 if service_uuid
is None and len(GK
.services
) > 0:
588 # if we don't get a service uuid, we simple start the first service in the list
589 service_uuid
= list(GK
.services
.iterkeys())[0]
591 if service_uuid
in GK
.services
:
592 # ok, we have a service uuid, lets start the service
593 service_instance_uuid
= GK
.services
.get(service_uuid
).start_service()
594 return {"service_instance_uuid": service_instance_uuid
}
595 return "Service not found", 404
599 Returns a list of UUIDs containing all running services.
602 LOG
.info("GET /instantiations")
603 return {"service_instantiations_list": [
604 list(s
.instances
.iterkeys()) for s
in GK
.services
.itervalues()]}
607 # create a single, global GK object
610 app
= Flask(__name__
)
611 app
.config
['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024 # 512 MB max upload
614 api
.add_resource(Packages
, '/packages')
615 api
.add_resource(Instantiations
, '/instantiations')
618 def start_rest_api(host
, port
, datacenters
=dict()):
620 # start the Flask server (not the best performance but ok for our use case)
624 use_reloader
=False # this is needed to run Flask in a non-main thread
628 def ensure_dir(name
):
629 if not os
.path
.exists(name
):
634 with
open(path
, "r") as f
:
637 except yaml
.YAMLError
as exc
:
638 LOG
.exception("YAML parse error")
643 def make_relative_path(path
):
644 if path
.startswith("file://"):
645 path
= path
.replace("file://", "", 1)
646 if path
.startswith("/"):
647 path
= path
.replace("/", "", 1)
651 def generate_lan_string(prefix
, base
, subnet_size
=24, ip
=0):
653 Helper to generate different network configuration strings.
655 r
= "%s.%d.%d/%d" % (prefix
, base
, ip
, subnet_size
)
659 def generate_subnet_strings(n
, start
=1, subnet_size
=24, ip
=0):
661 Helper to generate different network configuration strings.
664 for i
in range(start
, start
+ n
):
665 r
.append("%d.0.0.%d/%d" % (i
, ip
, subnet_size
))
669 if __name__
== '__main__':
671 Lets allow to run the API in standalone mode.
673 GK_STANDALONE_MODE
= True
674 logging
.getLogger("werkzeug").setLevel(logging
.INFO
)
675 start_rest_api("0.0.0.0", 8000)