<?xml version="1.0" encoding="US-ASCII"?>
<?xml-stylesheet type='text/xsl' href='rfc2629.xslt' ?>
<?rfc toc="yes" ?>
<?rfc symrefs="yes" ?>
<?rfc sortrefs="no"?>
<?rfc iprnotified="no" ?>
<?rfc strict="no" ?>
<?rfc compact="no" ?>
<?rfc subcompact="no" ?>
<!DOCTYPE rfc SYSTEM "rfc2629.dtd" [
<!ENTITY RFC2119 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.2119.xml">
<!ENTITY RFC3588 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.3588.xml">
<!--<!ENTITY RFC4005 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.4005.xml">-->
<!ENTITY RFC7155 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.7155.xml">
<!ENTITY RFC6733 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.6733.xml">
<!ENTITY RFC8174 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.8174.xml">
]>
<rfc category="info" docName="draft-liest-nmrg-ndt-challenges-00"
     ipr="trust200902">
  <front>
    <title abbrev="NDT Challenges">Challenge: Network Digital Twin - Practical Considerations and Thoughts</title>

    <author fullname="Marco Liebsch" initials="M" surname="Liebsch">
      <organization abbrev="NEC">NEC Laboratories Europe GmbH</organization>
      <address>
        <postal>
          <street>Kurfuersten-Anlage 36</street>
          <city> D-69115 Heidelberg</city>
          <region></region>
          <code></code>
          <country>Germany</country>
        </postal>
        <email>marco.liebsch@neclab.eu</email>
      </address>
    </author>

    <author fullname="Martin Stiemerling" initials="M" surname="Stiemerling">
      <organization abbrev="h_da">Darmstadt University of Applied Sciences</organization>
      <address>
        <postal>
          <street>Schoefferstrasse 3</street>
          <city>Darmstadt</city>
          <region></region>
          <code>64295</code>
          <country>Germany</country>
        </postal>
        <email>mls.ietf@gmail.com</email>
      </address>
    </author>

        <author fullname="Neil Schark" initials="N" surname="Schark">
      <organization abbrev="h_da">Darmstadt University of Applied Sciences</organization>
      <address>
        <postal>
          <street>Schoefferstrasse 3</street>
          <city>Darmstadt</city>
          <region></region>
          <code>64295</code>
          <country>Germany</country>
        </postal>
        <email>Neil.Schark@h-da.de</email>
      </address>
    </author>

    <date year="2024"/>

    <area>Internet</area>

    <workgroup>Network Management Research Group (NMRG)</workgroup>

    <keyword>Internet-Draft</keyword>

    <keyword></keyword>

    <keyword></keyword>

    <abstract>
      <t>This document focuses on practical challenges associated with the
   design, creation and use of Network Digital Twins. According to the
   identified challenges, a set of suitable functional elements are described
   to overcome some of these challenges. Experiences from the design,
   development and evaluation of an SDN-based Network Digital Twin are described
   and conclude this document.     
   </t>
    </abstract>
  </front>




  <middle>
    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    <section title="Terminology">
<!--      <t>The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
      "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
      document are to be interpreted as described in RFC 2119 <xref
      target="RFC2119"/>.</t>
-->
    <t>The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL
      NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED",
      "MAY", and "OPTIONAL" in this document are to be interpreted as
      described in BCP 14 <xref target="RFC2119"/> <xref target="RFC8174"/> when, and only when, they
      appear in all capitals, as shown here.</t>

    </section>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->


   <section anchor="sec:intro"
             title="Introduction">
<t>Digital Twins are well known from Industry applications, where, for example, a robotic system or production machine
with sensors and actuators is digitally represented on a computer. The twin is used for monitoring and simulation purpose.
In the meantime, the computation and use of a digital twin of a data network gets more traction and is discussed in the
research community in particular in the view of automated network management, also in the view of beyond 5th Generation (5G) of
a mobile communication system.
</t>

