Load-Balanced Dynamic SFC Migration Based on Resource Demand Prediction

Abstract

In network function virtualization, the resource demand of network services changes with network traffic. SFC migration has emerged as an effective technique for preserving the quality of service. However, one important problem that has not been addressed in prior studies is how to manage network load while maintaining service-level agreements for time-varying resource demands. Therefore, we propose the Resource Predictive Load Balancing SFC Migration (RP-LBM) algorithm in this paper. The algorithm uses CNN-AT-LSTM to predict VNF resource demands in advance, eliminating the delays associated with dynamic migrations and determining the optimal migration timing. It leverages the PPO algorithm’s perceptual capabilities in complex environments to develop SFC migration strategies and ensure network load balancing. Additionally, it reduces the number of subsequent migrations and minimizes the service interruption rate. The simulation results show that the service interruption rate of the RP-LBM algorithm is on average 27.3% lower than that of the passive migration method. The PPO-based migration algorithm has lower SFC migration times and service interruption rates compared to the DQN algorithm, ensuring service continuity with low migration costs.

1. Introduction

In traditional networks, deploying or updating the physical network requires specialized hardware to provide new services. This leads to high purchasing and maintenance costs. Additionally, the system cannot be easily customized or adjusted based on demand. Therefore, Network Function Virtualization (NFV) was developed. NFV aims to implement the functions of traditional network devices through software. It decouples network functions from dedicated hardware and runs them as software on general-purpose servers or in virtualized environments. This approach can significantly reduce operators’ costs and improve the flexibility and resilience of network service deployment. Network operators can use Service Function Chains (SFCs) to provide customized network services to users. SFC connects Virtualized Network Functions (VNFs). It not only supports the fine-grained and elastic delivery of services in the network but also allows for the modification of service functions and the migration of loads.

In NFV, operators use Service Function Chains to provide customized network services [1]. Network efficiency is closely related to the mapping of Virtualized Network Functions and the routing of SFCs. At the same time, as network slicing operates, the traffic arrival of each specific service fluctuates over time. This can lead to a mismatch between SFC resource demand and server resource availability, which negatively affects the quality of service (QoS) and resource utilization [2]. When a VNF layout and resource allocation strategy cannot meet the current network demands, the NFV Orchestrator (NFVO) reconfigures the SFC. This reconfiguration includes vertical scaling, horizontal scaling, and dynamic migration. Horizontal scaling makes full use of fragmented resources, but it is only possible when there are enough available resources on the server. Dynamic migration is a flexible solution during overload conditions, but it also incurs overhead.

Due to the dynamic changes in traffic, edge computing networks often experience overloaded nodes. This leads to increased computation delays and sometimes service interruptions. To maintain normal SFC services, SFC migration must be performed. Additionally, network load balancing should be ensured. Network load balancing allows the network system to adapt more easily to dynamic changes in traffic [3]. By introducing load balancing for time-varying network traffic, the network becomes more robust after VNF migration and promotes long-term resource optimization.

Based on the above background, we focus on the problem of SFC dynamic migration for network load balancing in edge computing environments where resources are scarce and highly dynamic. We use machine learning algorithms to predict VNF resource demands, which helps us anticipate changes in network node resource allocation. With the prediction results, we proactively determine the appropriate time for migration and identify the VNFs to migrate from overloaded nodes. We also use deep reinforcement learning algorithms to better understand complex environments and select target nodes for migration. This approach ensures network load balancing, reduces the number of future migrations, and minimizes the impact of unnecessary migrations.

In view of the above problems, the main contributions of this paper are as follows:

• Considering the real SFC request scenario, we use a time-varying traffic dataset. We apply a CNN-AT-LSTM model to predict the short-term resource demands of VNFs. Using these predictions, we can proactively migrate VNFs in advance within a certain time frame.
• Considering that dynamic changes in traffic may lead to frequent VNF migration and uneven use of network resources, we introduce a load-balancing model to maintain network stability.
• In response to the multi-dimensionality and complexity of the VNF migration remapping problem caused by the dynamic network environment, we propose a DRL algorithm based on Proximal Policy Optimization (PPO) to enhance the effectiveness of VNF migration decisions.

2. Related Work

Within the framework of Network Function Virtualization, researchers from around the world have conducted many studies on the dynamic migration of Service Function Chains and have achieved significant results. One major challenge in dynamic migration is how to allocate resources for SFCs as their resource demands change and the duration that SFCs remain in the network is uncertain. Recent research typically takes one or more factors related to migration costs as optimization objectives and proposes corresponding migration decision algorithms.

For instance, the authors of [4] proposed a migration algorithm based on Deep Q-Networks (DQNs). Their goal was to minimize end-to-end latency and address service interruptions caused by overloaded nodes, link failures, and VNF instance failures. The authors of [5] introduced a framework that uses Convolutional Neural Networks (CNNs) and Artificial Neural Networks (ANNs) to determine the optimal migration paths for VNFs. Their aim was to minimize migration time and cost. This solution analyzes network conditions, workload patterns, and resource availability to achieve dynamic and efficient VNF relocation, which significantly improves network performance and reliability. Additionally, the authors of [6] presented a scalable cluster-based VNF migration algorithm. This algorithm is designed to minimize the total embedding cost while meeting the latency requirements between VNFs. It performs better than existing methods in terms of embedding costs and has a much shorter execution time compared to brute-force search methods.

However, the methods mentioned above only trigger migrations after changes occur in network traffic or after network node or link failures. These are forms of reactive migration and cannot proactively handle sudden changes in resource demand. Currently, to solve reactive migration, researchers are trying to predict resource demands in advance. In [7], the authors proposed a CAT-LSTM model to predict the resource demands of VNFs using SFC data. They improved accuracy by using aspect embedding and attention mechanisms. Similarly, the authors of [8] introduced a Graph Neural Network (GNN) model based on the graph features. This model accurately predicts VNF resource demands by identifying multidimensional dependencies within SFC graph structures. Although studies in [7,8] have made progress in prediction, they do not deeply explore how to effectively use these predictions to optimize resource allocation.

Moreover, existing research primarily focuses on optimizing objectives such as reducing latency and migration costs. However, merely minimizing energy consumption or overhead may lead to uneven utilization of network resources, and future dynamic traffic changes could result in frequent VNF migrations. Additionally, in edge computing networks where resources are relatively scarce and highly dynamic, greater emphasis should be placed on the distribution and utilization efficiency of resources to ensure network load balancing.

