Newer
Older
" self.description = description\n",
" self.type = type\n",
" self.protocol = protocol\n",
" self.version = version\n",
" self.endpoint = endpoint\n",
" self.security = security\n",
" if impl_specific_info is not None:\n",
" self.impl_specific_info = impl_specific_info\n",
" def id(self):\n",
" return self._id\n",
" @id.setter\n",
" def id(self, id):\n",
" if id is None:\n",
" raise ValueError(\"Invalid value for `id`, must not be `None`\") # noqa: E501\n",
" self._id = id\n",
4018
4019
4020
4021
4022
4023
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
4042
4043
4044
4045
4046
4047
4048
4049
4050
4051
4052
4053
4054
4055
4056
4057
4058
4059
4060
4061
4062
4063
4064
4065
4066
4067
4068
4069
4070
4071
4072
4073
4074
4075
4076
" def name(self):\n",
" return self._name\n",
" @name.setter\n",
" def name(self, name):\n",
" if name is None:\n",
" raise ValueError(\"Invalid value for `name`, must not be `None`\") # noqa: E501\n",
" self._name = name\n",
" @property\n",
" def description(self):\n",
" return self._description\n",
" @description.setter\n",
" def description(self, description):\n",
" self._description = description\n",
" @property\n",
" def type(self):\n",
" return self._type\n",
" @type.setter\n",
" def type(self, type):\n",
" if type is None:\n",
" raise ValueError(\"Invalid value for `type`, must not be `None`\") # noqa: E501\n",
" self._type = type\n",
" @property\n",
" def protocol(self):\n",
" return self._protocol\n",
" @protocol.setter\n",
" def protocol(self, protocol):\n",
" if protocol is None:\n",
" raise ValueError(\"Invalid value for `protocol`, must not be `None`\") # noqa: E501\n",
" self._protocol = protocol\n",
" @property\n",
" def version(self):\n",
" return self._version\n",
" @version.setter\n",
" def version(self, version):\n",
" if version is None:\n",
" raise ValueError(\"Invalid value for `version`, must not be `None`\") # noqa: E501\n",
" self._version = version\n",
" @property\n",
" def endpoint(self):\n",
" return self._endpoint\n",
" @endpoint.setter\n",
" def endpoint(self, endpoint):\n",
" if endpoint is None:\n",
" raise ValueError(\"Invalid value for `endpoint`, must not be `None`\") # noqa: E501\n",
" self._endpoint = endpoint\n",
" @property\n",
" def security(self):\n",
" return self._security\n",
" @security.setter\n",
" def security(self, security):\n",
" if security is None:\n",
" raise ValueError(\"Invalid value for `security`, must not be `None`\") # noqa: E501\n",
" self._security = security\n",
" @property\n",
" def impl_specific_info(self):\n",
" return self._impl_specific_info\n",
" @impl_specific_info.setter\n",
" def impl_specific_info(self, impl_specific_info):\n",
" self._impl_specific_info = impl_specific_info\n",
" def to_dict(self):\n",
" result = {}\n",
" for attr, _ in six.iteritems(self.swagger_types):\n",
" value = getattr(self, attr)\n",
" if isinstance(value, list):\n",
" result[attr] = list(map(\n",
" lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n",
" value\n",
" ))\n",
" elif hasattr(value, \"to_dict\"):\n",
" result[attr] = value.to_dict()\n",
" elif isinstance(value, dict):\n",
" result[attr] = dict(map(\n",
" lambda item: (item[0], item[1].to_dict())\n",
" value.items()\n",
" ))\n",
" else:\n",
" result[attr] = value\n",
" for key, value in self.items():\n",
" result[key] = value\n",
" return result\n",
" def to_str(self):\n",
" return pprint.pformat(self.to_dict())\n",
" def __repr__(self):\n",
" return self.to_str()\n",
" def __eq__(self, other):\n",
" return False\n",
" return self.__dict__ == other.__dict__\n",
" def __ne__(self, other):\n",
" return not self == other\n",
"\n",
"class SecurityInfo(object):\n",
" swagger_types = {'o_auth2_info': 'SecurityInfoOAuth2Info'}\n",
" attribute_map = {'o_auth2_info': 'oAuth2Info'}\n",
" def __init__(self, o_auth2_info=None): # noqa: E501\n",
" self._o_auth2_info = None\n",
" self.discriminator = None\n",
" if o_auth2_info is not None:\n",
" self.o_auth2_info = o_auth2_info\n",
" def o_auth2_info(self):\n",
" return self._o_auth2_info\n",
" @o_auth2_info.setter\n",
" def o_auth2_info(self, o_auth2_info):\n",
" self._o_auth2_info = o_auth2_info\n",
" def to_dict(self):\n",
" result = {}\n",
" for attr, _ in six.iteritems(self.swagger_types):\n",
" value = getattr(self, attr)\n",
" if isinstance(value, list):\n",
" result[attr] = list(map(\n",
" lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n",
" value\n",
" ))\n",
" elif hasattr(value, \"to_dict\"):\n",
" result[attr] = value.to_dict()\n",
" elif isinstance(value, dict):\n",
" result[attr] = dict(map(\n",
" lambda item: (item[0], item[1].to_dict())\n",
" value.items()\n",
" ))\n",
" else:\n",
" result[attr] = value\n",
" for key, value in self.items():\n",
" result[key] = value\n",
" return result\n",
" def to_str(self):\n",
" return pprint.pformat(self.to_dict())\n",
" def __repr__(self):\n",
" return self.to_str()\n",
" def __eq__(self, other):\n",
" return False\n",
" return self.__dict__ == other.__dict__\n",
" def __ne__(self, other):\n",
" return not self == other\n",
"\n",
"class SecurityInfoOAuth2Info(object):\n",
" swagger_types = {'grant_types': 'list[str]','token_endpoint': 'str'}\n",
" attribute_map = {'grant_types': 'grantTypes','token_endpoint': 'tokenEndpoint'}\n",
" def __init__(self, grant_types=None, token_endpoint=None): # noqa: E501\n",
" self._grant_types = None\n",
" self._token_endpoint = None\n",
" self.discriminator = None\n",
" self.grant_types = grant_types\n",
" self.token_endpoint = token_endpoint\n",
" def grant_types(self):\n",
" return self._grant_types\n",
" @grant_types.setter\n",
" def grant_types(self, grant_types):\n",
" if grant_types is None:\n",
" raise ValueError(\"Invalid value for `grant_types`, must not be `None`\") # noqa: E501\n",
" self._grant_types = grant_types\n",
" def token_endpoint(self):\n",
" return self._token_endpoint\n",
" @token_endpoint.setter\n",
" def token_endpoint(self, token_endpoint):\n",
" if token_endpoint is None:\n",
" raise ValueError(\"Invalid value for `token_endpoint`, must not be `None`\") # noqa: E501\n",
" self._token_endpoint = token_endpoint\n",
" def to_dict(self):\n",
" result = {}\n",
" for attr, _ in six.iteritems(self.swagger_types):\n",
" value = getattr(self, attr)\n",
" if isinstance(value, list):\n",
" result[attr] = list(map(\n",
" lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n",
" value\n",
" ))\n",
" elif hasattr(value, \"to_dict\"):\n",
" result[attr] = value.to_dict()\n",
" elif isinstance(value, dict):\n",
" result[attr] = dict(map(\n",
" lambda item: (item[0], item[1].to_dict())\n",
" value.items()\n",
" ))\n",
" else:\n",
" result[attr] = value\n",
" for key, value in self.items():\n",
" result[key] = value\n",
" return result\n",
" def to_str(self):\n",
" return pprint.pformat(self.to_dict())\n",
" def __repr__(self):\n",
" return self.to_str()\n",
" def __eq__(self, other):\n",
" return False\n",
" return self.__dict__ == other.__dict__\n",
" def __ne__(self, other):\n",
" return not self == other\n",
"\n",
"class OneOfTransportInfoEndpoint(object):\n",
" swagger_types = {}\n",
" attribute_map = {}\n",
" def __init__(self): # noqa: E501\n",
" self.discriminator = None\n",
" def uris(self):\n",
" return self._uris\n",
" @uris.setter\n",
" def uris(self, uris):\n",
" self._uris = uris\n",
" def to_dict(self):\n",
" result = {}\n",
" for attr, _ in six.iteritems(self.swagger_types):\n",
" value = getattr(self, attr)\n",
" if isinstance(value, list):\n",
" result[attr] = list(map(\n",
" lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n",
" value\n",
" ))\n",
" elif hasattr(value, \"to_dict\"):\n",
" result[attr] = value.to_dict()\n",
" elif isinstance(value, dict):\n",
" result[attr] = dict(map(\n",
" lambda item: (item[0], item[1].to_dict())\n",
" value.items()\n",
" ))\n",
" else:\n",
" result[attr] = value\n",
" for key, value in self.items():\n",
" result[key] = value\n",
" return result\n",
" def to_str(self):\n",
" return pprint.pformat(self.to_dict())\n",
" def __repr__(self):\n",
" return self.to_str()\n",
" def __eq__(self, other):\n",
" if not isinstance(other, OneOfTransportInfoEndpoint):\n",
" return False\n",
" return self.__dict__ == other.__dict__\n",
" def __ne__(self, other):\n",
" return not self == other\n",
"\n",
"class EndPointInfoUris(object):\n",
" swagger_types = {'_uris': 'list[str]'}\n",
" attribute_map = {'_uris': 'uris'}\n",
" def __init__(self, uris:list): # noqa: E501\n",
" self._uris = None\n",
" self.uris = uris\n",
" def uris(self):\n",
" return self._uris\n",
" @uris.setter\n",
" def uris(self, uris):\n",
" self._uris = uris\n",
" def to_dict(self):\n",
" result = {}\n",
" for attr, _ in six.iteritems(self.swagger_types):\n",
" value = getattr(self, attr)\n",
" if isinstance(value, list):\n",
" result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,value))\n",
" elif hasattr(value, 'to_dict'):\n",
" result[attr] = value.to_dict()\n",
" elif isinstance(value, dict):\n",
" result[attr] = dict(map(\n",
" lambda item: (item[0], item[1].to_dict())\n",
" if hasattr(item[1], 'to_dict') else item,\n",
" value.items()\n",
" ))\n",
" else:\n",
" result[attr] = value\n",
" for key, value in self.items():\n",
" result[key] = value\n",
" return result\n",
" def to_str(self):\n",
" return pprint.pformat(self.to_dict())\n",
" def __repr__(self):\n",
" return self.to_str()\n",
" def __eq__(self, other):\n",
" return False\n",
" return self.__dict__ == other.__dict__\n",
" def __ne__(self, other):\n",
" return not self == other\n",
"\n",
"class EndPointInfoFqdn(object):\n",
" swagger_types = {'_fqdn': 'list[str]'}\n",
" attribute_map = {'_fqdn': 'fqdn'}\n",
" def __init__(self, fqdn:list): # noqa: E501\n",
" self._fqdn = None\n",
" self.fqdn = fqdn\n",
" def fqdn(self):\n",
" return self._fqdn\n",
" @fqdn.setter\n",
" def fqdn(self, fqdn):\n",
" self._fqdn = fqdn\n",
" def to_dict(self):\n",
" result = {}\n",
" for attr, _ in six.iteritems(self.swagger_types):\n",
" value = getattr(self, attr)\n",
" if isinstance(value, list):\n",
" result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,value))\n",
" elif hasattr(value, 'to_dict'):\n",
" result[attr] = value.to_dict()\n",
" elif isinstance(value, dict):\n",
" result[attr] = dict(map(\n",
" lambda item: (item[0], item[1].to_dict())\n",
" if hasattr(item[1], 'to_dict') else item,\n",
" value.items()\n",
" ))\n",
" else:\n",
" result[attr] = value\n",
" for key, value in self.items():\n",
" result[key] = value\n",
" return result\n",
" def to_str(self):\n",
" return pprint.pformat(self.to_dict())\n",
" def __repr__(self):\n",
" return self.to_str()\n",
" def __eq__(self, other):\n",
" return False\n",
" return self.__dict__ == other.__dict__\n",
" def __ne__(self, other):\n",
" return not self == other\n",
"\n",
"class EndPointInfoAddress(object):\n",
" swagger_types = {'_host': 'str', '_port': 'int'}\n",
" attribute_map = {'_host': 'host', '_port': 'port'}\n",
" def __init__(self, host:str, port:list): # noqa: E501\n",
" self._host = None\n",
" self._port = None\n",
" self.host = host\n",
" self.port = port\n",
" def host(self):\n",
" return self.host\n",
" @host.setter\n",
" def host(self, host):\n",
" self._host = host\n",
" def port(self):\n",
" return self._port\n",
" @port.setter\n",
" def port(self, port):\n",
" self._port = qosport_kpi\n",
" def to_dict(self):\n",
" result = {}\n",
" for attr, _ in six.iteritems(self.swagger_types):\n",
" value = getattr(self, attr)\n",
" if isinstance(value, list):\n",
" result[attr] = list(map(\n",
" lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,\n",
" value\n",
" ))\n",
" elif hasattr(value, 'to_dict'):\n",
" result[attr] = value.to_dict()\n",
" elif isinstance(value, dict):\n",
" result[attr] = dict(map(\n",
" lambda item: (item[0], item[1].to_dict())\n",
" if hasattr(item[1], 'to_dict') else item,\n",
" value.items()\n",
" ))\n",
" else:\n",
" result[attr] = value\n",
" for key, value in self.items():\n",
" result[key] = value\n",
" return result\n",
" def to_str(self):\n",
" return pprint.pformat(self.to_dict())\n",
" def __repr__(self):\n",
" return self.to_str()\n",
" def __eq__(self, other):\n",
" return False\n",
" return self.__dict__ == other.__dict__\n",
" def __ne__(self, other):\n",
" return not self == other\n",
"\n",
"class EndPointInfoAddresses(object):\n",
" swagger_types = {'_addresses': 'list[EndPointInfoAddress]'}\n",
" attribute_map = {'_addresses': 'addresses'}\n",
" def __init__(self, addresses:list): # noqa: E501\n",
" self._addresses = None\n",
" self.addresses = addresses\n",
" def addresses(self):\n",
" return self._addresses\n",
" @addresses.setter\n",
" def addresses(self, addresses):\n",
" self._addresses = addresses\n",
" def to_dict(self):\n",
" result = {}\n",
" for attr, _ in six.iteritems(self.swagger_types):\n",
" value = getattr(self, attr)\n",
" if isinstance(value, list):\n",
" result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,value))\n",
" elif hasattr(value, 'to_dict'):\n",
" result[attr] = value.to_dict()\n",
" elif isinstance(value, dict):\n",
" result[attr] = dict(map(\n",
" lambda item: (item[0], item[1].to_dict())\n",
" if hasattr(item[1], 'to_dict') else item,\n",
" value.items()\n",
" ))\n",
" else:\n",
" result[attr] = value\n",
" for key, value in self.items():\n",
" result[key] = value\n",
" return result\n",
" def to_str(self):\n",
" return pprint.pformat(self.to_dict())\n",
" def __repr__(self):\n",
" return self.to_str()\n",
" def __eq__(self, other):\n",
" return False\n",
" return self.__dict__ == other.__dict__\n",
" def __ne__(self, other):\n",
" return not self == other\n",
"\n",
"class EndPointInfoAlternative(object):\n",
" swagger_types = {'alternative': 'object'}\n",
" attribute_map = {'alternative': 'alternative'}\n",
" def __init__(self, alternative=None): # noqa: E501\n",
" self._alternative = None\n",
" self.discriminator = None\n",
" self.alternative = alternative\n",
" def alternative(self):\n",
" return self._alternative\n",
" @alternative.setter\n",
" def alternative(self, alternative):\n",
" if alternative is None:\n",
" raise ValueError(\"Invalid value for `alternative`, must not be `None`\") # noqa: E501\n",
" self._alternative = alternative\n",
" def to_dict(self):\n",
" result = {}\n",
" for attr, _ in six.iteritems(self.swagger_types):\n",
" value = getattr(self, attr)\n",
" if isinstance(value, list):\n",
" result[attr] = list(map(\n",
" lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n",
" result[attr] = value.to_dict()\n",
" elif isinstance(value, dict):\n",
" result[attr] = dict(map(\n",
" lambda item: (item[0], item[1].to_dict())\n",
" value.items()\n",
" ))\n",
" else:\n",
" result[attr] = value\n",
" for key, value in self.items():\n",
" result[key] = value\n",
" return result\n",
" def to_str(self):\n",
" return pprint.pformat(self.to_dict())\n",
" def __repr__(self):\n",
" return self.to_str()\n",
" def __eq__(self, other):\n",
" return False\n",
" return self.__dict__ == other.__dict__\n",
" def __ne__(self, other):\n",
" return not self == other\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The function below is creating an application MEC services\n",
"\n",
"**Note:** This is call application MEC service in opposition of a standardized MEC service exposed by the MEC Sanbox such as MEC 013, MEC 030...\n",
"\n",
"**Reference:** ETSI GS MEC 011 V3.2.1 (2024-04) Clause 8.2.6.3.4 POST"
]
},
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def create_mec_service(sandbox_name: str, app_inst_id: swagger_client.models.application_info.ApplicationInfo) -> object:\n",
" \"\"\"\n",
" Request to create a new application MEC service\n",
" :param sandbox_name: The MEC Sandbox instance to use\n",
" :param app_inst_id: The MEC application instance identifier\n",
" :param sub_id: The subscription identifier\n",
" :return The HTTP response, the response status and the headers on success, None otherwise\n",
" :see ETSI GS MEC 011 V3.2.1 (2024-04) Clause 8.2.6.3.4 POST\n",
" \"\"\"\n",
" global MEC_PLTF, CALLBACK_URI, logger, service_api\n",
" url = '/{sandbox_name}/{mec_pltf}/mec_service_mgmt/v1/applications/{app_inst_id}/services'\n",
" logger.debug('create_mec_service: url: ' + url)\n",
" path_params = {}\n",
" path_params['sandbox_name'] = sandbox_name\n",
" path_params['mec_pltf'] = MEC_PLTF\n",
" header_params['Accept'] = 'application/json' # noqa: E501\n",
" # HTTP header `Content-Type`\n",
" header_params['Content-Type'] = 'application/json' # noqa: E501\n",
" # Body request\n",
" callback = CALLBACK_URI + '/statistic/v1/quantity'\n",
" transport_info = TransportInfo(id=str(uuid.uuid4()), name='HTTP REST API', type='REST_HTTP', protocol='HTTP', version='2.0', security=SecurityInfo(), endpoint=OneOfTransportInfoEndpoint())\n",
" transport_info.endpoint.uris=[EndPointInfoUris(callback)]\n",
" category_ref = CategoryRef(href=callback, id=str(uuid.uuid4()), name='Demo', version='1.0.0')\n",
" appServiceInfo = ServiceInfo(ser_name='demo6 MEC Service', ser_category=category_ref, version='1.0.0', state='ACTIVE',transport_info=transport_info, serializer='JSON')\n",
" (result, status, headers) = service_api.call_api(url, 'POST', header_params=header_params, path_params=path_params, body=appServiceInfo, async_req=False)\n",
" return (result, status, headers['Location'])\n",
" except ApiException as e:\n",
" logger.error('Exception when calling call_api: %s\\n' % e)\n",
" return None\n",
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The function below is deleting an application MEC services.\n",
"\n",
"**Reference:** ETSI GS MEC 011 V3.2.1 (2024-04) Clause 8.2.7.3.5 DELETE"
]
},
"execution_count": null,
" \"\"\"\n",
" Request to create a new application MEC service\n",
" :param sandbox_name: The MEC Sandbox instance to use\n",
" :param app_inst_id: The MEC application instance identifier\n",
" :param sub_id: The subscription identifier\n",
" :return 0 on success, -1 otherwise\n",
" :see ETSI GS MEC 011 V3.2.1 (2024-04) Clause 8.2.7.3.5 DELETE\n",
" \"\"\"\n",
" logger.debug('>>> delete_mec_subscription: resource_url: ' + resource_url)\n",
" try:\n",
" res = urllib3.util.parse_url(resource_url)\n",
" if res is None:\n",
" logger.error('delete_mec_subscription: Failed to paerse URL')\n",
" return -1\n",
" header_params = {}\n",
" # HTTP header `Accept`\n",
" header_params['Accept'] = 'application/json' # noqa: E501\n",
" # HTTP header `Content-Type`\n",
" header_params['Content-Type'] = 'application/json' # noqa: E501\n",
" service_api.call_api(res.path, 'DELETE', header_params=header_params, async_req=False)\n",
" return 0\n",
" except ApiException as e:\n",
" logger.error('Exception when calling call_api: %s\\n' % e)\n",
" return -1\n",
" # End of function delete_mec_service"
"execution_count": null,
"outputs": [],
"source": [
"def process_main():\n",
" \"\"\"\n",
" This is the second sprint of our skeleton of our MEC application:\n",
" - Mec application setup\n",
" - Create new MEC service\n",
" - Send a request to our MEC service\n",
" - Delete newly created MEC service\n",
" - Mec application termination\n",
" \"\"\" \n",
" global LISTENER_IP, LISTENER_PORT, CALLBACK_URI, logger\n",
"\n",
" logger.debug('Starting at ' + time.strftime('%Y%m%d-%H%M%S'))\n",
" logger.debug('\\t pwd= ' + os.getcwd())\n",
"\n",
" httpd = start_notification_server()\n",
" # Create the MEC service\n",
" result, status, mec_service_resource = create_mec_service(sandbox_name, app_inst_id)\n",
" if status != 201:\n",
" logger.error('Failed to create MEC service')\n",
" logger.info('mec_service_resource: %s', mec_service_resource)\n",
"\n",
" # Any processing here\n",
" logger.info('body: ' + str(result.data))\n",
" data = json.loads(result.data)\n",
" logger.info('data: %s', str(data))\n",
" logger.info('=============> Execute the command: curl %s/statistic/v1/quantity', CALLBACK_URI)\n",
" time.sleep(30)\n",
"\n",
" # Stop notification server\n",
" stop_notification_server(httpd)\n",
"\n",
" # Delete the MEC servce\n",
" delete_mec_service(mec_service_resource)\n",
"\n",
" # Terminate the MEC application\n",
" mec_app_termination(sandbox_name, app_inst_id, sub_id)\n",
"\n",
" logger.debug('Stopped at ' + time.strftime('%Y%m%d-%H%M%S'))\n",
" # End of function process_main\n",
"\n",
"if __name__ == '__main__':\n",
" process_main()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Annexes\n",
"\n",
"## Annex A: How to use an existing MEC sandbox instance\n",
"\n",
"This case is used when the MEC Sandbox API is not used. The procedure is the following:\n",
"- Log to the MEC Sandbox using a WEB browser\n",
"- Select a network scenario\n",
"- Create a new application instance\n",
"\n",
"When it is done, the newly created application instance is used by your application when required. This application instance is usually passed to your application in the command line or using a configuration file\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"1. ETSI GS MEC 002 (V2.2.1) (01-2022): \"Multi-access Edge Computing (MEC); Phase 2: Use Cases and Requirements\".\n",
"2. ETSI GS MEC 010-1 (V1.1.1) (10-2017): \"Mobile Edge Computing (MEC); Mobile Edge Management; Part 1: System, host and platform management\".\n",
"3. ETSI GS MEC 010-2 (V2.2.1) (02-2022): \"Multi-access Edge Computing (MEC); MEC Management; Part 2: Application lifecycle, rules and requirements management\".\n",
"4. ETSI GS MEC 011 (V3.1.1) (09-2022): \"Multi-access Edge Computing (MEC); Edge Platform Application Enablement\".\n",
"5. ETSI GS MEC 012 (V2.2.1) (02-2022): \"Multi-access Edge Computing (MEC); Radio Network Information API\".\n",
"6. ETSI GS MEC 013 (V2.2.1) (01-2022): \"Multi-access Edge Computing (MEC); Location API\".\n",
"7. ETSI GS MEC 014 (V2.1.1) (03-2021): \"Multi-access Edge Computing (MEC); UE Identity API\".\n",
"8. ETSI GS MEC 015 (V2.1.1) (06-2020): \"Multi-Access Edge Computing (MEC); Traffic Management APIs\".\n",
"9. ETSI GS MEC 016 (V2.2.1) (04-2020): \"Multi-access Edge Computing (MEC); Device application interface\".\n",
"10. ETSI GS MEC 021 (V2.2.1) (02-2022): \"Multi-access Edge Computing (MEC); Application Mobility Service API\".\n",
"11. ETSI GS MEC 028 (V2.3.1) (07-2022): \"Multi-access Edge Computing (MEC); WLAN Access Information API\".\n",
"12. ETSI GS MEC 029 (V2.2.1) (01-2022): \"Multi-access Edge Computing (MEC); Fixed Access Information API\".\n",
"13. ETSI GS MEC 030 (V3.2.1) (05-2022): \"Multi-access Edge Computing (MEC); V2X Information Service API\".\n",
"14. ETSI GR MEC-DEC 025 (V2.1.1) (06-2019): \"Multi-access Edge Computing (MEC); MEC Testing Framework\".\n",
"15. ETSI GR MEC 001 (V3.1.1) (01-2022): \"Multi-access Edge Computing (MEC); Terminology\".\n",
"16. ETSI GR MEC 003 (V3.1.1): Multi-access Edge Computing (MEC); \n",
"Framework and Reference Architecture\n",
"17. [The Wiki MEC web site](https://www.etsi.org/technologies/multi-access-edge-computing)\n"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
}
},
"nbformat": 4,
"nbformat_minor": 4
}