<t>The creation of a Network Digital Twin (NDT) implies many challenges, incl. the continuous
collection and computation of relevant data points from network components of a possibly large network topology with many
network functions and nodes. As a key use case, the user of an NDT may apply changes, such as configurations or load, first to
the digital representation of the network and evaluate and assess these changes' impact to the network operation in terms
of performance, latency, or stability. Such simulation requires proper modelling of the network's information and behavior.
The IRTF's Network Management Research Group (NMRG) is discussing various use cases and is working on a suitable
reference architecture for NDTs <xref target="I-D.irtf-nmrg-network-digital-twin-arch"/>. 
</t>

<t>This document focuses on practical challenges associated with the design, creation and use of NDTs. Furthermore,
some technology directions and methodologies are discussed as possible solution to overcome some of these challenges.
Experiences from the design, development and evaluation of an prototype implementation, that realizes an NDT
of a Software-defined Network (SDN) completes this document.
</t>

   </section>


    <section anchor="sec:challenges"
             title="Practical Challenges in operating a Network Digital Twin">

<t>A user of a Network Digital Twin may be a person, which uses a suitable frontend, or an automated
process, such as a network OAM and Orchestration system. The user is probably aware of the detailed
or an abstracted view of the physical network topology. The NDT Instance comprises all functions
that are needed to monitor the physical network and to generate a digital representation of it, to expose
a digital representation of the network to the user, take probe requests from a user to simulate changes
in the digital representation of the network, and provide simulation results back to the user. To build a
digital representation of the network, the NDT instance monitors network functions in the physical
network and collects relevant data points. The resulting digital representation of the network
is in the following denoted as Twin Model.
</t>


<t>The following assumptions apply:
</t>

 <t><list style="hanging">
          <t hangText="o The NDT Instance is aware of the network nodes, functions and segments
that are in scope of its duty to build and maintain a Twin Model"/>

          <t
          hangText="o The NDT Instance is aware of relevant data points and how to collect them
from the physical network. The NDT Instance may probe periodically for these data points or
schedule periodic or event-based reporting of these data points, e.g. in a network controller."/>

	  <t hangText="o The NDT Instance and the user share the same descriptors and level of detail
of the Twin Model's topology."/>

          <t hangText="o The NDT Instance utilizes at least one method and model to apply a user's
probe request for changes in the network for simulation. The model may be aligned with tools
for discrete event simulation, mathematical models or models from the Artificial Intelligence
and Machine Learning Science. A model may be pre-provisioned or automatically generated and
improved throughout the NDT Instance operation."/>

          <t
          hangText="o Based on the provided and assessed simulation results, a user may decide to
apply the previously probed or adjusted changes to the physical network. Different options exist for
a concrete implementation of such enforcement. The user may have access to a network controller northbound
interface or any other API to apply changes to a physical network. One option is based on the principles
of Intent Based Networking (IBN), where the NDT Instance provides an API to its user to issue probe
requests and further semantic, that allows the NDT Instance to assess the simulation result and
enforce changes in the physical network on its own, without providing simulation results back to the
user."/>
</list></t>


<t><xref target="fig:principle"/> depicts generalized principles of generating and using a
Network Digital Twin. The NDT Instance maintains a model of the physical network by means of constantly monitored
data points. These data points are monitored on the relevant network nodes and network functions (NF) and
transmitted directly or indirectly (via a network controller) to the NDT Instance. The current state
of a network is exposed to the NDT user. Change requests in the network are issued to the NDT Instance. Such requests
may, for example, tune a parameter in a network node, such as load, performance, routing table entry, or load balancing
strategy. The simulation results may by provided back to the user to take further action.
</t>

<t>
The functional architecture of an NDT as described in <xref target="I-D.irtf-nmrg-network-digital-twin-arch"/> comprises
northbound interfaces for users or applications to leverage the NDT's features, and southbound interfaces towards the
physical network and its components to collect data points and enforce control decisions. 
</t>



