The rise of technologies like AI and IoT has increased the need for high-performance, low-latency computing. Edge computing addresses this by extending cloud resources closer to client applications. Effective workload distribution across this edge-cloud continuum must however consider both network proximity and available computing resources to avoid potential overloads. To achieve this, we developed a computing-aware framework for dynamic traffic steering using Kubernetes API, MP-BGP, and SRv6. Specifically, we use Kubernetes APIs to determine computing capacity and BGP to advertise it, while SRv6 steers traffic based on proximity, resource availability, and QoS requirements. We implemented a proof-of-concept of the proposed framework and validated it using GNS3 and Unix-based routers running FRRouting, demonstrating its effectiveness and performance.

This paper presents an enhanced edge-cloud service-continuity platform that integrates advanced Transport Layer Security (TLS) 1.3 features to address performance and security challenges in dynamic smart environments such as smart cities and logistics. Building on a previously proposed proxy-based architecture, we incorporate two key TLS mechanisms: hybrid post-quantum key exchange using X25519MLKEM768 to mitigate Store Now Decrypt Later (SNDL) attacks, and stateless session resumption for fast handover across edge proxies. Our open-source implementation relies on Envoy proxies and BoringSSL library. We evaluate the cryptographic, data, and latency overheads across multiple network conditions. Results show that hybrid post-quantum TLS introduces manageable overheads while significantly enhancing security, and that session resumption reduces connection costs by up to 73%. These findings confirm the viability of strong cryptographic protections without sacrificing service performance, making the solution suitable for secure, seamless continuity in smart city edge computing scenarios.

In the world of cloud technologies, serverless computing has now settled as a stable and promising resident. This gives a cloud provider the flexibility to provide its users with both Platform-as-a-Service (PaaS), i.e., the back-end application runs in a dedicated container, or Function-as-a-Service (FaaS), i.e., the back-end logic is offered as elementary functions that are invoked by the client applications. In parallel, edge computing has attracted a significant interest, due its enticing promises of reducing the outbound traffic of telco operators, while at the same time cutting down the user latency. As a result, in the near future, PaaS and FaaS containers are going to cohabit in a versatile computation infrastructure spanning from the far edge up to the cloud. In this paper we propose a mathematical formulation of a resource allocation problem that optimizes the assignment of both types of containers and can be solved efficiently by an edge orchestrator. We evaluate the proposed solution via extensive simulation experiments, which show that our approach, which takes into account the characteristics of PaaS vs. FaaS, provides significant performance benefits compared to less sophisticated strategies, despite its relatively low run-time complexity.

Interoperability is one of the main issues concerning the Internet of Things (IoT). The Arrowhead Framework (AHF) is an open-source platform that aims at tackling this problem. In this work, we first integrate a set of legacy IoT devices (i.e., an ECG and a smart plug) into the AHF by leveraging W3C Web of Things (WoT) as an interface between the two worlds. The result is an architecture where AHF consumers are deployed in a local cloud and consume Web Things, which can be deployed on IoT devices as well as on servers at the network edge to provide edge computing services. In this context, IoT device mobility raises a problem. When the IoT device moves, indeed, the edge-hosted service needs to follow it to preserve proximity, which is key to edge computing. In this case, the IP addresses of both the Web Things (i.e., the one hosted on the IoT device and the one hosted at the edge) may change, causing problems of mutual reachability after mobility/migration. WoT does not currently handle this issue. In this work, we extend WoT in this direction and evaluate our approach over a small-scale edge computing testbed.

ETSI MEC is a standard for edge computing which allows the execution of services - called MEC applications - on hosts in user proximity. One of the emerging concepts within ETSI MEC is that of MEC application relocation, i.e., the migration of a MEC application between edge hosts. ETSI MEC identifies several approaches to relocate a MEC application along with its internal state. However, some of these approaches devote the transfer of the application state to the application itself, whereas others rely on costly virtual-machine migration procedures. To overcome the above limitations, in this work we extend ETSI MEC to support MEC application relocation by exploiting container-migration technologies. We evaluate the performance of our implementation over a small-scale edge testbed, showing the overall benefits of the proposed approach.