Current studies have demonstrated the advantages of ensuring network load balancing in enhancing network performance. For example, the authors of [9] proposed a load-balanced Virtual Network Embedding algorithm based on deep reinforcement learning for regional satellite networks. The algorithm divides the satellite network into multiple mapping regions and deploys Virtual Network Requests only in the region with the lowest load. It simultaneously considers topology dynamics and resource loads, effectively improving acceptance rates while also enhancing resource utilization. Similarly, the authors of [10] introduced a task scheduling algorithm considering load balancing issues in cloud computing environments. The proposed BCSV algorithm achieves better results in terms of completion time, load balancing, and resource utilization compared to previous algorithms, even in heterogeneous environments. This improvement enhances the overall performance of cloud computing networks.

In summary, we use high-precision predictions to anticipate SFC resource demands in advance and determine the appropriate timing for migration. We introduce a load-balancing model to ensure efficient use of resources, reduce the frequency of VNF migrations in the network, and avoid potential issues caused by uneven resource usage. Additionally, we design a deep reinforcement learning algorithm to proactively make migration decisions for SFCs on overloaded nodes, preventing the degradation or even interruption of network service quality.

3. System Model and Problem Description

In this section, we define the network model, describe the SFC and VNF, and then propose the VNF migration problem and the network load balancing model.

3.1. Network Model

We consider an NFV network architecture with three layers as depicted in [11]. As shown in Figure 1, physical nodes are connected by links in the physical layer. VNFs are instantiated on physical nodes that supply the necessary resources in the VNF layer. The various NF types that comprise the SFC are deployed on matching VNF types at the application layer.

The physical network is modeled as a fully connected undirected graph $G=\left(V^s,E^s\right)$, where $V^s$ is the set of underlying nodes and $E^s$ is the set of physical links between nodes. The underlying nodes have a set of resource types to support VNFs, such as CPU, memory, and cores. Here, $C_i^S$ represents the maximum CPU resource capacity of the $i$-th node $v_i^s\in V^S$, where each unit of CPU resource represents the resources required to process a data packet. The memory resource capacity of the $i$-th node is $M_i^S$, represented in available megabytes. The underlying link directly connecting nodes $v_i^s$ and $v_j^s$ is represented as $e_{ij}^S\in E^s$, the physical link bandwidth is $B{W}_{ij}^S$, and the link delay is represented as $L_{ij}^S$.

3.2. SFC and VNF

The VNF type set is represented as $F$, and the CPU and memory resources consumed by the server to instantiate a VNF $f\in F$, denoted as $v^{vnf}$, are $c^f$ and $m^f$, respectively. A physical node can instantiate one or more types of VNFs, and each type of VNF can support the deployment of multiple virtual network function instances.

The SFC set is represented as $S$, and each request $sf{c}^j\in S$ can be represented as $sf{c}^j=\langle v_{j,in}^s,v_{j,out}^s,V_j^{NF},E_j^{NF},l_j\rangle$, where $v_{j,in}^s$ and $v_{j,out}^s$ represent the entrance and exit network elements, respectively; $V_j^{NF}$ represents a set of ordered NF request sets, the set of VNF types that the traffic passes through in order; $E_j^{NF}$ represents the logical link set, connecting the VNFs between the entrance and exit network element nodes; and $l_j$ represents the permissible end-to-end delay of the request. The CPU resource demand and memory resource demand of the $u$-th NF $v_{j,u}^{nf}\in V_j^{NF}$ of $sf{c}^j$ are $c_{j,u}^{nf}$ and $m_{j,u}^{nf}$, respectively. The traffic segment $\left(v_{j,u}^{nf},v_{j,v}^{nf}\right)$ of $sf{c}^j$ is represented as the logical link $e_{j,uv}^{nf}\in E_j^{NF}$, and the bandwidth demand of the logical link is $b{w}_{j,uv}^{nf}$.

The decision variable $t_{j,u}^f\in \left\{0,1\right\}$ specifies the types of NFs in the SFC. If the $u$-th virtual node $v_{j,u}^{nf}\in V_j^{NF}$ of $sf{c}^j$ is of type $f$, then $t_{j,u}^f$ equals 1:

$$t_{j,u}^f=\{\begin{array}{c}1,\hspace{1em} if v_{j,u}^{nf}is of type of f\in F\\ 0, otherwise\end{array}$$

(1)

It is stipulated that the entrance and exit network element nodes do not have a type; that is, $t_{j,u}^f$ is always equal to 0. When the decision variable ${\eta }_{j,u}^i\in \left\{0,1\right\}$ equals 1, it indicates that the $u$-th virtual node $v_{j,u}^{nf}\in V_j^{NF}$ of $sf{c}^j$ is deployed on the physical node $v_i^s\in V^S$:

$${\eta }_{j,u}^{i,t}=\{\begin{array}{c}1,\hspace{1em} if v_{j,u}^{nf}is mapped to v_i^s during t\\ 0, otherwise\end{array}$$

(2)

When the decision variable ${\tau }_{j,uv}^{pq}\in \left\{0,1\right\}$ equals 1, it indicates that the traffic segment $e_{j,uv}^{nf}\in E_j^{NF}$ of $sf{c}^j$ flows through the physical link $e_{pq}^S\in E^S$, which can be represented as follows:

$${\tau }_{j,uv}^{pq}=\{\begin{array}{c}1, \hspace{1em} if e_{j,uv}^{nf}is mapped to e_{pq}^s during t\\ 0, otherwise\end{array}$$

(3)

If an NF of type $f\in F$ is mapped to $v_i^s\in V^S$, then a VNF of type $f$ must also be instantiated on node $v_i^s$. Here we define the state variable ${\beta }_f^i\in \left\{0,1\right\}$, which equals 1 if there is a VNF of type $f\in F$ on the physical node $v_i^s\in V^S$:

$${\beta }_f^i=\{\begin{array}{c}1 \hspace{1em} if a VNF of type f is assigned on v_i^s\\ 0 otherwise\end{array},$$

(4)

$${\beta }_f^{i,t}=1, \mathrm{if} {\displaystyle \sum }_{sf{c}^j\in S}{\displaystyle \sum }_{v_{j,u}^{nf}\in V_j^{NF}}{\eta }_{j,u}^{i,t}{t}_{j,u}^f\ge 1, \forall v_i^s\in V^S, f\in F, t\in T$$

(5)

Due to dynamic traffic changes, the relationship between the inflow bandwidth and resource demand of $v_{j,v}^{nf}\in V_j^{NF}$ at time $t$ can be expressed as follows:

$$c_{j,v}^{nf}\left(t\right)=b{w}_{j,uv}^{nf}\left(t\right){\displaystyle \sum }_{f\in F}{t}_{j,v}^f {\mathrm{coeff}}_c^f\hspace{1em}\forall t\in T$$

(6)

$$m_{j,v}^{nf}\left(t\right)=b{w}_{j,uv}^{nf}\left(t\right){\displaystyle \sum }_{f\in F}{t}_{j,v}^f {\mathrm{coeff}}_m^f\hspace{1em}\forall t\in T$$

(7)

where $coef{f}_c^f$ and $coef{f}_m^f$ represent the CPU resource coefficient and memory resource coefficient, respectively, of the VNF of type $f\in F$. The data flow may be amplified or reduced (such as firewalls and intrusion defense will reduce traffic) when passing through each NF, causing the required bandwidth to change. The relationship between the inflow bandwidth of an NF $v_{j,v}^{nf}\in V_j^{NF}$ and the required bandwidth of the logical link connected to it is

$$b{w}_{j,uv}^{nf}\left(t\right)=b{w}_{j,ku}^{nf}\left(t\right){\displaystyle \sum }_{f\in F}{t}_{j,v}^f {\mathrm{ratio}}^f \forall t\in T$$

(8)

where $v_k^{nf},v_u^{nf},v_v^{nf}\in V_i^{NF}$ are a set of ordered NFs, and ${\mathrm{ratio}}^f$ is the bandwidth scaling factor for VNF of type $f\in F$.

To describe the migration process, here we define variables related to server status and VNF migration. When ${\mathsf{\xi }}_{j,u}^t\in \left\{0,1\right\}$ equals 1, it indicates that the virtual node $v_{j,u}^{nf}$ needs to perform migration in the $t$ period.

We define a set of variables related to resource prediction. Resource data can be CPU, disk, memory, or other system resource usage, such as the number of processes, OS load, etc. For simplicity, this paper considers predicting CPU and memory data. $c_{j,u}^{nf}\left(t+n\right)\left(n=1,2,\dots \right)$ represents the CPU resource demand of $v_{j,u}^{nf}$ in the $t+n$ period obtained through prediction; $m_{j,u}^{nf}\left(t+n\right)\left(n=1,2,\dots \right)$ represents the memory resource demand of $v_{j,u}^{nf}$ in the $t+n$ period obtained through prediction.

$th{r}_{over}$ represents the overload threshold of the underlying server.

The above variables satisfy the following constraint conditions: each virtual network function of the service function chain should be deployed on a physical node, which is unique, and can be represented as follows:

$${\displaystyle \sum }_{v_i^s\in V^s}{\eta }_{j,u}^{i,t}=1 \forall sf{c}^j\in S, \forall v_{j,u}^{nf}\in V_j^{NF}, \forall t\in T$$

(9)

Each virtual link needs to be mapped onto a physical link. Since the virtual link may span nodes,

$${\displaystyle \sum }_{e_{pq}^s\in E^s}{\mathsf{\tau }}_{j,uv}^{pq,t}\ge 1 \forall sf{c}^j\in S, \forall e_{j,uv}^{nf}\in E_j^{NF}, \forall t\in T$$

(10)

The constraints on CPU and memory resources of the underlying network nodes are respectively satisfied:

$${\displaystyle \sum }_{f\in F}{\mathsf{\beta }}_f^{i,t}{c}^f+{\displaystyle \sum }_{sf{c}^j\in S}{\displaystyle \sum }_{v_{j,u}^{nf}\in V_j^{NF}}{\mathsf{\eta }}_{j,u}^{i,t}{c}_{j,u}^{nf}\left(t\right)\le C_i^S \forall v_i^s\in V^S, \forall t$$

(11)

$${\displaystyle \sum }_{f\in F}{\mathsf{\beta }}_f^{i,t}{m}^f+{\displaystyle \sum }_{sf{c}^j\in S}{\displaystyle \sum }_{v_{j,u}^{nf}\in V_j^{NF}}{\mathsf{\eta }}_{j,u}^{i,t}{m}_{j,u}^{nf}\left(t\right)\le M_i^S \forall v_i^s\in V^S, \forall t\in T$$

(12)

The underlying link bandwidth constraint is satisfied:

$${\displaystyle \sum }_{sf{c}^j\in S}{\displaystyle \sum }_{e_{j,uv}^{nf}\in E_j^{NF}}{\tau }_{j,uv}^{pq,t}b{w}_{j,uv}^{nf}\left(t\right)\le B{W}_{pq}^S \forall e_{pq}^s\in E^S, \forall t\in T$$

(13)

The service function chain delay limit is satisfied:

$${\displaystyle \sum }_{e_{j,uv}^{nf}\in E_j^{NF}}{\displaystyle \sum }_{e_{pq}^s\in E^s}{\tau }_{j,uv}^{pq,t}{L}_{pq}^S\le l_j\hspace{1em}\forall sf{c}^j\in S, \forall t\in T$$

(14)

Every pair of connected VNFs $\left(v_{j,u}^{nf},v_{j,v}^{nf}\right)$ satisfies traffic conservation. Given a logical link $e_{j,uv}^{nf}\in E_j^{NF}$ and underlying nodes $\forall v_i^s\in V^S$,

$$\sum _{v_q^s\in {\mathsf{\Omega }}^{+}\left(v_p^s\right)}{\mathsf{\tau }}_{j,uv}^{qp,t}-\sum _{v_q^s\in {\mathsf{\Omega }}^{-}\left(v_p^s\right)}{\mathsf{\tau }}_{j,uv}^{pq,t}=\left\{\begin{array}{c}{\mathsf{\eta }}_{j,v}^{p,t}-{\mathsf{\eta }}_{j,u^{\prime }}^{p,t}, \hspace{1em}\forall v_{j,u^{\prime }}^{nf},v_{j,v}^{nf}\in V_j^{NF}\\ 1, \forall v_{j,v}^{nf}\in \left\{v_{j,out}^s\right\},\hspace{0.17em}{v}_{j,out}^s=v_p^s,\hspace{0.17em}{v}_{j,u}^{nf}\in V_j^{NF}\\ -1, \forall v_{j,v}^{nf}\in \left\{v_{j,in}^s\right\},\hspace{0.17em}{v}_{j,in}^s=v_p^s,\hspace{0.17em}{v}_{j,u}^{nf}\in V_j^{NF}\\ 0, otherwise\end{array}\right.$$

(15)

where ${\mathsf{\Omega }}^{+}\left(v_p^s\right)$ and ${\mathsf{\Omega }}^{-}\left(v_p^s\right)$ represent the upstream and downstream node sets of vps, respectively.

The migration of the virtual node $v_{j,u}^{nf}\in V_j^{NF}$ is represented by the following constraint condition. If the underlying node mapped by $v_{j,u}^{nf}$ is different before and after the traffic change, then $v_{j,u}^{nf}$ is migrated:

$${\mathsf{\xi }}_{j,u}^t\ge {\mathsf{\eta }}_{j,u}^{i,t}-{\mathsf{\eta }}_{j,u}^{i+1,t}\hspace{1em}\forall v_{j,u}^{nf}\in V_j^{NF}, \forall sf{c}^j\in S, \forall v_i^s\in V^S, \forall t\in T$$

(16)

3.3. Load Balancing Model

The network system can more readily adjust to the dynamic fluctuations in network traffic because of network load balancing [3]. Load balancing is implemented for time-varying network traffic in order to improve network resilience following VNF migration and encourage long-term resource optimization.

The system’s efficiency in terms of load balancing is assessed using the change in resources. The average resource usage rate of physical nodes is directly correlated with the variance of system resources [12]. The load on physical node m may change as a result of VNF j being moved from physical node n to physical node m during the VNF migration process.

At this time, the load on physical node m can be represented as follows:

$$L_m^{\mathrm{cpu}}\left(t\right)={\displaystyle \sum }_{j\in N_i^v}{x}_m^{i,j}·C_{i,j}^v\left(t\right)$$

(17)

$$L_m^{\mathrm{mem}}\left(t\right)={\displaystyle \sum }_{j\in N_i^v}{x}_m^{i,j}·M_{i,j}^v\left(t\right)$$

(18)

where the CPU and memory resource loads of physical node m are denoted by $L_m^{\mathrm{cpu}}\left(t\right)$ and $L_m^{\mathrm{mem}}\left(t\right)$, respectively. To determine overall load balancing, the variation in resources on a single physical node m is insufficient. Based on variations in system resources, the load-balancing capability of the system can be assessed. Consequently, the mean CPU and memory load values at time $t$ are:

$$L_{\mathrm{mean}}^{\mathrm{cpu}}\left(t\right)={\displaystyle \frac{{\sum }_{m\in N^P}{L}_m^{\mathrm{cpu}}\left(t\right)/C_m}{\left|N^P\right|}}$$

(19)

$$L_{\mathrm{mean}}^{\mathrm{mem}}\left(t\right)={\displaystyle \frac{{\sum }_{m\in N^P}{L}_m^{\mathrm{mem}}\left(t\right)/M_m}{\left|N^P\right|}}$$

(20)

where $C_m$ and $M_m$ represent the physical node $m$’s CPU and memory resource capacity, respectively. The network’s variations in CPU and memory resources are stated as follows:

$$L_{\mathrm{var}}^{\mathrm{cpu}}\left(t\right)={\displaystyle \frac{{\sum }_{m\in N^P}{\left[L_m^{\mathrm{cpu}}\left(t\right)-L_{\mathrm{mean}}^{\mathrm{cpu}}\left(t\right)\right]}^2}{\left|N^P\right|}}$$

(21)

$$L_{\mathrm{var}}^{\mathrm{mem}}\left(t\right)={\displaystyle \frac{{\sum }_{m\in N^P}{\left[L_m^{\mathrm{mem}}\left(t\right)-L_{\mathrm{mean}}^{\mathrm{mem}}\left(t\right)\right]}^2}{\left|N^P\right|}}$$

(22)

We employ the percentage of resource consumption as the measurement unit when assessing a network system’s load balancing to make sure that storage and processing resources are quantified in the same unit. Consequently, the weighted sum of the variations of computing and storage resources can be used to determine the load-balancing capability $L_{\mathrm{total}}\left(t\right)$ of the network system, which is expressed as follows:

$$L_{\mathrm{total}}\left(t\right)={\omega }_1{L}_{\mathrm{var}}^{\mathrm{cpu}}\left(t\right)+{\omega }_2{L}_{\mathrm{var}}^{\mathrm{mem}}\left(t\right),$$

(23)

where the weight factors for the impact of storage and computing resources on network load balancing are denoted by ${\omega }_1$ and ${\omega }_2$, respectively. Both resources are assumed to have the same effect on the network in this paper, with ${\omega }_1={\omega }_2=0.5$.

Thus, minimizing the variation in computing and storage resources is the system’s optimal goal, as indicated by

$$min{L}_{\mathrm{total}}\left(t\right)$$

(24)

4. Algorithm Design

Liu et al. [13] demonstrated that the VNF migration problem is NP-hard, since the significant scale of the network, the diversity of the network service flow, and the variability of the network environment make the VNF placement decision space high-dimensional and difficult.

Therefore, this section proposes a Resource Predictive Load Balancing SFC Migration Algorithm (RP-LBM) to address the aforementioned issue. The overall architecture of the algorithm is shown in Figure 2. The resource monitoring module obtains the dynamic resource utilization of the physical network. The Long Short-Term Memory (LSTM) model uses historical resource demand data to predict the NF resource demand at a future time. The resource prediction result is input into the migration decision module. For the SFC deployed on the node that is expected to be overloaded, the Proximal Policy Optimization algorithm is used to obtain the migration strategy. This strategy includes determining the migration path and VNF embedding nodes, ensuring that the service is not interrupted, and minimizing resource variance.

4.1. LSTM-Based Resource Demand Prediction Algorithm

Traffic variations in network environments are typically highly real-time and dynamic. Short-term forecasting can promptly reflect and quickly capture these changes. Deep learning models possess rapid learning and adaptation capabilities, enabling them to accurately complete prediction tasks and capture real-time traffic fluctuations within a short time frame. Therefore, we have adopted an integrated algorithm that combines Convolutional Neural Networks, Long Short-Term Memory networks, and attention mechanisms to accurately predict the resource demands of VNF [14].

First, the CNN module is used to extract key features from the historical data of VNF resource usage. CNNs excel at identifying local patterns and spatiotemporal features in data, and are able to generate high-quality feature representations. The convolutional layer scans the VNF resource usage time series data with multiple convolutional kernels. This captures different types of local patterns, such as peaks and regular changes in resource usage. As a result, it generates a rich set of feature maps that clearly show the underlying structure of VNF resource usage.

Next, the features extracted by the CNN are passed to the LSTM network. LSTM has powerful sequence processing capabilities, which can capture the time dependencies and long-term patterns in the use of VNF resources. This helps the model learn the connections between different time steps. LSTM processes the feature sequences and captures the dynamic information of resource demands change over time by maintaining hidden states and memory cells. LSTM can identify trend changes and cyclical fluctuations in resource use.

To further improve the model’s prediction capability, we integrate an attention mechanism into the LSTM network. The attention mechanism can assign different weights to each time step. This highlights the most important historical information for the current prediction. Figure 3 shows a flowchart of how the attention mechanism is integrated with the LSTM network. The workflow of the attention mechanism is as follows:

At each time step $t$, the attention mechanism calculates the attention weights based on the hidden state of the current LSTM $h_t$ and the hidden state of all previous time steps ${\alpha }_{t,i}$, where $i$ takes all previous time steps. Attention weights are calculated by a scoring function that measures the relevance of each hidden state $h_i$ to the current prediction task $t$:

$$e_{t,i}=score\left(h_t,h_i\right)=h_t^{⊺}{W}_a{h}_i$$

(25)

$${\alpha }_{t,i}={\displaystyle \frac{\mathrm{e}\mathrm{x}\mathrm{p}\left(e_{t,i}\right)}{{\sum }_{k=1}^T\mathrm{e}\mathrm{x}\mathrm{p}\left(e_{t,k}\right)}}$$

(26)

where $W_a$ is a learnable weight matrix, and the softmax function ensures that the attention weights ${\alpha }_{t,i}$ are 1 on all $i$.

Then, the attention weight ${\alpha }_{t,i}$ is used to perform a weighted sum of the hidden states to generate a context vector $c_t$:

Finally, the context vector $c_t$ is $h_t$ connected to the current hidden state, and the final resource demand forecast ${\widehat{y}}_t$ is generated through the fully connected layer:

$${\widehat{y}}_t=softmax\left(W_c\left[c_t;h_t\right]+b_c\right)$$

(27)

where $W_c$ and $b_c$ are the weight matrix and bias term of the fully connected layer, respectively.

Through this hybrid model combining CNN, LSTM, and attention mechanisms, the paper achieves precise predictions of future VNF resource demands, providing a reliable basis for SFC migration.

4.2. PPO-Based SFC Migration Algorithm

In the study of VNF migration problems, traditional heuristic algorithms are widely used in practical scenarios due to their simplicity and low computational complexity. However, in high-dimensional and complex decision spaces, these algorithms tend to get stuck in local optima. This limits the overall effectiveness of migration strategy optimization.

Deep reinforcement learning (DRL) algorithms, with their self-learning capabilities and extensive data analysis power, can explore a more comprehensive strategy space in high-dimensional decision environments. This allows DRL algorithms to find superior migration strategies compared to heuristic algorithms in complex and dynamic network environments. Although training deep neural networks requires significant computational resources and time, they offer notable advantages in decision accuracy and migration strategy optimization for complex networks involving numerous network nodes, links, and service functions [4]. Additionally, the use of experience replay and parallel training techniques can improve training efficiency and reduce resource consumption.

Therefore, we propose a DRL algorithm based on Proximal Policy Optimization to solve the VNF migration problem. This algorithm converts the optimization objectives into a Markov Decision Process (MDP) and then uses the PPO algorithm to solve the MDP model, obtaining a near-optimal solution.

4.2.1. MDP Model

As part of dynamic optimization, we take into account reducing the variance of network resources following VNF migration under time-varying traffic. Since the state space, action space, state transition probability, and reward function are represented by the four-element tuple $(S,A,P,R),$ respectively, the optimization aim is changed into a Discrete Time Markov Decision Process (DTMDP).

The network’s state space at time $t$ is represented by the state space $S$, $s\left(t\right)=\left\{\mathsf{\psi }\left(t\right),\mathsf{\xi }\left(t\right),C\left(t\right),M\left(t\right)\right\}\in S$, where $\psi \left(t\right)$ denotes the state space of the physical node and $\xi \left(t\right)$ denotes the state space of the physical link, respectively, as follows:

$$\mathsf{\psi }\left(t\right)=\left\{{\mathsf{\phi }}_1\left(t\right),{\mathsf{\phi }}_2\left(t\right),\dots ,{\mathsf{\phi }}_n\left(t\right)\right\} \forall n\in N^p$$

(28)

$$\mathsf{\xi }\left(t\right)=\left\{{\mathcal{S}}_{1,1}\left(t\right),{\mathcal{S}}_{1,2}\left(t\right),\dots ,{\mathcal{S}}_{n,m}\left(t\right)\right\} \forall n,m\in N^p, \forall l_{nm}\in L^p$$

(29)

The state space of the CPU and the memory resource requirements of VNF are represented by $C\left(t\right)$ and $M\left(t\right)$, respectively. These demand data reflect the anticipated outcome of VNF’s resource needs. The two resource requirements’ state spaces can be shown as follows:

$$C\left(t\right)=\left\{C_{1,1}^v\left(t\right),C_{1,2}^v\left(t\right),\dots ,C_{i,j}^v\left(t\right)\right\} \forall i\in F,j\in N_i^v$$

(30)

$$M\left(t\right)=\left\{M_{1,1}^v\left(t\right),M_{1,2}^v\left(t\right),\dots ,M_{i,j}^v\left(t\right)\right\} \forall i\in F,j\in N_i^v$$

(31)

The set of mapping activities that VNF can perform is denoted by action space A. The mapping action space of VNF can now be expressed as follows:

$$a\left(t\right)=\left\{a_{1,1}\left(t\right),a_{1,2}\left(t\right),\dots ,a_{i,j}\left(t\right)\right\}\hspace{1em}\forall i\in F,j\in N_i^v,a\left(t\right)\in A$$

(32)

where $a_{i,j}\left(t\right)$ is the mapping action that the $j$-th VNF on SFC $i$ may perform. This includes the selection scheme of the physical node mapping variable $x_n^{i,j}$ and the virtual link mapping variable $y_{n,m}^{j,k}$.

The transition probability $P$, which can be expressed as $p\left(s\left(t+1\right)s\left(t\right),a\left(t\right)\right)$, is the probability of moving to the next state $s\left(t+1\right)$ following an action $a\left(t\right)\in a$ in the current state $s\left(t\right)\in s$.

The network creates a mapping strategy $\pi$ when it performs action $a\left(t\right)$ under state $s\left(t\right)$. The optimization aims states that an instantaneous reward $r\left(t\right)$ can be obtained if the mapping approach $\pi$ fulfills system restrictions.

$$r\left(t\right)=-L_{\mathrm{total}}\left(t\right)$$

(33)

The network uses the value function $V^{\pi }$ to assess the quality of the current VNF mapping strategy $\pi$ at this precise instant. $V^{\pi }$ can be represented as follows:

$$\begin{array}{ll}{V}^{\mathsf{\pi }}\left(s\left(t\right),a\left(t\right)\right)& =E\left[R\left(t\right)s\left(t\right),a\left(t\right)\right]\\ & =E\left[r\left(t\right)+{\gamma }_{v}r\left(t+1\right)+\cdots s\left(t\right),a\left(t\right)\right]\\ & =E\left[r\left(t\right)+{\gamma }_v{V}^{\pi }\left(s\left(t+1\right),a\left(t+1\right)\right)s\left(t\right),a\left(t\right)\right]\end{array}$$

(34)

where the importance of future rewards in relation to present rewards is represented by the discount factor, ${\gamma }_v\in \left[0,1\right]$. The optimal strategy for VNF migration can be expressed as follows:

$${\mathsf{\pi }}^{\ast }=\arg \underset{a}{\max }{V}^{\mathsf{\pi }}\left(s,a\right)\hspace{1em}\forall s,a$$

(35)

4.2.2. Proximal Policy Optimization Algorithm

Proximal Policy Optimization is a widely used policy optimization algorithm in reinforcement learning. PPO aims to stabilize the training process and reduce fluctuations and uncertainties during policy updates by limiting the difference between new and old policies [15]. PPO is mainly implemented through the following key steps.

First, it interacts with the environment using the current policy to collect a batch of trajectory data, including states $s_t$, actions $a_t$, rewards $r_t$, and next states $s_{t+1}$. To improve sample efficiency, data are usually collected simultaneously in multiple parallel environments. These data are used for subsequent updates of the policy and value function.

Next, the Generalized Advantage Estimation (GAE) method is used to estimate the advantage function $\widehat{A_t}$. The advantage function measures the superiority of a particular action relative to the average policy:

$$\widehat{A_t}={\delta }_t+\left(\gamma \lambda \right){\delta }_{t+1}+\dots +{\left(\gamma \lambda \right)}^{T-t+1}{\delta }_{T-1}$$

(36)

where ${\delta }_t=r_t+\gamma V\left(s_{t+1}\right)-V\left(s_t\right)$, $\gamma$ is the discount factor, and $\lambda$ is the GAE decay parameter.

Next, for each sample point, the probabilities of selecting action $a_t$ under state $s_t$ for both the new and old policies, ${\pi }_{{\theta }_{\mathrm{old}}}\left(a_t|s_t\right)$ and ${\pi }_{\theta }\left(a_t|s_t\right)$, are calculated. The probability ratio $r\left(\theta \right)$ indicates the relative change between the new and old policies. A ratio greater than 1 indicates that the new policy is more inclined to choose action $a_t$ in this state, while a ratio less than 1 indicates the opposite:

$$r\left(\theta \right)={\pi }_{\theta }\left(a_t|s_t\right)/{\pi }_{{\theta }_{\mathrm{old}}}\left(a_t|s_t\right)$$

(37)

To limit the extent of policy updates and avoid $r\left(\theta \right)$ being too large or too small, PPO introduces a clipping operation. The clipped objective function is defined as follows:

$$L^{\mathrm{CLIP}}\left(\mathsf{\theta }\right)=E_t\left[\min \left(r_t\left(\mathsf{\theta }\right)\widehat{A_t}, \mathrm{clip}\left(r_t\left(\mathsf{\theta }\right),1-ϵ,1+ϵ\right)\widehat{A_t}\right)\right]$$

(38)

where $ϵ$ is a small positive number, typically between 0.1 and 0.3. The clipping operation constrains $r_t\left(\theta \right)$ within the range $\left[1-ϵ, 1+ϵ\right]$, preventing excessive policy updates that lead to unstable training.

In addition, PPO uses mean squared error to minimize the difference between the value function and the target value:

$$L^{\mathrm{VF}}\left(\mathsf{\theta }\right)=E_t\left[{\left(V_{\mathsf{\theta }}\left(s_t\right)-V_t^{\mathrm{target}}\right)}^2\right]$$

(39)

The value function $V_{\mathsf{\theta }}\left(s_t\right)$ estimates the expected return after executing the policy in state $s_t$, while the target value $V_t^{\mathrm{target}}$ estimates the actual return, which can be calculated using Monte Carlo or temporal difference methods.

To encourage exploration and prevent premature convergence to local optima, an entropy regularization term is added. The entropy regularization term rewards policies with higher entropy, i.e., more random policies, which helps ensure adequate exploration during the early stages of training:

$$S\left[{\pi }_{\theta }\right]\left(s_t\right)=-{\displaystyle \sum }_a{\pi }_{\theta }\left(a|s_t\right)\log {\pi }_{\theta }\left(a|s_t\right)$$

(40)

Combining these components, the total loss function $L\left(\theta \right)$ is defined as follows:

$$L\left(\theta \right)=E_t\left(L^{\mathrm{CLIP}}\left(\theta \right)-c_1{L}^{\mathrm{VF}}\left(\theta \right)+c_2{S}_{\pi \theta }\right)$$

(41)

where $c_1$ and $c_2$ are weights used to balance the importance of policy loss, value function loss, and the entropy regularization term.

To optimize the total loss function $L\left(\theta \right)$, PPO typically uses stochastic gradient descent algorithms (such as the Adam optimizer) for parameter updates.

First, based on the current batch of sample data, calculate the gradients of the total loss function $L\left(\theta \right)$ with respect to the policy parameters and value function parameters, ${\nabla }_{{\theta }_a}L\left(\theta \right)$ and ${\nabla }_{{\theta }_c}L\left(\theta \right)$. Use the Adam optimizer to update the parameters based on the computed gradient information:

$${\nabla }_{{\theta }_a}L\left(\theta \right)\theta \leftarrow \theta -\alpha ·{\displaystyle \frac{m_t}{\sqrt{v_t}+ϵ}}$$

(42)

where $\alpha$ is the learning rate; $m_t$ and $v_t$ are the first- and second-moment estimates of the gradient, respectively; and $ϵ$ is a small constant to prevent division by zero.

The policy parameters ${\theta }_a$ aim to maximize policy rewards by minimizing the negative terms in the loss function:

$${\theta }_a\leftarrow {\theta }_a-\alpha ·{\nabla }_{{\theta }_a}\left(-L^{\mathrm{CLIP}}\left(\theta \right)-c_2{S}_{{\pi }_{\theta }}\right)$$

(43)

The value function parameters ${\theta }_c$ aim to minimize the value function loss $L^{\mathrm{VF}}\left(\theta \right)$:

$${\theta }_c\leftarrow {\theta }_c-\alpha ·{\nabla }_{{\theta }_c}{L}^{\mathrm{VF}}\left(\theta \right)$$

(44)

Through these steps, PPO effectively balances exploration and exploitation during policy optimization, stabilizes the training process, and enhances sample efficiency.

4.3. Resource Predictive Load Balancing SFC Migration Algorithm

The pseudocode for the RP-LBM algorithm is shown in Algorithm 1. RP-LBM uses predicted future resource demands and the physical network graph as inputs to generate the SFC mapping strategy $\pi$ (Lines 1–2). First, it calculates the resource utilization ${\eta }_R$ for each physical node based on the prediction results (Line 3). If ${\eta }_R$ exceeds the set threshold $th{r}_{over}$ (Line 4), it selects an SFC to migrate on that node (Line 5) and it initializes the policy parameters $({\theta }_c, {\theta }_a)$, the maximum number of iterations $K_{max}$, and other relevant parameters (Line 6). In the main loop (Lines 7–19), it selects mapping actions $a\left(t\right)$ from the policy $\pi \left(s_n\left(t\right)|a_n\left(t\right),{\theta }_a^n\right)$, executes the action to obtain an immediate reward r$\left(t\right)$, and transitions to a new state s$\left(t+1\right)$, while calculating the advantage function $A\left(s_n\left(t\right),a_n\left(t\right)\right)$. If constraints are not satisfied, it sets the immediate reward r(t) = $-1/\epsilon$ and reselects actions. Then, it computes the clipped surrogate objective for Proximal Policy Optimization and updates the policy parameters ${\theta }_a$ using gradient ascent and the value function parameters ${\theta }_c$ using gradient descent. If the resource utilization does not exceed the threshold, no action is taken (Line 20).

Algorithm 1 Resource Predictive Load Balancing SFC Migration Algorithm (RP-LBM)
1	Input: Prediction result $c_{j,u}^{nf}\left(t+n\right), m_{j,u}^{nf}\left(t+n\right)\left(n=1,2,\dots \right);$ Physical network diagram $G=\left(V^s,E^s\right)$; SFC network diagram $G_i^{nf}=\left(V_i^{nf}, E_i^{nf}\right)$
2	Output: SFC mapping strategy $\pi$;
3	Calculate the resource utilization ${\eta }_R$ of each physical node according to the prediction result;
4	if ${\eta }_R \ge th{r}_{over}$ then
5	Select an SFC to migrate on that node;
6	Initialize $({\theta }_c, {\theta }_a),K_{max}$, M, ($({\epsilon }_c, {\epsilon }_a)$);
7	for episode = 1, …, M do
8	Select mapping actions $a\left(t\right)$ from the strategies $\pi \left(s_n\left(t\right)|a_n\left(t\right),{\theta }_a^n\right)$;
9	if constraints are satisfied then
10	Execute the action $a\left(t\right)$, get the instantaneous reward
11	r$\left(t\right)$ and transfer it to the state s$\left(t+1\right)$;
12	Obtain the advantage function $A\left(s_n\left(t\right),a_n\left(t\right)\right)$;
13	else
14	Set instantaneous reward r(t) = $-1/\epsilon$, and re-select the action $a\left(t\right)$ from the policy network;
15	end if
16	Compute the clipped surrogate objective for PPO
17	Update the policy parameters ${\theta }_a$ using gradient ascent
18	Update the value function parameters ${\theta }_c$ using gradient descent
19	end for
20	end if

5. Performance Evaluation

5.1. Simulation Setup

In order to evaluate the effectiveness of the above algorithm, we conducted simulations using the SFC simulation platform SFCSim [16] using the Python environment and tested the program on a cellular network topology.

Figure 4 depicts the physical network, which consists of 42 links and 19 physical nodes. The server’s CPU and memory resources are set to roughly $(250, 300) \mathrm{MIPS}$ and $(600, 1000) \mathrm{GB}$, respectively, uniformly divided [17]. The link delay is uniformly distributed in units of $(1, 4) \mathrm{ms}$, and we have set the link bandwidth capacity to 500 Mbps. The node overload threshold is 0.7.

We consider eight types of VNFs. Each SFC chooses a subset of VNFs at random, and the length of each SFC is randomly selected from two to five. The entrance and exit are chosen at random from $V^S$. The bandwidth factor ratios of the various VNF variants are chosen from 0.5, 1, and 1.5.

The CPU coefficient $coef{f}_c^f$ and memory coefficient $coef{f}_m^f$ of different types of VNFs are uniformly distributed in (0.1, 0.2). The maximum delay of the SFC is 30 ms. We set the network to have 20 paths in a 24-hour period using the Clearwater VNF Dataset’s traffic dataset [18].

5.2. Simulation Result and Analysis

In this paper, the following metrics are used to evaluate the performance of the algorithm under three conditions of sufficient resources, moderate resources, and scarce resources: node resource variance, total network migration times, average variance of network node resources, and service interruption rate, i.e., the ratio of interruption time to the SFC lifecycle.

Firstly, the performance of three algorithms in predicting the resource demand of each network function in the prediction network was compared: LSTM, CNN-AT-LSTM, and LSTM–encoder–decoder. The results of model training are shown in

Table 1. Comparison of average results on all VNFs in SFCs between LSTM, CNN-AT-LSTM, and LSTM–encoder–decoder.

Metric	LSTM	CNN-AT-LSTM	LSTM–Encoder–Decoder
MSE	21.973	15.579	19.653
RMSE	4.688	3.947	4.433

. It can be seen that the mean square error (MSE) and root mean square error (RMSE) between the predicted values and the actual values of the CNN-AT-LSTM model are the smallest, indicating that this model has the highest prediction accuracy.

To intuitively demonstrate the predictive capabilities of the models, we chose LSTM and CNN-AT-LSTM as examples. We compared the CPU demand predictions for a single VNF with the actual values. The detailed comparison results are presented in Figure 5, which includes annotations for “Level Shift” and “Change Point.” During times when the data experienced significant level shifts, CNN-AT-LSTM quickly adjusted its predictions and closely followed the changes in the actual values. In contrast, the LSTM model showed some delay. At data change points, the prediction errors of CNN-AT-LSTM were much smaller than those of the LSTM model. This highlights CNN-AT-LSTM’s ability to capture rapid dynamic changes more effectively. The results indicate that the attention mechanism in CNN-AT-LSTM allows it to focus on important time steps within the input sequence. This is especially useful during pattern shifts and data change points. As a result, CNN-AT-LSTM improves overall prediction accuracy and response speed. In summary, CNN-AT-LSTM offers higher prediction precision and reliability when dealing with the dynamic fluctuations of network resource demands. It is better equipped to handle severe and sudden variations in resource requirements compared to the LSTM model.

The resource demand prediction results serve as input for the RP-LBM. RP-LBM can identify potential overload nodes in advance and develop corresponding migration strategies. Figure 6 and Figure 7 illustrate the changes in network resource variance under three different resource states: (a) sufficient resources, (b) moderate resources, and (c) scarce resources. The figure also compares the average node resource variance under these different conditions. In each scenario, we use different deep reinforcement learning algorithms, namely DQN and PPO, to create migration strategies. We compare these strategies with situations where no pre-migration is performed. The reward functions of the DQN and PPO algorithms are based on the network system’s load-balancing capability. This design causes the algorithms to prefer migration strategies that minimize network resource variance. Consequently, both algorithms maintain a lower variance in network resource usage and support the network’s load-balancing state. In contrast, the no-migration strategy uses the shortest path algorithm to deploy SFC but does not optimize network node resource usage. This approach results in unbalanced network resource utilization and fails to manage resource allocation effectively. As a result, the overall performance and stability of the system may be negatively affected.

We also compare the total number of network SFC migrations and the SFC service interruption rates when using different algorithms, as shown in Figure 8 and Figure 9. The analysis shows that, across all three resource states, the RP-LBM-PPO algorithm always results in fewer SFC migrations than the RP-LBM-DQN algorithm. Additionally, when resources are sufficient or moderate, the PPO algorithm performs similarly to the DQN algorithm in terms of service interruption rates. This indicates that the PPO algorithm can maintain lower service interruption rates with less migration overhead. Figure 5 shows that resource demand has periodic fluctuations and sudden data surges. Throughout the traffic variations, the RP-LBM algorithm consistently maintains the service interruption rate low. This demonstrates the algorithm’s capability to quickly ensure service quality during traffic bursts. By rapidly adjusting resource allocation, the algorithm effectively maintains service continuity. These results further validate the superior performance of the RP-LBM-PPO algorithm in dynamic environments.

In contrast, the strategy that does not use pre-migration can only respond passively to changes in resource demand. This approach cannot develop a migration plan in advance and results in the highest service interruption rate. This finding highlights the importance of predicting resource demand and planning ahead to improve network stability and reduce the risk of interruptions. Combined with Figure 7, it can be known that when the network resource variance is small, resource utilization is more balanced. Balanced resource utilization directly impacts the overall performance and efficiency of the network. The PPO and DQN algorithms maintain lower levels of network resource variance through effective load-balancing strategies. In this way, these algorithms achieve more balanced resource allocation and reduce the service interruption rate.

However, when resources are scarce, the number of migrations using the DQN algorithm increases significantly. This leads to a sharp rise in the service interruption rate, which is 7.6% higher than that of the PPO algorithm. In a resource-scarce environment, the DQN algorithm tends to frequently adjust network configurations to balance the load. These excessive migration operations increase the system’s overhead and complexity, resulting in a higher service interruption rate. The PPO algorithm, on the other hand, uses a more stable policy optimization method. This approach allows the PPO algorithm to adjust policies more effectively under resource constraints, reducing unnecessary migration times. The policy update mechanism of PPO ensures the continuity and stability of network services with only small policy changes. Therefore, in situations where resources are limited, the PPO algorithm demonstrates greater efficiency and stability. It reduces the number of migrations while maintaining a low service interruption rate. This performance indicates that the PPO algorithm has better robustness and adaptability in complex network environments.

6. Conclusions

6.1. Summary of the Performance

To address the issue of the service QoS degradation or interruptions caused by dynamic changes in resource demand within edge computing environments, we conducted an in-depth study on the dynamic migration problem of SFCs where resources are scarce and constantly changing. The focus is on optimizing network performance through load balancing. We used the CNN-AT-LSTM machine learning model to predict the resource demands of VNFs. This approach allows us to anticipate changes in network node resource allocation and proactively develop migration strategies based on these predictions. By determining which VNFs to migrate from overloaded nodes, we ensure efficient resource management. We integrated the Proximal Policy Optimization deep reinforcement learning algorithm into our prediction model. This combination enables the system to detect changes in complex environments and select appropriate target nodes for migration. It also achieves network load balance, reduces the number of subsequent migrations, and minimizes the impact of unnecessary migrations.

The experimental results demonstrate that the RP-LBM-PPO algorithm outperforms the RP-LBM-DQN algorithm in both the number of migrations and the service interruption rate. When resources are sufficient or moderate, the PPO algorithm maintains a low service interruption rate with minimal migration overhead. However, in resource-scarce conditions, the DQN algorithm significantly increases the number of migrations and the service interruption rate due to frequent adjustments. In contrast, the PPO algorithm effectively reduces these negative impacts through stable policy optimization. These findings indicate that the PPO algorithm offers better efficiency and stability, making it more robust and adaptable in complex network environments.

6.2. Potential Future Research Directions

We assume that the lifecycle of SFC is infinite and do not consider how dynamic arrivals affect network load, migration operations, and service interruption rates. Additionally, the single-objective optimization algorithm we used focuses solely on minimizing the variance of system computation and storage resources to balance the network load. Although reducing the number of migrations and controlling service interruption rates have significantly improved the efficiency and stability of network resource management, we have not specifically modeled or deeply analyzed the time costs and resource overhead of migration operations. Future research should address SFCs with dynamic lifecycles and develop detailed models for migration costs and energy consumption [19]. Furthermore, it should explore multi-objective optimization methods to achieve a comprehensive optimization of resource utilization efficiency, service quality, and energy consumption.