<t>

   <figure anchor="fig:principle"
              title="Principle in generating and using a Network Digital Twin">
        <artwork align="center"><![CDATA[
                                         +-------------+    
   +--+                                  |             |
   |NF|- - - - - - - - - t1  - - - - - ->|             |  expose +------+
   +--+                                  |             | ------> |      |
            +--+                         |             |  probe  |      |
            |NF|- - - - -t2 - - - - - - >|     NDT     | <------ | NDT  |
            +--+                         |  Instance & |  result | User | 
+--+                                     |    Model    | ------> |      |
|NF|- - - - - - - - - - -t3 - - - - - - >| Computation |         +------+
+--+                                     |             |
                           +--+          |             |
                           |NF|- - t4- ->|             |
                           +--+          +-------------+

          ]]></artwork>

        <postamble></postamble>
      </figure>
</t>


<t>The complete life-cycle of an NDT Instance may imply the following challenges:
</t>

  <t><list style="hanging">
        <t hangText="o A large number and diversity of nodes and functions needs to be monitored, such as physical or virtual
routers, switches, network functions, or even compute, storage and networking resources. Scalability needs to be ensured in dependency
of the number and types of data points and the level of details needed for model generation and maintenance."/>
	<t hangText="o A large number of data points needs to be transmitted upstream towards the NDT Instance for data aggregation,
storage and computation. The platforms that host components associated with the NDT Instance must provide sufficient compute, storage and
networking resources to handle such data volume and its treatment."/>
  <t hangText="o The change rate, e.g., events per second, of any data point plays also a crucial role. As all changes of a data point
  could potentially transferred into the NDT instance, this may lead to either an overload situation of the instance or it may be even 
  impossible to keep up with all state changes, e.g., if considering TCP flows and their changes with respect to sequence numbers. This
  will require a proper dimensioning in terms of granularity of the data point's information to be relayed to the NDT instance.  "/>
	<t hangText="o Transmission latency (t1, t2, t3, ...) from a number of network functions to the NDT Instance may differ dependent on the topological
distance of a network function, its monitoring strategy (local data point aggregation) and network performance. In case data points are labeled
with timestamps, synchronization of distributed network nodes/functions may be required. Dependent on the modelling technique, differences in
transmission latency and timestamps may have impact on the model accuracy. "/>
	<t hangText="o Users of an NDT Instance may have different requirements on the relevant network scope, accuracy, attributes associated
with the network nodes, functions and segments, as well as with delay tolerance in the NDT providing simulation results back to the user."/>
	<t hangText="o Impact and severity of the above items depend on many factors, such as network size, network performance, expected accuracy,
and the deployment strategy of NDT enablers (centralized vs. distributed)."/>
		<t hangText="o It is likely that a NDT is used by multiple users in parallel. This is not an issue when these uses concurrently read state
  from the NDT, but challenges arise when multiple users apply changes to the same NDT. This in fact means that parallel configurations of the
  NDT happen and it has to be ensured that these configurations are not conflicting each other or, in case of a conflict, are merged in a
  meaningful way. "/>
</list></t>

   
    </section>



   <section anchor="sec:reference_arch"
             title="NDT Instance -- Functional Components and Reference Points">
<t>The IRTF's Network Management Research Group (NMRG) drafted and published a Reference Architecture for NDTs. This section complements
the NMRG's NDT reference architecture without interference and adds a few functional elements in support of the subsequent discussion
section. While <xref target="sec:ref_intro"/> depicts an NDT reference architecture with the focus on selected functions and reference points,
<xref target="sec:ref_discuss"/> discusses the roles of some functional elements and reference points. 
</t>

	<section anchor="sec:ref_intro"
		title="NDT reference architecture -- an extended view">
	 