Serverless computing has emerged as a very popular cloud technology, together with its companion Function-as-a-Service (FaaS) programming model enabling invocations of stateless functions from clients. An evolution of serverless is now taking place, shifting it towards the edge of the network and broadening its scope to stateful functions, as well. In this paper we argue that stateless vs. stateful is not a dichotomy of the application per se, but rather a time-varying property of most (if not all) applications, as confirmed by the analysis of real traces collected in a production environment. Based on this observation, we propose a mathematical formulation of a resource allocation problem that jointly encompasses both operation modes, dubbed lambda vs. mu, which can be solved efficiently at run-time by an edge orchestrator. We evaluate the proposed solution via simulation experiments in realistic network and workload conditions, which leads the way to the practical realization of a system where applications can freely adapt their current operation mode and optimize their performance at a minimum cost of operation from the network's perspective.

Edge computing allows to run microservices in close proximity to end user devices. This proximity lets edge computing support emerging 5G application scenarios that need low latency and high bandwidth (e.g., augmented reality, autonomous vehicles). Given its interest, edge computing is fastly gaining momentum and is currently being standardised by the European Telecommunications Standards Institute (ETSI) as Multi-Access Edge Computing (MEC). Notwithstanding its strengths, edge computing is significantly challenged by device mobility, as this can reduce proximity to the edge microservice, putting edge computing benefits at risk. A way to solve this problem is to migrate the edge microservice across edge servers, to let it follow the application component running on the mobile device. Besides, if the microservice is stateful (i.e., it maintains a state associated to the user), its state needs to be migrated as well. Within ETSI MEC, this concept is expressed as stateful application relocation. The standard identifies three different high-level ways to transfer the application state. However, all of them assume that it is up to the application to actually relocate the state. In this work, we assume that applications at the edge run as containers, and we extend ETSI MEC to let it support stateful application relocation by leveraging container migration techniques. This approach allows to transfer the application state in a transparent way to the application itself. We implemented our solution and tested it over a small-scale edge computing testbed to extract initial results.

In modern cloud and edge computing environments, services are typically provided as Virtual Machines (VMs). More recently, containers have been gaining momentum as a lightweight form of VMs. Container migration is used for several reasons, one of which being to maintain proximity between edge computing services and mobile users. When migrating containers, however, it is important to consider that they typically have ongoing communications with other endpoints, e.g., users' applications. Moreover, in case of connection-oriented protocols, communicating endpoints share a state (i.e., the connection), which needs to be migrated as well. Connection-oriented protocols like TCP were not designed having connection migration in mind, thus their connections cannot survive a change of IP address or port number. On the other hand, the QUIC protocol provides a mechanism for client-side connection migration, i.e., when a client device changes IP address (e.g., after a wireless handover), QUIC transparently migrates ongoing connections to the new address. Nonetheless, server-side connection migration in QUIC is not yet implemented nor investigated. In this paper, we extend QUIC to support server-side connection migration when a container is migrated between hosts. More specifically, we design two different strategies to achieve this purpose. Besides, we describe a proof-of-concept implementation based on aioquic, a Python open-source implementation of QUIC. We also verify that our implementation does not break QUIC specification nor undermines aioquic interoperability. Finally, we evaluate our solution by testing both the considered strategies using different container migration techniques and against a no-migration scenario.

The integration between fog computing and the Internet of Things (IoT) creates plenty of new opportunities. Fog computing nodes run complex tasks on behalf of IoT devices, and the topological proximity of fog computing to the IoT enables several advantages (e.g., low latency). However, some IoT devices are mobile, and mobility may compromise the fog advantages. When a device moves, the communication path to the corresponding fog service may increase, with an impact on the fog advantages (which are a consequence of fog proximity) and overall performance. To overcome this issue, the fog service may be migrated across the fog computing infrastructure and maintained close enough to the served IoT device(s). It is worth noting, though, that service migration comes at a cost and may affect application Quality of Service (QoS). In this paper, we consider a fog service to be implemented as multiple containers, having one of them encapsulating an MQTT broker. Our contribution is the evaluation of the impact of container migration, which is considered in various flavours, on application QoS as perceived by mobile things. To this purpose, we consider an augmented reality application based on the MQTT protocol and conduct a set of experiments over a real fog computing testbed. Results show how migrating the fog service gives some benefits on the experienced QoS with respect to a case where no migration is performed.

