hash stringlengths 32 32 | doc_id stringlengths 5 12 | section stringlengths 5 1.47k | content stringlengths 0 6.67M |
|---|---|---|---|
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.2 Use case #2: Enhancement of radio network performance assurance scenarios
| The use case of enhancement of radio network performance assurance scenarios is introduced in clause 4.2 and following management capabilities are identified:
- MnS consumer expresses radio network performance assurance expectation for a specific RAN feature.
It is recommended to enhance the RadiNetworkExpectation and generic ExpectationTarget defined in 3GPP TS 28.312 [1] to support above identified management capabilities:
- Add "rANFeatureContext" as ObjectContexts for the RadioNetworkExpectation to represent the expected specific RAN feature for RAN Subnetwork that the intent expectation is applied.
The detailed solution in clause 4.2.3 is used as baseline for normative work.
|
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.3 Use case #3: Assisting and reporting intent decomposition across intent handling functions
| The use case description, requirements and a potential solution for assisting and reporting intent decomposition across intent handling functions are described in clause 4.3. This use case enables an MnS consumer to specify the intent handling functions that are not recommended for intent decomposition as an expectation context as well as to receive an intent report regarding intent decomposition.
The potential solution described in clause 4.3.3.1, which proposes enhancing the existing intent expectations with adding a new context as well as enhancing the intent report with information on decomposition of an intent, can be used as baseline for normative work.
NOTE: During normative phase, enhancing the intent report with information on intent decomposition can be considered with the solution proposed for intent traceability in clause 4.4.3.1 of present document.
|
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.4 Use case #4: Intent traceability
| |
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.5 Use case #5: Invariant Guidance in Intent Contexts
| |
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.6 Use case #6: Intent Interpretation Assistance Information
| |
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.7 Use case #7: Enhancement of intent exploration
| The use case of enhancement of intent exploration is introduced in clause 4.7 and following management capabilities are identified:
- The capability enabling the MnS consumer to request to periodically obtain the exploration report.
- The capability enabling the MnS consumer to obtain the best target values for individual object represented by the ExpectationObject in an IntentExpectation.
It is recommended to enhance the generic information model definition for intent driven management defined in 3GPP TS 28.312 [1] to support above identified management capabilities:
- Extend the attribute "observationPeriod" in IntentReportControl <<dataType>> to indicate the time period for which the IntentExplorationReport is observed and reported.
- Add cellContext, coverageAreaPolygonContext as targetContexts for the ExpectationTarget <<dataType>> which is used for the attribute targetExplorationResult.
- Extend the IntentExplorationReport <<dataType>> by adding the attribute "expectationExplorationStatus".
The detailed solution in clause 4.7.3 is used as baseline for normative work.
|
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.8 Use case #8: Support to express guarantee requirements in an intent
| |
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.9 Use case #9: Intent handling capability configuration, registration and discovery
| The use case of Intent handling capability configuration, registration and discovery is described in clause 4.11 and following management capabilities are identified:
- The capability enabling an MnS consumer to obtain intent handling capabilities of each intent handling function, including supported contexts.
- The capability enabling an MnS consumer to obtain intent negotiation capability of a specific intent handling function.
It is recommended to enhance the generic information model definition for intent driven management defined in 3GPP TS 28.312 [1] to support above identified management capabilities:
- Add attribute "supportedObjectContextInfoList" and "supportedExpectationContextInfoList" as attributes of IntentHandlingCapability <<dataType>>.
- Add attribute "supportedNegotiationFunctionalities" and "intentHandlingScope" as attributes of IntentHandlingCapability <<dataType>>.
The detailed solution in clause 5.9.3 is used as baseline for normative work.
|
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.10 Use Case#10: Radio network delivering in transient overload scenario
| |
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.11 Use case #11: Enhancing intent feasibility check capability
| The use case of enhancement of intent feasibility check capability is introduced in clause 4.11 and following management capabilities are identified:
- The capability enabling the MnS consumer to receive recommended values for infeasible targets.
The potential solution described in clause 4.11.3.1 proposes a new allowed value "FEASIBILITYCHECK_WITH_EXPLORATION" that is to be included for intentMgmtPurpose attribute.
The potential solution described in clause 4.11.3.2 proposes to extend the type for attribute "inFeasibleTargets" from "String" to "inFeasibleTargetInfo <<dataType>>", which includes targetName and recommendedValue.
|
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.12 Use case #12: Documentation for the overview of intent driven management functionalities
| The overview of intent driven management functionalities and corresponding usage for different phases is introduced in 4.12.3, including intent investigation and pre-evaluation phase and intent fulfilment.
It is recommended to add a new concept section in clause 4 in 3GPP TS 28.312 [1] to illustrate the overview of intent driven management functionalities. The detailed solution in clause 4.12.3 is used as baseline for normative work.
|
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.13 Use case #13: Improve intent life cycle documentation
| The evaluation shows that potential solution #2 (clause 4.13.3.2) aligns most closely with the intent state definitions and behaviours described in 3GPP TS 28.312 [1]. States like FULFILLED, DEGRADED and SUSPENDED are already defined. By introducing only two new transient states - EXPLORING for feasibility check and negotiation and FULFILLING for the fulfilment phase - solution #2 provides a clear separation between non-fulfilment and fulfilment activities without creating additional observable states. The EXPLORING state captures the automatic feasibility check and any negotiation that occurs before the intent progresses to fulfilment or is deleted. The FULFILLING state explicitly represents ongoing execution, allowing the system to report progress and to transition to DEGRADED, FULFILLED, SUSPENDED or TERMINATED as appropriate.
The detailed potential solution #2 in clause 4.13.3.2 should be used as baseline for normative work. The new description and state diagram should replace the content in clause 4.7 of 3GPP TS 28.312 [1].
|
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.14 Use case #14: Intent expectation satisfied information
| |
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.15 Use case #15: Relation and Interaction with MnS producers for AI/ML Management
| The use case description, requirements and a potential solution for relation and interaction with MnS producers for AI/ML Management are described in clause 4.15. This use case clarifies the relation and interaction of intent-driven MnS producers with MnS producers for ML model lifecycle management in both intent pre-evaluation phase and intent fulfilment phase.
The potential solution described in clause 4.15.3.1, which proposes adding text in 3GPP TS 28.312 [1] in order to describe possible interactions between intent-driven MnS producer and MnS producer for ML model lifecycle management can be used as a baseline for normative work. The exact text and the clause to which it belongs can be decided during the normative phase.
|
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.16 Use case #16: Investigation on the applicability and potential impacts to support natural language intents translation
| Regarding the Deployment scnenario#1(Intent Interpreter as a separate function outside the intent handling function), the Intent Interpreter is MnS consumer's internal implementation and the existing intent driven management service can be used to satisfy the interaction between intent handling function and MnS consumer with Intent Interpreter embedded.
Regarding the Deployment scnenario#2(Intent Interpreter is a function integrated in intent handling function), needs further investigation and discussion in 6G to identify corresponding requirements.
|
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.17 Use case #17: Enhancement of core network and service delivering and assurance scenarios
| |
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.18 Use case #18: The relation and the interactions between intent handling function and NDTFunction
| |
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.19 Use case #19: Enhancement of radio service scenarios for service protection
| |
bbd9841f4f65b6569258419594b8dc01 | 28.881 | 5.20 Use case #20: New deployment scenario for Intent Handling Function at ManagedElement
| Annex A:
Change history
Change history
Date
Meeting
TDoc
CR
Rev
Cat
Subject/Comment
New version
2025-08
SA5#162
Initial version.
0.0.0
2025-09
SA5#162
S5-254121
draftTR
Draft TR v0.1.0
S5-254032 Add structure proposal
S5-254033 Add new issue for enhancement of radio service delivering and assurance scenarios
S5-254034 Add new issue for enhancement of radio network performance assurance scenarios
S5-254035 Add issue description, requirement and solution for intent decomposition
S5-254036 Add issue, requirements and potential solution for intent traceability
S5-254037 Invariant Guidance in Intent Contexts
Intent interpretation information
S5-254038 Add new issue for Intent exploration enhancement
S5-254039 Add Key Issue on Intent feasibility check
S5-254040 enhancement to support resource reservation
S5-254042 Add new issue for Intent handling capability registration and discovery
0.1.0
2025-10
SA5#163
S5‑254896
draftTR
Draft TR v0.2.0
S5-254645 Add solution for enhancement of radio network performance assurance scenarios
S5-254646 Add solution for enhancement of radio service delivering and assurance scenarios
S5-254647 Add new requirements and solution for enhancement radio service delivering and assurance scenarios
S5-254648 Add new use case for radio service assurance in transient overload scenarios
S5-254649 Add use-case description, requirement and solution for enhancing feasibility check
S5-254650 Add Solution to Support to Express Guarantee Requirements in an Intent
S5-254652 Add solution for Intent exploration enhancement
S5-254653 Documentation for the overview of intent driven management functionalities
S5-254654 Add use case for the investigation on the transition of intent Lifecycle management state
S5-254655 Add Use case on intent expectation satisfaction information
S5-254656 Add solution for Intent handling capability configuration, registration and discovery
S5-254657 Add use-case description, requirement and solution for relation and interaction with AIML
S5-254658 Add use case for the Investigation on the applicability and potential impacts to support natural language intents translation
S5-254659 Add solution for use case#3
S5-254660 Add potential solution for UC#4 intent traceability
S5-254884 Add description and requirements for intent guarantee UC#8
0.2.0
2025-11
SA5#164
S5-255470
draftTR
S5-255071: Add evaluation and conclusion for Use case #7 Enhancement of intent exploration
S5-255245: Add potential solution, evaluation and recommendation for Use Case#15
S5-255386: Add description and conclusion for WT 2.1
S5-255387: Add scope
S5-255491: Add requirements and solution for expressing the relative values for the target
S5-255492: Add evaluation and conclusion for Use case #1 Enhancement of radio service delivering and assurance scenarios
S5-255494: Add use case for enhancement of Core network delivering and assurance scenarios
S5-255495: Update Solution for enhancing intent feasibility check capability
S5-255496: Enhance solution for Use-Case#11 and add evaluation, recommendations
S5-255497: Add evaluation and conclusion for Use case #12 Documentation for the overview of intent driven management functionalities
S5-255500: Enhance solution for Use case#13 Intent Lifecycle Management State Transition
S5-255501: Add description and solution to intent LCM states UC#13
S5-255502: Update Use case #9 Intent handling capability configuration, registration and discovery
S5-255503: Add solution for intent guarantee UC#8
S5-255504: Add use case for the relation and the interactions between intent handling function and NDT
S5-255625: Intent Interpretation Assistance Information Solution
S5-255626: Update Use case #16 Investigation on the applicability and potential impacts to support natural language intents translation
S5-255628: Invariant Guidance in Intent Contexts Solution
S5-255629: Add evaluation and recommendations for Use case#3
S5-255683: Add use case on Enhancement of radio service for protection level
0.3.0
2025-12
SA#110
SP-251412
Presentation to TSG SA for approval
1.0.0
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 1 Scope
| This Technical Report (TR) explains how application (App) developers can leverage the services from enablement frameworks, namely Common API Framework (CAPIF), Edge Application Enablement (EDGEAPP), and the Service Enabler Architecture Layer (SEAL) to create their software.
To facilitate understanding, this study presents a set of representative deployment options. These are provided as examples to illustrate common operator scenarios, but they do not limit the options that the frameworks offer. The TR will cover the linkage between the available services with different vertical use cases, to guide App developers on how to use the different services to fulfil their use cases.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 2 References
| The following documents contain provisions which, through reference in this text, constitute provisions of the present document.
- References are either specific (identified by date of publication, edition number, version number, etc.) or non‑specific.
- For a specific reference, subsequent revisions do not apply.
- For a non-specific reference, the latest version applies. In the case of a reference to a 3GPP document (including a GSM document), a non-specific reference implicitly refers to the latest version of that document in the same Release as the present document.
[1] 3GPP TR 21.905: "Vocabulary for 3GPP Specifications".
[2] 3GPP TS 23.222: "Common API Framework for 3GPP Northbound APIs (CAPIF); (Stage 2)".
[3] 3GPP TS 29.222: "Common API Framework for 3GPP Northbound APIs (CAPIF); (Stage 3)".
[4] 3GPP TS 23.558: "Architecture for enabling Edge Applications".
[5] 3GPP TS 29.558: "Enabling Edge Applications; Application Programming Interface (API) specification; (Stage 3)".
[6] 3GPP TS 23.434: "Service Enabler Architecture Layer for Verticals (SEAL); Functional architecture and information flows".
[7] 3GPP TS 33.122: "Security aspects of Common API Framework (CAPIF) for 3GPP northbound APIs".
[8] 3GPP TS 33.558: "Security aspects of enhancement of support for enabling edge applications".
[9] 3GPP TS 33.434: "Security aspects of Service Enabler Architecture Layer (SEAL) for verticals".
[10] IETF RFC 6749: "The OAuth 2.0 Authorization Framework".
[11] IETF RFC 7519: "JSON Web Token (JWT)".
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 3 Definitions of terms, symbols and abbreviations
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 3.1 Terms
| For the purposes of the present document, the terms given in 3GPP TR 21.905 [1] and the following apply. A term defined in the present document takes precedence over the definition of the same term, if any, in 3GPP TR 21.905 [1].
Application Client (AC): An application component, typically hosted on User Equipment (UE), that consumes services provided by an EAS (as defined in 3GPP TS 23.558 [4]).
Application Context: A set of data about the Application Client that resides in the Edge Application Server (as defined in 3GPP TS 23.558 [4]).
CAPIF API Invoker: An entity that consumes APIs exposed via CAPIF (as defined in 3GPP TS 23.222 [2]).
CAPIF API Provider: An entity that offers APIs via CAPIF (as defined in 3GPP TS 23.222 [2]).
Common API Framework (CAPIF): A 3GPP framework that provides common functions for API exposure, onboarding, discovery, and authorization across multiple domains and stakeholders (as defined in 3GPP TS 23.222 [2]).
Edge Application Server (EAS): An application component hosted on an edge node that provides services to ACs (as defined in 3GPP TS 23.558 [4]).
Edge Enabler Client (EEC): A client-side function, co-located with the AC, that interacts with the Edge Enabler Server (EES) for discovery, registration, and mobility support (as defined in 3GPP TS 23.558 [4]).
Edge Enabler Server (EES): A network function that provides EDGEAPP control plane services to EECs, including EAS discovery, mobility handling, and service continuity (as defined in 3GPP TS 23.558 [4]).
Edge Computing Service Provider (ECSP): An operator or provider responsible for deploying and operating EDGEAPP functions (ECS, EES, EAS) in the network (as defined in 3GPP TS 23.558 [4]).
Service Enabler Architecture Layer (SEAL): A framework providing reusable service enablers such as location, group communications, and messaging, available to vertical applications (as defined in 3GPP TS 23.434 [6]).
SEAL Server: A server implementing SEAL service enabler functions, possibly hosted centrally or at the edge, and accessible via CAPIF (as defined in 3GPP TS 23.434 [6]).
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 3.2 Symbols
| For the purposes of the present document, the following symbols apply:
<symbol> <Explanation>
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 3.3 Abbreviations
| For the purposes of the present document, the abbreviations given in 3GPP TR 21.905 [1] and the following apply. An abbreviation defined in the present document takes precedence over the definition of the same abbreviation, if any, in 3GPP TR 21.905 [1].
AC Application Client
AEF API Exposing Function
AMF API Managing Function
APF API Publishing Function
CAPIF Common API Framework
CCF CAPIF Core Function
EAS Edge Application Server
ECSP Edge Computing Service Provider
EEC Edge Enabler Client
EES Edge Enabler Server
ECS Edge Configuration Server
EDGEAPP Edge Application Enablement
JSON JavaScript Object Notation
OAuth Open Authorization
REST Representational State Transfer
SEAL Service Enabler Architecture Layer
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 4 Overview of Frameworks
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 4.1 Introduction
| Emerging 5G vertical services have requirements that can include low-latency, high-bandwidth, and context-aware processing at the network edge. To address these needs, 3GPP has developed several application enablement frameworks, each targeting a specific aspect of the application layer architecture:
- Common API Framework (CAPIF) – provides a unified, secure way to expose and consume service and network APIs across multiple domains and stakeholders, specified at stage-2 in 3GPP TS 23.222 [2]. CAPIF offers a harmonized approach for API development and exposure, allowing 3GPP network functions and even third parties to publish and discover APIs in a common environment.
- Edge Application Enablement (EDGEAPP) – specifies an architecture for applications at the network edge, including support for local service discovery, application lifecycle management, and continuity during user mobility, specified at stage-2 in 3GPP TS 23.558 [4]. EDGEAPP enables edge computing with minimal changes to existing applications, abstracting the edge infrastructure complexity behind standardized interfaces.
- Service Enabler Architecture Layer (SEAL) – defines a layer of reusable service enablers (e.g., location, group communications, messaging) available to vertical applications via standardized APIs, specified at stage-2 in 3GPP TS 23.434 [6]. By providing common functions that many industries require, SEAL allows different vertical applications to leverage the same core capabilities (for example, a group communication service or location service) instead of each vertical implementing its own.
This Technical Report provides an overview of how these frameworks work together and guides application developers on using them to build advanced services.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 4.2 Common API Framework (CAPIF)
| This clause will provide the CAPIF role in secure API exposure, onboarding, and discovery.The Common API Framework (CAPIF) is a 3GPP framework that provides common functions for secure API exposure, discovery, onboarding, and authorization across multiple domains, 3GPP TS 23.222 [2]. Its primary role is to harmonize how service APIs are published and consumed, offering a single point of entry for applications (API invokers) towards the common API aspects (CAPF APIs) and a consistent method for API providers to expose their service APIs. By introducing a common API framework, CAPIF prevents fragmentation because application developers and third-party service providers can use one standardized approach, rather than dealing with independent interfaces for each service API. CAPIF is designed to be used in conjunction with other frameworks, where it is agnostic to the content of the APIs and instead focuses on the exposure mechanism for APIs.
CAPIF was first specified in 3GPP Release 15 and has since been adopted for exposing APIs from core network functions (e.g. NEF for network capabilities, MBMS, etc.) as well as from application-enablement layer services, in a secure and controlled manner.
The CAPIF architecture is based on a service-oriented model with three main entity groups as illustrated in Figure 4.2.1, specifically a CAPIF Core Function (CCF), the API Invoker and one or more API Provider domains:
- CAPIF Core Function (CCF): The CCF handles the onboarding of API invokers and API registering of API provider domain functions (establishing trust and identity for each). It maintains the service API registry for discovery, and provides common services like authentication, authorization token issuance and logging.
- API Exposing Function (AEF): A function on the API provider domain side that hosts one or more service APIs and exposes them to external consumers (API Invokers). The AEF is the entry point through which an API invoker accesses the provider’s service API; it enforces the service’s access policies and handles the runtime service API calls (e.g. rate limiting). A 3GPP network function or application server can presented themselves as an AEF to offer their service APIs in a standardized way.
- API Publishing Function (APF): A provider-side function responsible for publishing the service API information and endpoints of the AEF to the CAPIF Core Function. When an API is made available, the APF registers the API’s meta-information (e.g. name, version, resource paths, supported operations) with the CCF, so that prospective invokers can discover it.
- API Management Function: A provider-side management entity that allows the API provider to administer and monitor their APIs. The API Management Function interfaces with the CCF for reporting and retrieving logs of API invocations (for auditing), subscribing to events (e.g. notifications of certain API usage or threshold breaches).
- API Invoker: The consuming entity that uses CAPIF to discover and invoke service APIs. An API Invoker could be an external third-party application or another network function/application within the operator’s environment. The invoker first onboards with the CAPIF core function to establish its identity and credentials, then queries the API registry to discover available services, and finally invokes the desired API on the corresponding AEF, obtaining authorization from the CCF as required. In a developer context, the API Invoker role is played by the developer’s application or service that seeks to utilize operator or third-party APIs in a secure manner.
Figure 4.2.1: Functional model for the CAPIF as defined in 3GPP TS 23.222 [2]
CAPIF operates through a set of well-defined procedures and interfaces. At a high level, the lifecycle of API exposure and consumption in CAPIF is as follows:
1. Onboarding and registration: An API provider (such as an Edge Configuration Server in an edge computing scenario) will register with the CCF to become a recognized provider, typically using credentials or certificates issued by the operator’s CAPIF authority (see clause 8.28 of 3GPP TS 23.222 [2]). Similarly, an application acting as an API invoker (e.g. a vertical application server or a UE client) will onboard with the CCF to obtain a secure invoker identity (see clause 8.1 of 3GPP TS 23.222 [2]). The CAPIF core function can provision digital certificates or JSON Web Tokens (JWT) and record the entity’s public information (like its name, domain, and roles) in its database. This establishes a trust relationship: the CCF recognizes the entity as an authorized API provider or consumer in the system.
2. API Publication (see clause 8.3 of 3GPP TS 23.222 [2]): Once registered, an API provider exposes its service API through CAPIF. The provider’s API Publishing Function sends the API description to the CAPIF core (via the CAPIF publishing interface, e.g. CAPIF-4) to register the API in the registry. This publication typically includes the API’s endpoint URI (which can point to the AEF), the resource structure and methods, required security scopes or policies, and any other metadata (version, category, etc.). For instance, in an EDGEAPP scenario, after an Edge Configuration Server (ECS) registers, it would publish its available service APIs (like edge node registration API, configuration APIs) to CAPIF so that edge clients or other components can later discover them. The CAPIF core can verify that the publishing entity is authorized to expose those APIs (e.g. checking that the provider is indeed entitled to publish an “Edge Configuration” service). Once published, the API is discoverable by the authorized invokers.
3. Discovery (see clause 8.7 of 3GPP TS 23.222 [2]): An API invoker queries the CAPIF Core Function to discover information a service API. Discovery can be performed using various criteria (service name, category, provider, etc.). The CCF will return the details of the AEF address, interface details and information on how to invoke it. CAPIF supports a federated discovery if multiple CCFs are interconnected, but within a single domain the CCF acts as the central lookup for all APIs. For example, an Edge Enabler Client (EEC) that needs to call a service on an Edge Application Server (EAS) can query CAPIF (via the CCF) to get the API endpoint and requirements for the EAS’s service API.
4. API Invocation with Authorization: Before invoking the target API, the API invoker obtains authorization from CAPIF. In CAPIF’s security framework, the CCF can function as an OAuth2 Authorization Server for API access tokens, see 3GPP TS 33.122 [7]. The invoker (acting as an OAuth client) requests an access token from the CCF, proving its identity (using credentials established at onboarding) and specifying the API it wants to call. The CCF issues a OAuth2 token if the invoker is allowed to use that API, with appropriate scope/permissions encoded. Armed with this token, the invoker then sends the API request to the provider’s AEF (over the CAPIF-internal interface to the AEF, e.g. CAPIF-2) and includes the token in the invocation. The AEF validates the token (by verifying its signature and checking with CCF if needed) and, if valid, allows the request to be processed by the underlying service. This ensures that only properly onboarded and authorized applications can invoke protected APIs. CAPIF also supports additional authorization models – for example, a mode where a “Resource Owner” (end-user or owner of the accessed resource) involvement is required for authorization (termed Resource Owner Aware API Access, RNAA).
5. Logging and Monitoring (see clause 8.19 and 8.21 respectively of 3GPP TS 23.222 [2]): As APIs are invoked, CAPIF provides a logging service. Each service API invocation and response can be logged via the CAPIF core (or the provider’s API Management Function reporting to CCF), recording details such as who invoked which API, when, and with what result. These logs enable auditing and troubleshooting. CAPIF can also emit events or notifications – for instance, if an API provider wants to be notified when a new invoker enrols to its API or when certain thresholds are exceeded, the framework can support that through an events interface.
For application developers, CAPIF greatly simplifies integration with 3GPP network services and other service platforms. Instead of dealing with separate authentication and discovery mechanisms for each API (e.g. one for location services, another for messaging, etc.), a developer can rely on CAPIF to provide a one-stop hub for all API interactions. For example, a developer building a fleet management application could use CAPIF to discover the operator’s “vehicle location API” and invoke it securely, without needing to know the internal details of the network’s location function – CAPIF mediates trust and access. Likewise, if the developer’s application provides its own API (say it’s an analytics service that the operator might call), the developer can publish this API via CAPIF so that it’s uniformly accessible to other authorized parties.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 4.3 Edge Application Enablement (EDGEAPP)
| This clause will provide the EDGEAPP role in application lifecycle and orchestration at the edge.Edge Application Enablement (EDGEAPP) has been specified by 3GPP to enable applications to be deployed and managed at the edge of the network (closer to end users) to achieve ultra-low latency and high bandwidth efficiency, 3GPP TS 23.558 [4]. By offloading computation and services from centralized cloud to edge nodes (e.g. servers co-located with base stations or local data centers), EDGEAPP enables use cases like real-time video analytics, AR/VR, V2X, and industrial automation that require immediate processing and minimal backhaul delay. The key goal of EDGEAPP is to make this edge deployment transparent to application developers – applications should not need major redesign to benefit from edge computing. The framework accomplishes this by providing a standardized set of functions that handle discovery of edge services, provisioning and relocation of application instances, and continuity of sessions as users move between edge sites. In essence, EDGEAPP extends the 3GPP system with an application-layer control plane for edge computing, while hiding network complexity from the application itself.
The EDGEAPP architecture introduces several new functional entities (as depicted in Figure 4.3-1), which can be grouped into client-side and network-side components:
- Application Client (AC): The end-user application component that consumes a service. In an edge computing scenario, this could be, for example, a video streaming app, a game client, or an IoT application running on a UE (User Equipment). The AC is typically developed by the Application Service Provider and contains the core application logic for the end user. Importantly, the AC itself does not directly interface with the edge network functions; instead, it interacts with the Edge Enabler Client via local APIs on the device. This design keeps the AC simple and focused on the service logic, while offloading networking tasks to the Edge Enabler Client.
- Edge Enabler Client (EEC): A client-side middleware function residing on the UE (or whatever device hosts the AC). The EEC is the bridge between the application client and the edge system. It exposes a set of APIs (referred to as EDGE-5 interfaces in 3GPP) to the AC, through which the AC can request edge services (such as registering to the edge system, discovering available edge application servers, etc.). Internally, the EEC communicates with the network’s edge enablement functions: it registers the device/application with an Edge Enabler Server, keeps track of the current “serving” edge zone, and orchestrates any changes needed when the user moves. From the developer’s perspective, the EEC is crucial – by calling the EEC’s APIs, the developer’s application can utilize edge capabilities without needing to implement complex protocols. The EEC also handles obtaining any needed network authorization (for example, via CAPIF tokens when calling edge services) on behalf of the AC.
- Edge Enabler Server (EES): A network-side function that is typically deployed at an edge data center or site serving a particular geographical zone. The EES is the core control-plane entity in the EDGEAPP framework. It manages edge application services within its zone and interfaces with EECs on UEs. Key responsibilities of the EES include registering new Edge Application Servers (EAS) when they become available in its zone, handling UE registrations (via EECs) so that the system knows which UEs are using edge services in that area and facilitating service discovery for UEs (telling an EEC which local EAS can provide the service the AC needs). The EES also monitors UE mobility (through integration with the cellular network or via the EEC’s updates) – when a UE is about to move or has moved to another zone, the EES can trigger Application Context Relocation (ACR) procedures to ensure continuity of the service session. In summary, the EES is analogous to a local edge broker/manager that coordinates between UEs and application servers at the edge.
- Edge Application Server (EAS): The actual application server instance that runs on the edge node, providing the service logic to be consumed by the AC. This could be, for example, an instance of a video analytics engine, a game server, or a data caching server, deployed in the edge cloud. The EAS is owned by the application provider (ASP) and hosts the service that the AC uses. Each EAS registers with the local EES so that the system knows the service it offers and can advertise it to interested clients. The EAS relies on the EES for certain lifecycle operations; for instance, the EES can instruct the EAS to transfer state or shut down when a user leaves the zone. The EAS can also consume network and edge services itself – for example, an EAS might call an mobile network operator provided API (like a location service via CAPIF) to augment its application or use EES-provided APIs for retrieving information about UEs or network conditions. In EDGEAPP terminology, there are reference points (like EDGE-3 and EDGE-7) for EAS to interact with the EES and potentially with operator network exposures.
- Edge Configuration Server (ECS): A centralized function that oversees the configuration and coordination of the edge system across multiple edge sites. The ECS can be thought of as the master controller in a multi-edge deployment. It maintains a global view of all edge sites (each with an EES and perhaps multiple EAS instances). The ECS provides services such as: answering queries from EECs or EESs about where certain application services are available (e.g., if a UE in zone A needs a service that’s currently only in zone B, the ECS can help route or instantiate it), bootstrapping new edge nodes (EESs) into the system, and storing subscription information or policies that apply network wide. In some scenarios, the EEC can contact the ECS at initial registration (EDGE-4 interface) to obtain information like the address of its serving EES if the UE is not preconfigured. The EESs also typically interface with the ECS (EDGE-6) to report new EAS deployments or to get updates on global configurations. The ECS, being a central point, can use CAPIF/NEF to interface with core network functions – for example, to fetch network resource exposure (like cell congestion status) or to publish its own APIs for other systems. The Edge Computing Service Provider (ECSP), for example the mobile network operator, is responsible for running the ECS, EES, and providing the infrastructure on which EAS instances run.
Figure 4.3-1: EDGEAPP Architecture, as specified in 3GPP TS 23.558 [4]
The typical sequence of interactions in EDGEAPP to deliver an edge-augmented service is outlined below (note that some steps can vary depending on deployment options, but this reflects a common scenario in a single operator’s network):
1. Edge Infrastructure Registration: Before any end-user device participates, the edge nodes must be set up. Each Edge Enabler Server (EES) that comes online (for a new edge site) registers with the Edge Configuration Server (ECS). The ECS thus maintains a registry of all EESs and their capabilities/zones. This registration can involve mutual authentication and authorization – often incorporating CAPIF if the ECS’s APIs are published via CAPIF. In our context, the operator ensures all EES instances are known to the ECS (either through provisioning or dynamic discovery in larger deployments). Similarly, when an application provider wants to deploy an Edge Application Server (EAS) in a zone, they might coordinate with the operator such that the EAS gets registered with the local EES. The EES will record what service the EAS offers (e.g. “VideoAnalyticsService v1”) and possibly pass that information up to the ECS for global awareness. At this stage, CAPIF can be used: for example, the ECS and EES can onboard to CAPIF as API providers and invokers so that their APIs (like “register EAS” or “query edge info”) are accessible securely. By the end of this step, the edge control-plane is prepared: EES know about local EAS services, and the ECS knows about all EESs (and possibly their EAS listings).
2. UE Discovery of Edge Service (Registration): When a user’s device (UE) powers on or an application starts, the Edge Enabler Client on the UE needs to discover which edge it should connect to. There are multiple ways this can happen. The UE could have a pre-provisioned address for an EES (perhaps provided by the operator’s subscription or via a device management system); or the UE could perform a DNS query or receive an indication from the network (e.g., during attach, the network might provide an “edge pointer”). Another method is the bootstrap via ECS: the EEC contacts the central ECS to ask, “where is my serving EES?” and the ECS responds with the address of the optimal EES for that UE (based on the UE’s location or subscription). Once the EEC knows which Edge Enabler Server to use, it proceeds to register with that EES. EEC-EES registration involves the EEC introducing the AC (application client) and itself to the EES: essentially saying “this UE/application wants to use edge services in your zone.” The EES authenticates the EEC (possibly via network credentials or certificates; security can rely on 3GPP credentials or CAPIF tokens if the EEC is acting as an invoker) and then creates a context for that AC on the edge. After a successful registration, the EES knows this UE (often by a unique Edge UE ID) and can start providing it with services like discovery notifications. The EEC will typically get a confirmation that it is registered. From the AC developer’s viewpoint, this whole discovery and registration process is triggered by a simple API call like Eeec_ACRegistration() from the AC to the EEC – the EEC and the network handle the rest (including contacting ECS or using CAPIF as needed).
3. Service Discovery and Consumption: After registration, the AC can request an actual application service at the edge. Suppose the AC needs a “Video Analytics” service. The AC (through an API call to EEC, e.g. Eeec_EASDiscovery(serviceType)) asks the EEC to find an appropriate Edge Application Server (EAS) that provides that service. The EES receives this request via the EEC and checks whether an EAS in its zone offers the requested service. If yes, it selects the optimal EAS (there can be multiple instances or versions) and returns the details (e.g. the EAS’s IP address or domain and any required info to connect) to the EEC, which then passes it to the AC. If no local EAS can serve it, the EES might query the ECS to see if the service is available in another zone or if a new instance should be instantiated. Assuming an EAS is found in the local zone (Edge Zone 1 for example), the AC can then start communicating with that EAS to consume the service. Typically, the AC’s requests will still go through the EEC as a proxy (the exact data plane path can vary it could be AC → EEC (on device) → direct IP to EAS, or AC → EEC → EES → EAS, depending on whether the EES needs to anchor the traffic). In any case, the AC’s traffic to the EAS is application-layer communication (e.g. HTTP requests, video stream) and the EES/EEC ensure it is routed to the edge rather than a distant server.
4. It’s worth noting the security aspect here: if the EAS’s API is protected (which would be the usual scenario expected), the AC/EEC can need to obtain an authorization token to invoke it. This is where CAPIF integration comes in – the EAS can expose its service API via CAPIF (with the EAS acting as an API provider and the EEC or AC as the invoker). In practice, the EEC might use CAPIF to get a token for the EAS’s API and include it in AC’s requests. However, these steps are typically hidden from the developer; they happen under the hood. The developer just sees that after discovery; the AC can call the EAS (likely the EEC provides a local API call that internally forwards to the EAS). In summary, the AC starts consuming the edge service, enjoying much lower latency because the EAS is nearby and potentially tailored to local conditions.
5. Mobility and Service Continuity: A key feature of EDGEAPP is handling what happens when a user moves out of the coverage of one edge site to another (e.g., driving from one city to the next). Without EDGEAPP, the session to the first edge server would break or see a drastic performance drop. EDGEAPP’s design allows for Application Context Relocation (ACR) to preserve service continuity. In our example, as the UE (with AC and EEC) moves from Edge Zone 1 to Edge Zone 2, the system must transfer the ongoing session from the current EAS (in Zone 1) to a new EAS in Zone 2 (that provides the same service). The EES in Zone 1, detecting that the UE is leaving (possibly via network triggers or the UE’s EEC notifying loss of connection), coordinates with the EES in Zone 2 and the central ECS to set up a target EAS. If a suitable EAS is already running in Zone 2, it can prepare to take over the session; if not, the operator might instantiate one on the fly (depending on how dynamic the system is – this is more advanced). The state of the application (the “application context”) can be transferred from EAS1 to EAS2 – this could involve state sync or handing off relevant data (the exact method can depend on application design; EDGEAPP can signal the EAS to push state). Once Zone 2’s EAS is ready, the EES2 (Edge Enabler Server in Zone 2) will finalize the relocation: the EEC on the UE is informed of the new EAS endpoint (via a notification or updated discovery result). The AC then seamlessly continues communication with EAS2. From the AC’s viewpoint, it might just receive an event or callback that a new server endpoint is now in use – the content of the service continues with minimal disruption. The AC does not need to re-register or rediscover manually; the EEC and EES handle that transition. EDGEAPP thus ensures that mobility across edges is managed gracefully, which is critical for use cases like vehicular connectivity or users walking across a city with an AR application. This continuity is achieved while still enforcing security (if a new token is needed for the new EAS, the EEC would obtain it via CAPIF as well, transparently to the AC).
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 4.4 Service Enabler Architecture Layer (SEAL)
| This clause will provide the SEAL role in the provision of reusable service enablers for vertical applications.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 4.4 Inter-framework Relationships Overview
| This clause will describe the role of each framework can provide in an overall framework.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5 Use Cases
| Each use case is expected to include end-to-end service flow and infrastructure details (e.g., number and placement of edge nodes, optional use of SEAL services for a single PLMN domain)
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1 Crowd Counting Video Analytics
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.1 Introduction
| This section describes a Crowd Counting Video Analytics use case. The use case has been selected to illustrate how application developers can leverage the EDGEAPP framework to discover and utilize Edge infrastructure that supports low-latency video analytics. Specifically, it demonstrates the benefits of deploying computation close to the user equipment (UE) when processing video streams in real time.
For EDGEAPP infrastructure discovery, the CAPIF framework is leveraged to demonstrate how CAPIF exposes standardized API information that enables developers to optimize their applications for efficient utilization of edge services. Through CAPIF, an API Catalogue is made available across all Edge Zones, allowing applications to discover available zones and obtain the corresponding API endpoints required to access and consume the Video Analytics services.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.2 Use case Description
| “Acme” company is developing a crowd counting video analytics application that leverages edge computing to process video in real time. The application consists of an Application Client (AC) running on a User Equipment (UE), which captures live video and streams it for analytics, and a video analytics application running on an Edge Application Server (EAS), which performs the crowd counting function.
The performance of the video analytics function depends on latency and network efficiency. Deploying the analytics server closer to the UE can significantly reduce latency and minimize the impact of transmitting large video streams across the network.
Developers can choose between two deployment models:
- Centralized Deployment: The video analytics server is deployed in a central data center, requiring all UEs to stream video to the central location.
- Edge Deployment: The video analytics server is deployed within Edge Zones, allowing video streams to be processed locally, thereby reducing backhaul traffic and latency.
The UE also hosts an Edge Enabler Client (EEC). The AC communicates with the EEC via the EDGE-5 reference point. The EEC hides all network complexity and interacts with the Edge Enabler Server (EES), the Edge Configuration Server (ECS), and the CAPIF Core Function (CCF) to enable the AC to consume the video analytics service.
As depicted in Figure 5.1.1-1, the topology considered for this use case includes:
• one CCF,
• one ECS,
• two EES (each serving one edge zone),
• two EAS (one per edge zone),
• one UE with EEC and AC.
Figure 5.1.1-1: Crowd Counting Video Analytics use case topology
The UE starts attached in Edge Zone 1, where the AC streams video to EAS 1. When the UE moves into Edge Zone 2, the system triggers an Application Context Relocation (ACR) to transfer the session to EAS 2, preserving service continuity with minimal disruption. The AC itself is only aware that the EEC provides it with an updated service endpoint; all control-plane interactions are performed by the EEC.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.3 Use case Realisation over Application Enablement Frameworks
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.3.1 General
| From the developer’s point of view, it is essential to understand which entity handles which tasks in the EDGEAPP system. The AC is deliberately kept simple: it talks only to the EEC, and all network complexity is abstracted away. When the AC is designed, only the calls to the EEC’s APIs need to be implemented to leverage the EDGEAPP capabilities. Everything else — serving EES discovery, ECS interaction, and service API resolution via CAPIF — is handled transparently by the edge system. Section 5.1.3.2, though, explain the end-to-end flows for developers to understand the full system.
For this use case, we are considering centralized CAPIF core function deployment option as described in Annex A.5.3 of 3GPP TS 23.558 [4].
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.3.2 AC Discovering the Serving EES
| The EEC running in the UE, needs to discover its EES. The EEC can learn which EES to register with through multiple mechanisms:
• Pre-provisioned in the UE/application profile.
• DNS-based discovery, using operator domain naming conventions.
• Network-provisioned, delivered at onboarding or during mobile attachment.
• Bootstrap via ECS, where the EEC queries ECS to obtain the correct serving EES.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.3.3 CAPIF roles of EDGEAPP entities
| While AC does not interact directly with CCF, it is important to understand the roles that each EDGEAPP entity plays in relation to CAPIF to consume APIs. In this use case, the EEC behaves as a CAPIF API Invoker. The EEC needs to discover EAS APIs and obtain OAuth tokens to consume them. In particular, the EEC queries the CCF to discover the Video Analytics service API exposed by the EAS.
The EEC then exposes the resolved API base URI and parameters to the AC via EDGE-5 (Eeec_EASDiscovery). The AC uses this information to send its video stream (i.e., application data traffic) directly to the EAS and expects to receive analytics results based on that. EES acts as an API Invoker consuming APIs from ECS and is an API provider as it exposes EES APIs to ECS. EAS acts as an API Invoker consuming APIs from EES and is an API provider as it exposes EAS APIs plus Application specific APIs. ECS acts as API Provider as it exposes APIs to EES.
With these considerations, the next section provides an end-to-end view with step-by-step flows describing all EDGEAPP and CAPIF entities and how they interact based in the Developers´ use of EDGE-5 APIs between AC and EEC.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.4 Use case Flows
| Editor’s note: Appropriate “Focus for Application developer” highlighting, if any, in the figures in this clause is FFS.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.4.1 General
| From a developer’s perspective, the use case flows describe how an Application Client (AC) interacts with its local Edge Enabler Client (EEC) to request services, discover the right Edge Application Server (EAS), and sustain service continuity when the UE moves between edge zones. The AC is abstracted from all network-level complexity; it only consumes the EDGE-5 APIs provided by the EEC. Behind the scenes, the EEC engages with the EES, ECS, and CAPIF to resolve service endpoints, discover APIs, and coordinate relocation. Each step below outlines the function, rationale, and developer implications.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.4.2 Step 1: AC Registration & Provisioning
| The first step is for the AC to register with the EEC so that it can start consuming services. The developer must ensure the AC calls the Eeec_ACRegistration API. If the EEC already aware of its serving EES (through provisioning, DNS discovery, or cached state), it registers directly as depicted in Figure 5.1.4.2-1. Otherwise, the EEC bootstraps via the ECS to discover the serving EES as depicted in Figure 5.1.4.2-2. This step establishes the control context needed for subsequent service requests.
Figure 5.1.4.2-1: AC registration in EEC (option 1)
Alternatively, EEC can discover a suitable EES from the ECS.
Figure 5.1.4.2-2: AC registration in EEC (option 2)
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.4.3 Step 2: EAS Discovery
| Once registered, the AC needs to know which EAS can provide the video analytics service. The developer calls Eeec_EASDiscovery, and the EEC queries the EES to find suitable EAS instances in the serving zone. The response includes candidate EAS endpoints, which the EEC returns to the AC via callback. The flow is shown in Figure 5.1.4.3-1.
At this stage, the AC learns where to send its data, but not yet how to use the service API.
Figure 5.1.4.3-1: EAS Discovery
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.4.4 Step 3: CAPIF API Discovery
| The AC now requires the actual API contract to interact with the selected EAS. The developer does not handle CAPIF directly; instead, the EEC calls CAPIF_Discover_Service_API towards the CCF. CAPIF responds with the API base URI, supported operations, and authorization details. The EEC then informs the AC via a response callback. The flow is shown in Figure 5.1.4.4-1.
The developer can now use this endpoint for direct service invocation.
Figure 5.1.4.4-1: CAPIF API Discovery
EEC notifies the API endpoint information obtained from CAPIF.
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.4.5 Step 4: Service Invocation
| With the endpoint and API details, the AC begins sending its video stream directly to the EAS. From the developer’s perspective, this involves implementing the client logic that captures frames and invokes the Video Analytics service API as specified by CAPIF. The EAS processes the video in real time and returns crowd counting results, which the AC can render or act upon. The flow is shown in Figure 5.1.4.5-1.
Figure 5.1.4.5-1: Video Analytics API Consumption
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.4.6 Step 5: Mobility with Application Context Relocation
| The EEC does not detect mobility itself. Mobility/zone-change is determined in the network and conveyed to the EES (e.g., via operator control-plane and exposure functions). The EES then informs the EEC over EDGE-1 using the service continuity/mobility procedures. The EEC translates that into the local EDGE-5 notification the AC can consume. From the developer’s perspective, they only need to:
- ensure the AC has subscribed (e.g., Eeec_Services_Subscribe) to mobility/ACR notifications, and
- handle updateNotificationCallback(mobilityEvent: zoneChange → Zone2) to gracefully pause/buffer and wait for the new endpoint before resuming the stream.
Once the EEC has notified the AC of a mobility event (zone change), the next stage is to relocate the application context. The EES is the anchor for this process. When it detects that the UE should be served by another edge zone, it coordinates with the ECS to identify the target EES/EAS. The EEC can either trigger the ACR procedure explicitly (via Eeec_ACRTrigger) or let the EES manage it automatically.
NOTE: Each edge zone corresponds to an Edge Data Network (EDN) as defined in 3GPP TS 23.558 [4]. An EDN represents the localized network domain that hosts the edge components (EES, EAS, and supporting UPF) providing low-latency application services near the UE. From an application-enablement perspective, the edge zone is the logical area in which an Application Client (AC) is served by a specific EES and its associated EAS instances. When the UE moves to another edge zone, this corresponds to a change of serving EDN at the network level. The EES anchors the control context of each EDN and coordinates the Application Context Relocation (ACR) process to maintain service continuity across edge zones.
From the developer’s perspective, the AC does not implement relocation signalling. It only needs to:
- handle the notification callback (from Step 4),
- optionally request relocation via Eeec_ACRTrigger, and
- be ready to consume the new endpoint information once relocation is complete.
The state transfer between EAS 1 and EAS 2, as well as the context push between EESs, is handled by the edge system.
Figure 5.1.4.6-1: Mobility and Application Context Relocation
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.4.7 Step 6: API Update & Resume Streaming
| After relocation, the EEC refreshes API discovery with CAPIF to retrieve the new endpoint for EAS 2. The AC receives this updated endpoint via notification callback. The developer must handle this event by re-establishing the video stream to EAS 2 using the new service API. From the AC’s perspective, this looks like a service update rather than a failure, maintaining continuity of the analytics.
Figure 5.1.4.7-1: API Update & Resume Streaming
At the end of the procedure, the Application Client (AC) has successfully transitioned its session from EAS 1 in Zone 1 to EAS 2 in Zone 2. The Application Context Relocation ensured that service state was preserved across edge zones, while the updated API discovery via CAPIF allowed the AC to obtain the new endpoint seamlessly. From the developer’s perspective, the AC continued to stream video to the analytics service with minimal disruption — first to Zone 1’s EAS and, after mobility and relocation, directly to Zone 2’s EAS. This demonstrates how the EDGEAPP framework hides the complexity of mobility and service continuity, enabling the developer to focus on application logic rather than network details.
5.2 {Use case title}
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.2.1 Introduction
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.2.2 Use case Description
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.2.3 Use case Realisation over Application Enablement Frameworks
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.2.4 Use case Flows
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 6 Developer Guidelines
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 6.1 Introduction
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 6.2 Cross-Framework Integration
| CAPIF roles definition for EDGEAPP and SEAL entities
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 6.3 Example Application Flows
| The following flows will be considered “CAPIF + EDGEAPP”, “CAPIF + SEAL” and “CAPIF + EDGEAPP + SEAL”
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 6.4 Multi-CAPIF Considerations
| Relevant information to consider when several CAPIF are deployed
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 7 Security Considerations
| Aspects such as identity management across frameworks, secure onboarding and trust models, framework-specific and integrated authorization will be considered
Annex A:
Infrastructure Topology Diagrams Examples
Will show CAPIF+ EDGEAPP, CAPIF+SEAL and CAPIF+EDGEAPP+SEAL
A.1 CAPIF plus +EDGEAPP Topology
Editor’s Note: Further alignment is required between this clause and Annex A.5 of 3GPP TS 23.558 [4].
A.1.1 General
This annex describes a deployment in a single PLMN where the Common API Framework (CAPIF) integrates with the Edge Application Enablement (EDGEAPP) architecture. The scenario illustrates how onboarding, registration, API publication, discovery, authorization, and invocation are carried out with CAPIF security in place.
This sample deployment includes the following entities:
• CAPIF Core Function (CCF): Provides onboarding, registration, API catalogue, authorization, and token issuance.
• Edge Configuration Server (ECS): Provides supporting functions needed for the EEC to connect with an EES.
• Two Edge Enablement Servers (EES): One per Edge location.
• Two Edge Application Servers (EAS): One per Edge location, co-located with each EES.
• Two User Equipment (UEs): Each has an Edge Enabler Client (EEC) and an Application Client (AC) connected to its nearest Edge location.
The Logical Topology is shown in Figure A.1.1-1, where the letters and numbers are independent, for instance AC-A or AC-B could connected to either EAS.
Figure A.1.1-1: CAPIF plus EDGEAPP sample topology
A.1.2 Step 1: ECS Registration into CAPIF
The ECS needs first to be pre-provisioned with the CAPIF Root CA, the CAPIF base URL, and a bootstrap JWT/credentials, see clause 6.1 of 3GPP TS 33.122 [7]. It can then register with the CCF as an API Provider (clause 10.12.2 of 3GPP TS 23.222 [2]), establishing its trusted identity. The flow is depicted in Figure A.1.2-1.
Figure A.1.2-1: ECS Registration flow
A.1.3 Step 2: ECS Publishes APIs
Having obtained a valid certificate, the ECS publishes its service APIs (e.g., EESRegistration, configuration APIs) into CAPIF. The flow is depicted in Figure A.1.3-1.
Figure A.1.3-1: ECS Publish API flow
A.1.4 Step 3: EES Onboarding and Registration into CAPIF
Before onboarding, each EES is provisioned with:
• CAPIF Root CA certificate(s), to validate TLS when connecting to the CCF.
• CAPIF Core Function base URL, the discovery root for onboarding, registration, discovery, and token endpoints.
• Bootstrap JWT and/or credential material, initial credentials used to authenticate to CCF for onboarding (per operator policy).
The EES establishes a secure TLS session to the CCF using the CA root, authenticates with the bootstrap token/credentials, and performs:
• API Invoker onboarding (so it can later discover/consume ECS APIs), and
• API Provider registration (so it can later publish its own EES-facing APIs, e.g., EASRegistration/Discovery).
The EES onboarding as an API Invoker and then registering as an API Provider flows are depicted in Figure A.1.4-1.
Figure A.1.4-1: EES onboarding and registration flow
A.1.5 Step 4: EES Publishes Its APIs
The EES publishes APIs for EASRegistration, EASDiscovery, and UE-related assistance (EEC), as depicted in Figure A.1.5-1.
Figure A.1.5-1: EES publishing flow
A.1.6 Step 5: EES Discovers ECS APIs
Before interacting with ECS, the EES discovers ECS’s published APIs through CAPIF, as depicted in Figure A.1.6-1.
Figure A.1.6-1: EES discovery flow
A.1.7 Step 6: EES Registers with ECS
In order to register in ECS, EES needs to consume the discovered EESRegistration API. For that, the EES establishes a Security Context with the CCF using the client certificate issued/provisioned during API Invoker onboarding (Step 3) selecting the SecurityMethod, in this case, will be OAuth. Then, the EES requests an OAuth2 access token (Client Credentials grant) from the CCF, bound to the established Security Context, with scope for ECS APIs (EESRegistration).
The EES invokes EESRegistration on the ECS (EDGE-6) with the OAuth token in the bearer header. The ECS validates the token and completes EES registration into ECS.
These steps are depicted in Figure A.1.7-1.
Figure A.1.7-1: EES registration flow
A.1.8 Step 7: EAS Onboarding and Registration into CAPIF
Before onboarding, each EAS is provisioned with:
• CAPIF Root CA certificate(s): to validate the CCF’s TLS server certificate.
• CAPIF Core Function base URL(s): the root(s) for CAPIF onboarding, discovery/catalogue, and token endpoints.
• Bootstrap JWT and/or credential material: initial credentials issued by the operator/CCF that authorize the EAS to onboard; may encode roles for API Invoker and API Provider. JWT is be different for API Invoker and API Provider roles.
The EAS establishes a TLS session to the CCF (verifying with the CAPIF Root CA). It authenticates using the bootstrap token/credentials and performs:
• API Invoker onboarding, so it can later discover and consume ECS and EES APIs
• API Provider registration, so it can later publish its own application APIs to CAPIF
The EAS onboarding as an API Invoker and then registering as an API Provider flows are depicted in Figure A.1.8-1.
Figure A.1.8-1: EAS Onboarding and Registration flows
A.1.9 Step 8: EAS Discovers ECS/EES APIs
EAS queries CAPIF to locate both ECS and its serving EES APIs, as depicted in Figure A.1.9-1.
Figure A.1.9-1: EAS discovery flows
A.1.10 Step 9: EAS Registers with EES
The EAS requests a CAPIF-issued token scoped to EASRegistration and registers into its local EES, as depicted in Figure A.1.10-1.
Figure A.1.10-1: EAS registration flow
A.1.11 Step 10: EAS Publishes its Application APIs
The EAS publishes its application APIs (telemetry, AR, gaming, etc.) into CAPIF, as depicted in Figure A.1.11-1.
Figure A.1.11-1: EAS Publishing flow
At this point, EDGEAPP infrastructure is setup and ready. All EDGEAPP entitles are registered in CCF and have published their API endpoints. EES and EAS have also registered in ECS for UEs to discover them using EDEAPP APIs.
A.1.12 Step 11: AC/EEC Access EAS Services
ACs on UEs reach EAS services via EEC and EES. The EEC may leverage CAPIF-discovered info or operator-controlled EES discovery.
The EEC discovers its serving EES either through operator bootstrap configuration (pre-provisioned URL/endpoint), dynamic discovery via DNS or network signalling, or network-assisted redirection at session setup. CAPIF is not usually queried directly by the EEC for EES.
EEC sends an API Discovery request to the CCF to learn what APIs EAS has published (this aligns with Step10 where the EAS published APIs into CAPIF).
The EEC then passes EAS API information to AC. AC invokes the desired EAS API. The EAS processes the request, and responds to the AC.
These steps are depicted in Figure A.1.12-1.
Figure A.1.12-1: AC/EEC API Access flow
A.2 CAPIF+SEAL Topology
A.3 CAPIF+EDGEAPP+SEAL Topology
Annex B:
Change history
Change history
Date
Meeting
TDoc
CR
Rev
Cat
Subject/Comment
New version
2025-08
SA6#68
S6-253778
TR Initial Version
0.0.0
2025-08
SA6#68
S6-253670
S6-253778
S6-253727
References
Scope
Introduction
0.1.0
2025-10
SA6#69
S6-254653
S6-254655
S6-254733
S6-254656
S6-254740
S6-254658
Frameworks intro
Frameworks EDGEAPP
Frameworks CAPIF
Use case: Crowd Counting
Use case: Crowd Counting realisation
Annex CAPIF plus EDGEAPP
0.2.0
|
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1 Use case XCrowd Counting Video Analytics
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.32 Use case Realisation over Application EnablementSA6 Frameworks
| |
2b5c82519cec48b309e29881d9c51555 | 23.947 | 5.1.43 Use case Flows
| |
109aef2cbd7243013266d216a69f4ffd | 28.888 | 1 Scope
| The present document …
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 2 References
| The following documents contain provisions which, through reference in this text, constitute provisions of the present document.
- References are either specific (identified by date of publication, edition number, version number, etc.) or non‑specific.
- For a specific reference, subsequent revisions do not apply.
- For a non-specific reference, the latest version applies. In the case of a reference to a 3GPP document (including a GSM document), a non-specific reference implicitly refers to the latest version of that document in the same Release as the present document.
[1] 3GPP TR 21.905: "Vocabulary for 3GPP Specifications".
[2] 3GPP TS 28.533: "Management and orchestration; Architecture framework".
[3] 3GPP TS 28.579: "Management services exposure to external consumers through CAPIF".
[4] 3GPP TS 28.319: "Access control for management services".
[5] 3GPP TS 28.537: "Management and Orchestration; Management capabilities".
[6] 3GPP TS 28.622: "Telecommunication management; Generic Network Resource Model (NRM) Integration Reference point (IRP); Information Service (IS)"
[7] 3GPP TS 33.122: "Security aspects of Common API Framework for 3GPP Northbound APIs "
[8] 3GPP TS 29.222: " Common API Framework for 3GPP Northbound APIs".
[9] 3GPP TS 23.501: "System architecture for the 5G System (5GS)".
[10] 3GPP TS 23.502: "Procedures for the 5G System (5GS)".
[11] 3GPP TS 28.541: "Management and orchestration; 5G Network Resource Model (NRM); Stage 2 and stage 3".
[12] 3GPP TS 28.552: "Management and orchestration; 5G performance measurements".
[13] 3GPP TS 28.530: "Management and orchestration; Concepts, use cases and requirements".
…
[x] <doctype> <#>[ ([up to and including]{yyyy[-mm]|V<a[.b[.c]]>}[onwards])]: "<Title>".
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 3 Definitions of terms, symbols and abbreviations
| |
109aef2cbd7243013266d216a69f4ffd | 28.888 | 3.1 Terms
| For the purposes of the present document, the terms given in TR 21.905 [1] and the following apply. A term defined in the present document takes precedence over the definition of the same term, if any, in TR 21.905 [1].
Management Service (MnS): defined in TS 28.533 [2].
External MnS consumer: defined in TS 28.533 [2].
Internal MnS consumer: defined in TS 28.533 [2].
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 3.2 Symbols
| For the purposes of the present document, the following symbols apply:
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 3.3 Abbreviations
| For the purposes of the present document, the abbreviations given in TR 21.905 [1] and the following apply. An abbreviation defined in the present document takes precedence over the definition of the same abbreviation, if any, in TR 21.905 [1].
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 4 Concepts and background
| Editor’s note: This clause provides a description of concepts and background.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 4.1 Overview
| The study builds upon the management services exposure scenarios defined in clause 5.6 of TS 28.533 [2], which serves as the primary reference for exposing management services to external consumers. In addition, the Management Exposure framework described in TS 28.579 [3] introduces an optional approach based on CAPIF.
The enhanced exposure concept includes the ability to abstract sensitive internal identifiers, enforce data sharing permissions, and align with industry-standard exposure frameworks.
Key motivations and considerations include:
• Cross-domain integration: As operators increasingly collaborate with external entities, there is a need to expose selected management services in a controlled and standardized manner.
• Security and privacy: Exposure of collected data must comply with security requirements, for the case where these data conveys sensitive data that the operator does not want to expose as-is outside their admin domain.
• Access control enhancement: Improve mechanisms of existing specifications (e.g., TS 28.319 [4]) to provide notification-level access control, which is essential for dynamic service interactions.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 4.2 Authorization of external MnS consumers using CAPIF
| |
109aef2cbd7243013266d216a69f4ffd | 28.888 | 4.2.1 Introduction
| As noted in clause 5.6 of TS 28.533 [2], an operator can decide to expose 3GPP management system capabilities to external MnS consumers using existing MnS interfaces (e.g. external MnS consumer Y1), or using CAPIF (e.g. external MnS consumer Y2).
When CAPIF is not used, an external MnS consumer gets access to MnS APIs using 3GPP management system mechanisms defined for discovery (see TS 28.537 [5] and TS 28.622 [6]) and access control (see clause 4.9 of TS 28.533 [2]), in the same way as an internal MnS consumer. The access control capability is provided by authentication and authorization service producers, which are responsible for authenticating and authorizing MnS consumers (see Annex D of TS 28.533 [2]), based on operator-configured information. The operator can configure this information using the MSAC framework defined in TS 28.319 [4].
To expose service APIs using CAPIF, the 3GPP management system needs to be registered as an CAPIF API provider domain. To that end, the 3GPP management system provides required API provider domain functionalities (AMF, APF, AEF) in a framework called Management Service Exposure Domain (MSED), see TS 28.579 [3].
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 4.2.2 Authorization in CAPIF Framework
| 3GPP TS 33.122 [7] specifies security aspects of the CAPIF Framework.
CAPIF has defined three possible formats for access token’s scope. These formats are specified in the “scope” attribute in AccessTokenReq (see clause 8.5.4.2.6 of TS 29.222 [8]) and AccessTokenRsp (see clause 8.5.4.2.7 of TS 29.222 [8]).
4.3 Access control on notifications
Currently, the 3GPP management system supports notification subscription via the NtfSubscriptionControl IOC (see clause 4.3.22 of TS 28.622[6]), enabling MnS consumers to subscribe to receive notifications from MnS producers.
The NtfSubscriptionControl IOC (as defined in clause 4.3.22 of TS 28.622[6]) includes the following attributes:
Table 4.3-1: NtfSubscriptionControl properties
Attribute Name
S
isReadable
isWritable
isInvariant
isNotifyable
notificationRecipientAddress
M
T
T
F
T
notificationTypes
O
T
T
F
T
scope
O
T
T
F
T
notificationFilter
O
T
T
F
T
lastSequenceNo
O
T
F
F
F
operationalState
O
T
F
F
T
availabilityStatus
O
T
F
F
T
Further, clause 7.3 of TS 28.319[4] defines the AccessRule class associated to a given MnS consumer identified by their Identity and Role classes. The AccessRule class includes the following attributes (shown in Table 4.3-2) as defined in clause 7.3.3 of TS 28.319[4]):
Table 4.3-2: AccessRule properties
Attribute Name
S
ruleName
M
dataNodeSelector
M
operations
M
actions
O
componentCData
O
In clause 7.3.3 of TS 28.319[4], componentCData is defined as an optional attribute which specifies notification types and performance metric names.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5 Use cases and potential solutions
| |
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.1 Use case #1: Authorization of the service API invocation request from the external MnS consumer using CAPIF
| |
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.1.1 Description
| Editor's note: This clause provides a description of use case.
For an external MnS consumer to be able to invoke service APIs at the MSED AEF, first they send the service API authorization request (over the CAPIF-1e interfaced) to the CCF to request for the authorization to access one or more service APIs. If the service API authorization request is successful, the CCF issues this authorization to the API invoker in the form of an access token. This token contains the permissions granted to the API invoker for requested service APIs. These permissions are carried as part of the token’s scope, whose format is one of the three formats specified in the scope attribute of the AccessTokenReq (see clause 8.5.4.2.6 of TS 29.222[8]) and AccessTokenRsp (see clause 8.5.4.2.7 of TS 29.222[8]). For further details on the service API authorization procedure, see clause 6.5.2.3 of TS 33.122[7].
Accordingly, once an external MnS consumer has a valid access token from the CCF, they proceed to perform the service API invocation request to the AEF over the CAPIF-2e interface (see clause 6.5.2.3 of TS 33.122[7] for more details). As a pre-condition for the service API invocation request to be successful, the AEF needs to be able to understand the access token format issued by the CCF to enable the access token validation.
This use case describes how the service API invocation request from the external MnS consumer can be authorized at the MSED AEF.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.1.2 Potential requirements
| Editor's note: This clause provides potential requirements for the corresponding use case.
PREQ-FS_EnExpo-AuthCCF-01: The exposure of management services using CAPIF shall provide the capability enabling the authorization of the service API invocation request(s) at the MSED AEF.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.1.3 Potential solutions
| Editor's note: This clause provides one or more solutions. Further (sub-)clause(s) may be added to capture details.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.1.4 Evaluation of potential solutions
| Editor's note: This clause provides evaluation of potential solutions.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.2 Use case #2: Access control on notifications
| |
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.2.1 Description
| Editor's note: This clause provides a description of use case.
When an MnS consumer subscribes to receive notifications using the NtfSubscriptionControl IOC (see clause 4.3), the 3GPP management system needs to be able to determine whether a given MnS consumer is authorized to receive notifications on a set of managed object(s). Additionally, an MnS consumer could subscribe to receive notifications by specifying a notification scope that exceeds its authorized notification scope, the 3GPP management system needs to be able to handle such requests.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.2.2 Potential requirements
| Editor's note: This clause provides potential requirements for the corresponding use case.
PREQ-FS_EnExpo-Ntf-01: The 3GPP Management System should provide the capability to configure, per role (as defined in clause 7.3.2 of TS 28.319[4]), the set of notification types that the MnS consumer is authorized to receive.
PREQ-FS_EnExpo-Ntf-02: The 3GPP Management System should provide the capability to enforce the restrictions configured in requirement PREQ-FS_EnExpo-Ntf-01.
PREQ-FS_EnExpo-Ntf-03: The 3GPP Management System should provide the capability to configure, per role, the information content that the MnS consumer is authorized to receive in a notification.
Editor’s note: If the proposed solution is deemed too complicated, then this requirement could be removed.
Editor’s note: The access control rules for reading data via CRUD and access control rules for receiving data via notifications should be common.
Editor’s note: The relationship between the entity that subscribes to receive notifications and the entity that receives the notifications needs to be clarified.
PREQ-FS_EnExpo-Ntf-04: The 3GPP Management System should provide the capability to enforce the restrictions configured in requirement PREQ-FS_EnExpo-Ntf-03.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.2.3 Potential solutions
| Editor's note: This clause provides one or more solutions. Further (sub-)clause(s) may be added to capture details.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.2.4 Evaluation of potential solutions
| Editor's note: This clause provides evaluation of potential solutions.
5.X Use case #3: Transformation of MnS information for external MnS consumers
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.3.1 Description
| Editor's note: This clause provides a description of use case.
When an external MnS consumer which is located outside the PLMN trust domain requests access to network information, 3GPP management system needs to ensure that internal 5G information is not revealed. For instance, the relevant "S-NSSAI" need to be transformed/mapped to an AF-Service-Identifier before exposure, rather than being exposed to an untrusted AF directly. 3GPP 5GC control plane uses the same transformation/mapping approach for internal 5GC information. For example, to report the number of UEs and PDU Sessions per network slice to AF, the S-NSSAI is used in case of a trusted AF and AF-Service-Identifier is used for an untrusted AF, see " Translation of internal-external information" in clause 6.2.5.0 of TS 23.501 [9] and "Map the AF-Service-Identifier into DNN and S-NSSAI combination, determined by local configuration" in clause 4.3.6.1 of TS 23.502 [10] for further detail.
To manage the untrusted AFs, the related NRM information has been specified in TS 28.541 [11], which includes the NRM supporting for AF-Service-Identifier for an untrusted AF, see the attribute unTrustAfInfoList of NefInfo in clause 5.3.164 of TS 28.541 [11] for further detail.
The MnS consumer can get the performance measurements of a network slice. Performance measurements specified in TS 28.552 [12] can be split into sub-counters per S-NSSAI. 3GPP management system can use these sub-counters to distinguish performance measurements for different consumers/trusted AFs, which might be required when performance measurements are exposed as part of Network Slice as a Service (NSaaS) specified in TS 28.530 [13]. So far, no transformation/mapping approach of an S-NSSAI to an AF-Service-Identifier is specified for the case of an external MnS consumer/untrusted AF in performance management specifications. This use case is to study potential solutions to support transformation/mapping of an S-NSSAI to an AF-Service-Identifier for network slicing performance managements.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.3.2 Potential requirements
| Editor's note: This clause provides potential requirements for the corresponding use case.
REQ-EnExpo-Trans-01: The 3GPP management system should support a transformation to replace S‑NSSAI with AF‑Service‑Identifier before exposure to external MnS consumers.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.3.3 Potential solutions
| Editor's note: This clause provides one or more solutions. Further (sub-)clause(s) may be added to capture details.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 5.3.4 Evaluation of potential solutions
| Editor's note: This clause provides evaluation of potential solutions.
|
109aef2cbd7243013266d216a69f4ffd | 28.888 | 6 Conclusions and recommendations
| 6.X Use case #<X>: <use case title>
Editor's note: This clause provides conclusions and recommendations for the corresponding use case.
Annex A (informative):
Change history
Change history
Date
Meeting
TDoc
CR
Rev
Cat
Subject/Comment
New version
2025-10
SA5 #163
S5-254449
S5-254694
Added the TR structure for enhanced exposure of management services.
Added concepts and background.
0.1.0
2025-11
SA5#164
S5-255566
S5-255567
S5-255684
S5-255703
Add use case on transformation of MnS information for external MnS consumers
Add concepts, use case and requirements on access control on notifications
Add concepts for authorization of external MnS consumers using CAPIF
Add use case and requirements for authorization of the external MnS consumers at the CCF
0.2.0
|
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 1 Scope
| The present document studies the charging aspects of 6G system. This includes new charging business models and potential charging metrics, 6G charging architecture and charging mechanism, and the charging aspects of 6G services and frameworks.
|
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 2 References
| The following documents contain provisions which, through reference in this text, constitute provisions of the present document.
- References are either specific (identified by date of publication, edition number, version number, etc.) or non‑specific.
- For a specific reference, subsequent revisions do not apply.
- For a non-specific reference, the latest version applies. In the case of a reference to a 3GPP document (including a GSM document), a non-specific reference implicitly refers to the latest version of that document in the same Release as the present document.
[1] 3GPP TR 21.905: "Vocabulary for 3GPP Specifications".
[2] 3GPP TS 32.240: "Charging management; Charging architecture and principles".
[3] 3GPP TR 22.870: "Study on 6G Use Cases and Service Requirements".
[4] 3GPP TR 23.801-01: "Study on Architecture for 6G System; Stage 2".
[5] 3GPP TS 32.254: "Charging management; Exposure function Northbound Application Program Interfaces (APIs) charging".
[6] 3GPP TS 32.255: "Charging management; 5G Data connectivity domain charging; stage 2".
[7] 3GPP TS 32.256: "Charging management; 5G connection and mobility domain charging; stage 2".
[8] 3GPP TS 32.291: "Charging management; 5G system; Charging service, stage 3".
[9] 3GPP TS 32.298: " Charging management; Charging Data Record (CDR) parameter description".
|
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 3 Definitions of terms, symbols and abbreviations
| |
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 3.1 Terms
| For the purposes of the present document, the terms given in TR 21.905 [1] and the following apply. A term defined in the present document takes precedence over the definition of the same term, if any, in TR 21.905 [1].
example: text used to clarify abstract rules by applying them literally.
|
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 3.2 Symbols
| For the purposes of the present document, the following symbols apply:
<symbol> <Explanation>
|
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 3.3 Abbreviations
| For the purposes of the present document, the abbreviations given in TR 21.905 [1] and the following apply. An abbreviation defined in the present document takes precedence over the definition of the same abbreviation, if any, in TR 21.905 [1].
ABMF Account Balance Management Function
CDR Charging Data Record
CGF Charging Gateway Function
CHF Charging Function
CTF Charging Trigger Function
ECUR Event Charging with Unit Reservation
IEC Immediate Event Charging
PEC Post Event Charging
RF Rating Function
SCUR Session Charging with Unit Reservation
|
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 4 High-level description
| |
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 4.1 Background
| |
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 4.1.1 5G Converged Charging System
| The converged charging online and offline charging system is introduced for 5G system, as described in the TS 32.240 [2] clause 4.3.3.2. The following figure 4.1.1-1 specified the converged charging architecture.
Figure 4.1.1-1: Logical ubiquitous converged charging architecture
The Converged charging system includes the CHF (CHarging Function), ABMF (Account Balance Management Function), CGF (Charging Gateway Function) and RF (Rating Function).
The 5G converged charging is to provide a common process for a single, unified charging system, support the utilized online and offline charging information, as well as charging information record generation via CHF.
- Converged online and offline charging, with and without Quota management.
- Service Basde Interfaces Nchf via unified resource for all NF consumers.
- CHF CDR generation: CHF CDR(s) are generated by CHF for both online and offline charging, for all of the 5G services.
- Support "session" and "event" based charging, i.e. SCUR, ECUR, IEC and PEC.
- Charging information collection and reporting: the usage of online charging and offline charging are collected and reported in one charging message.
|
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 4.1.2 Potential SA1 requirements
| A set of charging requirements are identified in SA1 TR 22.870 [3] and copied below:
- [PR 5.5.9.6-1] Subject to operator policy and user consent, the 6G system shall support means to provide users with differentiation of QoS and charging based on users’ digital identity information issued by a third party and users’ subscription information.
- [PR 5.9.2.2-5] The 6G system shall be able to provide charging and accounting mechanisms for 6G System Data
- [PR-5.9.8.2-3] The 6G system shall provide appropriate charging support for differentiated services per media component (e.g. to meet SLA requirements).
- [PR 6.2.6-2] The 6G network shall support charging for the usage of network resources by third parties.
- [PR 6.11.6-2] The 6G network shall support charging information collection for the intelligent communication assistant service.
- [PR 6.14.6-1] The 6G system shall be able to collect charging information for the computing resource(s) coordinated by the 6G network e.g. per request, per UE.
- [PR 6.21.6-5] The 6G network shall support charging information collection per UE and/or for the usage of network resources related to multiple 3GPP services (e.g. communication service, sensing service, AI service) to satisfy the intents received from the UE.
- [PR 6.22.6-2] The 6G network (e.g. in conjunction to IMS) shall support charging information collection for the intelligent calling service.
- [PR.6.25.6-3] Subject to operator’s policy, the 6G network shall support the collection of charging information for the AI/ML model training, AI model inference and management which are within the service hosting environment for authorized third parties.
- [PR 6.26.6-4] The 6G network shall be able to collect charging information based on unique traffic characteristics pertinent to e.g. specific GenAI applications, or enhanced/guaranteed user experience.
- [PR 6.29.6-2] The 6G network shall be able to collect charging information for AI service per user.
- [PR 6.36.6-3] The 6G network shall be able to collect charging information for the usage of AI/ML models that are stored or generated within the Service Hosting Environment.
- [PR 6.44.6-3] Based on operator policy and user consent, the 6G network shall support mechanism to collect charging information for customized service based on received intent(s) from user.
- [PR 6.55.6-2] Based on regulatory requirements, operators’ policy and agreement with 3rd party, 6G network shall support charging for services provided to 3rd party AI agents (e.g. combination of communication, computing service, sensing service, etc.).
- [PR 7.17.6-4] The 6G system shall be able to support charging for the 6G wireless sensing service (e.g. considering sensing KPIs, duration).
- [PR 9.10.6-3] The 6G system shall support collection of charging information associated with initiating and terminating an intelligent immersive calling service.
Editor's Note: The requirements for 6G charging are still to be completed and further updates can be made in this clause.
|
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 4.1.3 Potential New Services with Charging Concern
| Table 4.1.3-1: Potential New Services with Charging Concern
Potential New Services
Description
UE assisted services
services involving UE contributions, e.g., certain types of sensing services
|
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 4.1.3.1 UE assisted services
| The new services enabled by 6G networks will be different from the legacy connectivity services. In legacy systems, the UE acts as a service consumer. In 6G, the UE will assist MNO to provide new services, contributing capabilities such as sensing and the 6G new service consumers will expand beyond the UE to include any authorized entities – application functions, 3rd parties, etc. Consequently, we need to consider enhancing business models in which UEs not only consume services but also assist MNO to provide 6G services with better QoE.
|
96f8bdc68da73f6fda85234415019d6f | 32.801-02 | 4.2 Business Model for 6G Charging
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.