<t>The functional architecture of an NDT as described in <xref target="I-D.irtf-nmrg-network-digital-twin-arch"/> comprises northbound
interfaces for users or applications to leverage the NDT's features, and southbound interfaces towards the physical network and its
components to collect data points and enforce control decisions.
</t>

<t><xref target="fig:reference_arch"/> distills and depicts a few functional additional elements and reference points that may play a role in tackling
the above challenges. The Network Twin Instance (T) comprises an interface (M-T) to a Management System, that initializes the Network
Twin Instance, monitors its operation and applies changes as needed, e.g. the scope of the physical network from which a twin should
be created, or changes in the physical network topology that need to be taken into account for the twin creation. Monitoring as well
as the enforcement of changes in the physical network may be performed through a network controller (NW Controller), which is decoupled
from the Network Twin Instance and used by the Network Twin Instance as well as by the NDT User (U) through the NW Controller's northbound
interface (T-Ctrl, U-Ctrl). In case of a distributed and collaborative deployment, Network Twin Instances can utilize a federation
interface (T-T). The role of the illustrated functional element and reference points in addressing the above challenges is discussed
in the subsequent <xref target="sec:ref_discuss"/>  
</t>


<t>

   <figure anchor="fig:reference_arch"
              title="Functional Elements and Reference Points of a Network Digital Twin">
        <artwork align="center"><![CDATA[

      +------------+             +--------------+
      | Management |             | NDT User (U) |
      +------------+             +--------------+
            ^                          ^ ^   
            |M-T                    U-T| |
            |                          | +---------------+
            v                          v                 |
 +----------------------------------------------+        |
 |              Network Twin Instance (T)       |        |
 |                                              |        |
 |  +-------------+      +--------------------+ +-----+  |
 |  | Interpreter |      |  Model Federation  | |     |  |
 |  +-------------+      +--------------------+ |     |  |
 |                                              | T-T |  |
 |  +-------------+      +--------------------+ |     |  |
 |  |             |      | Model Verification | |     |  |
 |  | Twin Models |      +--------------------+ |<----+  |
 |  |             |                             |        |
 |  +-------------+   +------------+            |        |
 |                    |            |  +-------+-+        |
 |                    |            |  |       ^          |
 |                    +------------+  |       |T-Ctrl    |U-Ctrl
 |                                    |       v          v
 |  +-----------+     +------------+  |  +------------------+     
 |  |Data Points|     |            |  |  |  NW Controller   | 
 |  |  Storage  |     |            |  |  +------------------+
 |  +-----------+     +------------+  |    |      ^       |
 |                                    |    |      |       |
 +------------------------------------+    |      |       |
                                           |      |       |
                                   Ctrl_mon|  Data_Points |Ctrl_conf
                                           v      |       v
 +--------------------------------------------------------------+
 |                   Physical Network (NW)                      |
 +--------------------------------------------------------------+

          ]]></artwork>

        <postamble></postamble>
      </figure>
</t>


    </section> 

    <section anchor="sec:ref_discuss"
             title="The role of some functional elements and reference points">

<t>The following list describes the role of the functional elements and reference points that are highlighted
in <xref target="fig:reference_arch"/>.
</t>

<t><list style="hanging">
        <t hangText="o Interpreter -- Receives probe requests with changes that apply to the Network Twin and additional descriptions
to guide the Network Twin Instance for computing the result. The U-T reference point may be Intent-based, which requires the
Interpreter to classify the request and determine relevant technical attributes and network function before applying the
changes to the Twin Model. Any other API may apply to the U-T reference point and can give the NDT User full control on
the attributes that apply to a particular model component should change."/>
        <t hangText="o Twin Data and Behavioral Model (TDBM)-- A model of the data and of the complete network and its behavior
        that should be represented by the NDT, or a sub-network in case of distributed and collaborating Network Twin Instances."/>
	<t hangText="o Network Controller (NWC) -- Exposes northbound interfaces to the Network Twin Instance (T-Ctrl) and the NDT User (U-Ctrl).