Integration between fog computing and the Internet of Things (IoT) paves the way to a plethora of promising opportunities. Device mobility might however impair fog computing benefits (e.g., low latency), which are indeed an outcome of fog proximity to end users/devices. A solution to this problem is to migrate the fog service across the fog infrastructure, thus to keep the distance to the served mobile device as low as possible. In this paper, we consider a fog service to be implemented as the combination of two containers, and we detail the demo through which we plan to show the impact of fog service migration on application performance. To this purpose, we plan to deploy an Augmented Reality (AR) application that detects vehicles in video frames and augments the latter with bounding boxes built around the detected vehicles. We offer to the audience the possibility to: (i) interact with the employed testbed by triggering device mobility; (ii) visualise the difference between migrating and not migrating the fog service in response to device mobility.

Research in the Internet of Things (IoT) conceives a world where everyday objects are connected to the Internet and exchange, store, process, and collect data from the surrounding environment. IoT devices are becoming essential for supporting the delivery of data to enable electronic services, but they are not sufficient in most cases to host application services directly due to their intrinsic resource constraints. Fog Computing (FC) can be a suitable paradigm to overcome these limitations, as it can coexist and cooperate with centralized Cloud systems and extends the latter toward the network edge. In this way, it is possible to distribute resources and services of computing, storage, and networking along the Cloud-to-Things continuum. As such, FC brings all the benefits of Cloud Computing (CC) closer to end (user) devices. This article presents a survey on the employment of FC to support IoT devices and services. The principles and literature characterizing FC are described, highlighting six IoT application domains that may benefit from the use of this paradigm. The extension of Cloud systems towards the network edge also creates new challenges and can have an impact on existing approaches employed in Cloud-based deployments. Research directions being adopted by the community are highlighted, with an indication of which of these are likely to have the greatest impact. An overview of existing FC software and hardware platforms for the IoT is also provided, along with the standardisation efforts in this area initiated by the OpenFog Consortium (OFC).

Due to their intrinsic resource constraints, the mobile Internet of Things (IoT) devices are not able to provide intensive services by just relying on their own facilities. Fog Computing effectively helps overcome this hurdle. Indeed, it extends the Cloud toward the network edge, distributing resources and services of computing, storage, and networking close to the end devices. This topological proximity is the key enabler of several advantages that are essential in many emerging ICT domains. Nonetheless, the mobility of an IoT device compromises such benefits as it increases the topological distance to the serving Fog node. Therefore, the Fog service has to be migrated in order to be always close enough to the served IoT device. We name thisCompanion Fog Computing(CFC), since the Fog service behaves as a "companion" of the correspondent application on the mobile device. In this paper, we present a Fog Computing Platform that performs stateful container (i.e., Fog service) migrations in order to enable CFC. Specifically, we introduce a CFC model from which we derive a reference architecture comprising all the functionalities required in a platform to make migration decisions and carry them out. Moreover, we demonstrate the soundness of the proposed reference architecture by discussing a proof-of-concept implementation based on the Stack4Things (S4T) platform, and we report a set of conducted experiments to show the feasibility of stateful container migrations.

As for the Cloud, essential features of Fog Computing are both virtualization and the capability to migrate virtual environments among nodes. In this paper, we thoroughly report both the state-of-the-art virtualization and migration techniques and their available implementations. In particular, we investigate the aptness of such technologies for a specific layer of the Fog hierarchy, namely the network edge. Indeed, this layer presents some characteristics that distinguish it from the Cloud so that a virtualization or migration technique that represents a good compromise for the Cloud might not be likewise suitable for the edge.

The Internet of Things (IoT) conceives a world where everyday objects are able to join the Internet and exchange data as well as process, store, collect them from the surrounding environment, and actively intervene on it. An unprecedented number of services may be envisioned by exploiting the Internet of Things. Fog Computing, which is also known as Edge Computing, was proposed in 2012 as the ideal paradigm to support the resource-constrained IoT devices in data processing and information delivery. Indeed, the Fog, which does not replace the centralized Cloud but cooperates with it, distributes Cloud Computing technologies and principles anywhere along the Cloud-to-Things continuum and particularly at the network edge. The Fog proximity to the IoT devices allows for several advantages that must be continuously guaranteed, also when end devices move from one place to another. In this paper, we aim at examining in depth what it means to provide mobility support in a Fog environment and at investigating what are the main challenges to be faced. Besides, in order to highlight the importance of this topic in everyday life, we provide the reader with three scenarios where there is an integration between the IoT and Fog Computing, and in which mobility support is essential. We finally point out the main research directions in the field.