The northbound interface is used to configure physical network monitoring and data point collection, as well as to apply
changes to the physical network. The NWC exposes southbound interfaces to the physical network for scheduling monitoring
rules on the network components and function (Ctrl_mon), to collect monitoring result (Data Points), and to enforce changes in the
physical network"/>
	<t hangText="o Data Points Storage -- Stores and structures monitored data points in alignment with the Twin Model. In case of
a distributed and collaborative deployment, the Data Points Storage may hold only data points associated with the respective sub-network."/>
	<t hangText="o Model Verification -- In case a machine learning model is being used, the model may be accurate and valid for
some time, but may need to be re-trained in case of re-configurations in the physical network. A new model may be trained in the background
while one model is being used at a time. In case a model turns out to be inaccurate, a suitable indication may be exposed to all connected
NDT users until a new, more accurate model is in service."/>
	<t hangText="o Model Federation -- A distributed deployment of multiple Network Twin Instances (T) can be advantageous in many
aspects. A single instance can model a sub-network comprising only a single network component or network functions, or may take
a few neighbor components and their data points into account. Such strategy can increase scalability and accuracy due to the
lower volume on network topology information and data points, as well as the resulting smaller Twin Model. Accuracy may benefit from
lower transmission latency of data points. Distributed Network Twing Instances can collaborate via the T-T reference points and
expose complete models to neighboring or all Network Twin Instances. Model aggregation can be accomplished by a single or multiple
dedicated Network Twin Instances."/>
</list></t>

<t>For large physical networks and their representation as NDT, a distributed deployment may be advantageous in many aspects.
For small sub-networks, In-Network Computing could be a suitable enabler to run machine learning models that represent the NDT
of a single or a few neighboring nodes. Training of such sub-network model may be performed on the node with In-Network Computing capabilities or by an external node. 
</t>

   </section>

   </section>

<!-->
     <section title="Leveraging in-network computing for NDT">
      <t>Ideas on concepts, benefit, operations, drawbacks.</t>

    </section>
-->


    <section  anchor="sec:sdndt"
             title="SDNDT - Implementation of a Software-defined Network Digital Twin">

    <section title="Discussion">
        <t>A first architectural and practical challenge is I) how to extract information about the current state of
        the physical network to the Network Digital Twin (NDT) and II) how to feed back changes from the NDT to the
        physical network. </t>
        <t>There are two extremes: <list style="hanging">
          <t hangText="o A fully distributed approach where each single network element writes its state into a 
          distributed database and changes are fed back from this database to the elements. NDT users also have to
          read and write state to the distributed database."/>
          <t hangText="o A fully centralized approach is also possible where a network controller is in charge of
          reading and writing from/to the network elements. This network controller would have its own data base
          and NDT users would solely interact with the network controller."/>
        </list>
        </t>
        <t>
        Further we distinguish between these types of NDTs (though there are more):
        <list style="hanging">
          <t hangText="o Static Test System"/>
          <t hangText="o Live Reacting System"/>
        </list>
        </t>
        <t>The static test system is the more simple type of the two systems. The overall goal is to be able to create a NDT instance on
        demand, which represents the physical network as good as possible. It lacks the need for dynamic up- dates in either direction,
        as only a snapshot is taken on-demand. By design, changes should only be applied to either the physical system or the Digital Twin
        if explicitly desired. In a realistic scenario, the NDT has to be updated to keep up with changes done on the physical network,
        but its sufficient, if the virtual environment gets recreated each time, as it should only represent a static state of the system
        at a given time. This approach may look overly simplified, but for a first proof-of-concept implementation it may be the best
        way, as the number of challenges and constraints is low.
        </t>
        <t>
        The long-term goal is to have a NDT that is (optimally) in total sync with the physical environment or it represents the physical
        network as close as possible. This would call for an extension of the static test system to a live reacting system, i.e., 
        automatic synchronization of state changes in the physical network to the NDT and triggered changes from the NDT back. However,
        the live reacting system will need live-data, i.e., real-time updates to the NDT, which may be challenging in terms of
        amount of information and the required granuality of the data, by the NDT instance. 
        </t>
        <t>In order to achieve a first usable implementation we did limit it to a fully-centralized approach for a static live test system.
        This focusses the implementation efforts to extracting configuration and runtime information from the physical network to the NDT
        and the feedback from the NDT. However, it of course neglects the real-time aspect, but getting a first workable solution was
        and is the goal.
        </t>
    </section>
    <section title="Implementation Overview">
        <t>For the implementation of the live static test system we used the goSDN SDN controller <xref target="gosdn"/> as network
        controller and on top if it a specialized application, i.e., the venv manager <xref target="venv-manager"/>. The emulation
        of the network elements can be done on virtual machines, but we did chose to rely on containerlab <xref target="containerlab"/>
        </t>
    <t>
    <xref target="fig:static-test-system"/> shows the principle architecture of the static test system. The roles of, as described
    in <xref target="sec:ref_discuss"/>, Interpreter, federation, and verification are currently not implemented, but will follow
    in the future. It is distinguished in the physical network and the NDT part. From the structure both parts are identically:
    <list style="hanging">
        <t hangText="o network controller -- is a SDN controller (SDN cntrl in the figure) and has the role of reading and writing
        configuration and state to and from the network elements. The controller is there in two instances, in the upper part for the
        physical network and in the lower part for the NDT instance."/>
        <t hangText="o venv-manager -- is a networking app running on the North-Bound-Interface (NBI) of goSDN and is in charge of
        retrieving the topology of the physical network and to feed it over the interface (2) (right hand side) to the NDT instance's
        venv-manager."/>
        <t hangText="o Controller-to-controller interface -- this interface, (1) in the figure, is used to synchronize the NDT
        instance with the configuration and state data of the physical network and also from the NDT back to the physical part."/>
        
        <t hangText="o network elements -- are either physical in the physical network domain or emulated ones in the NDT domain
        (lower part). In our implementation with use either virtual machines or containerlab for emulating the physical network elements."/>
    </list>
    The M-T and U-T reference points are exposed by the goSDN controller for the NDT instance. 
   <figure anchor="fig:static-test-system"
              title="Architecture overview of the static test system">
        <artwork align="center"><![CDATA[




      +----------------------------------------------+   
      |          goSDN controller - eco system       |   
      |              for physical network            |   
      |  +-------------+      +--------------------+ |   
      |  |             |      |                    | |   
    +-+->+ SDN cntrl   |<---->|    venv-manager    |<+--+ 
    | |  |             |      +--------------------+ |  |
    | |  +-------------+                             |  |
    | |      |  ^   |                                |  |
    | +------+--+---+--------------------------------+ (2)
    |        |  |   L----------+                        |
   (1)       |  +----------+   |                        |
    |        |             |   |                        |
    | Crl_mon| Data_Points |   |Ctrl_conf               |
    |        |             |   v                        |
    | +----------------------------------------------+  |
    | |           Physical Network (NW)              |  |
    | +----------------------------------------------+  |
    |                                                   |
    |                                                   |
    |      ^   ^                                        |
    |   M-T|   |U-T                                     |
    |      |   |                                        |
    | +----+---+-------------------------------------+  |
    | |    |   | goSDN controller - eco system       |  |
    | |    v   v     for NDT                         |  |
    | |  +-------------+      +--------------------+ |  |
    | |  |             |      |                    | |  |
    +-+->+ SDN cntrl   |<---->|    venv-manager    |<+--+ 
      |  |             |      +--------------------+ |  
      |  +-------------+                             |  
      |      |  ^   |                                |  
      +------+--+---+--------------------------------+  
             |  |   L----------+                        
             |  +----------+   |                        
             |             |   |                        
      Crl_mon| Data_Points |   |Ctrl_conf               
             |             |   v                        
      +----------------------------------------------+  
      |           Virtual/NDT Network                |  
      +----------------------------------------------+  

          ]]></artwork>

        <postamble></postamble>
      </figure>
    </t>
    <t>The goSDN controller uses gNMI with Yang models, namely a subset of OpenConfig <xref target="openconfig-ym"/>,
    to represent the configuration and state data of the network elements and thus the whole network. The gNMI
    interfaces, with the respective data models, is used to implement the Crl_mon and Ctrl_conf interfaces,
    as well as, the collection of data points. The state of devices is represented in the data models within
    the controller. 
    </t>
    <t>For testing purposes we did use Arista's CEOS docker images within containerlab, as a commercial
    counter part, for network elements. Further, we have developed our own SDN agent, the gnmi-target
    <xref target="danet-gnmi-target"/>, which runs on Linux (tested for debian and ubuntu) and in the
    future also on FreeBSD 13.2-RELEASE and newer. </t>
    </section>
    <section title="First Findings">
      <t>The current implementation of a NDT instance is usable for a static test system. The implementation
      works with one vendor specific operating system and our own gnmi-target as SDN agent on a network
      element. However, the crucial point will be if and how the required information can be extracted
      from the physical network. This is usually less a conceptual issue, but more a practical question
      what is accessbile with more less standardized interfaces.</t>
      <t>The current aim was not to have full-fledged real-time live reacting system, but to do the first
      steps, learn, and then move on towards more features, such as live feeds.</t>
      <t>Also self-learning behavioral model of the network elements was not developed, as we rely on
      virtualized versions of the network element's operating system, such as, Aristas CEOS or our own
      SDN agent on plain Linux. This neglects of course any impact of the hardware of a real network
      element, e.g., port or forwarding engine behavior.</t>
    </section>

    </section>





    <section title="IANA Considerations">
      <t>This document does not have IANA considerations.</t>

    </section>


    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    <section title="Security Considerations">
    <t>Security considerations are to be done in future revisions of this memo.</t>
    <t>However, one can imagine that a NDT instance with a full copy of the configuration and state 
    information of a complete network is a huge trove for any attacker. </t>
    </section>

    <section title="Acknowledgments">
      <t>Neil Schark is partially funded by the German BMBF DemoQuanDT project. Martin Stiemerling is partially
      funded by the German BSI ADWISOR5G project.</t>
    </section>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->
  </middle>

  <!-- ////////////////////////////////////////////////////////////////////////////////// -->

  <back>
    <references title="Normative References">
      &RFC2119;

      &RFC8174;

      <!--      &RFC3588;-->

    </references>

<references title="Informative References">


<?rfc include='reference.I-D.irtf-nmrg-network-digital-twin-arch"'?>
<reference anchor="gosdn" target="https://netellyfish.org">
   <front>
      <title>goSDN controller GIT repository</title>
      <author/>
   </front>
</reference>
<reference anchor="venv-manager" target="https://code.fbi.h-da.de/danet/gosdn/-/tree/master/applications/venv-manager">
   <front>
      <title>venv mananger implementation</title>
      <author/>
   </front>
</reference>
<reference anchor="containerlab" target="https://containerlab.dev/">
   <front>
      <title>venv mananger implementation</title>
      <author/>
   </front>
</reference>
<reference anchor="openconfig-ym" target="https://github.com/openconfig/public/">
   <front>
      <title>OpenConfig Yang Models repository</title>
      <author/>
   </front>
</reference>
<reference anchor="danet-gnmi-target" target="https://code.fbi.h-da.de/danet/gnmi-target">
   <front>
      <title>da/net gnmi-target</title>
      <author/>
   </front>
</reference>

    </references>

  </back>
</rfc>
