文章目录
概要
edge
何为边缘计算？
边缘计算（英语：Edge computing），是一种分布式计算的架构，将应用程序、数据资料与服务的计算，由网络中心节点，移往网络逻辑上的边缘节点来处理。边缘计算将原本完全由中心节点处理大型服务加以分解，切割成更小与更容易管理的部分，分散到边缘节点去处理。边缘节点更接近于用户终端设备，可以加快资料的处理与发送速度，减少延迟。在这种架构下，资料的分析与知识的产生，更接近于数据资料的来源，因此更适合处理大数据。[1]
现阶段，企业使用边缘计算
作为一种战略，边缘计算会将统一的环境从核心数据中心一直扩展到用户和数据附近的物理位置。通过采用混合云战略，企业可以在自己的数据中心和公共云基础架构（如 Amazon Web Services、Microsoft Azure 或 Google Cloud ）上运行相同的工作负载，同样地，边缘战略则将云环境扩展到更多地方。
如今，边缘计算已广泛用于许多行业，包括电信、制造、运输、公用事业等。同样地，企业实施边缘计算的原因也各不相同。[2]
边缘计算3.0
相对云计算
✔其实如果说云计算是集中式大数据处理，边缘计算则可以理解为边缘式大数据处理。
但不同的是，只是这一次，数据不用再传到遥远的云端，在边缘侧就能解决。
✔边缘计算更适合实时的数据分析和智能化处理，相较单纯的云计算也更加高效而且安全！
边缘计算和云计算两者实际上都是处理大数据的计算运行的一种方式。
边缘计算更准确的说应该是对云计算的一种补充和优化！[3]
整体架构流程
edge
边缘网络组件
边缘网络（Edge Network）的组件可以根据其功能和用途进行分类，通常包括以下主要部分：
-
边缘节点（Edge Nodes）：
- 边缘节点是位于靠近数据源或用户的设备，负责处理和存储数据，以减少延迟并优化带宽。边缘节点可能是边缘服务器、路由器、网关、物联网设备、智能传感器等。
-
边缘网关（Edge Gateway）：
- 边缘网关用于在边缘节点和云端之间实现数据通信和协议转换。它连接本地设备和更大范围的网络，提供数据聚合、协议转换和安全管理功能。
-
网络设备（Network Devices）：
- 这些设备包括交换机、路由器、负载均衡器等，负责网络流量的管理和数据的路由。在边缘网络中，网络设备负责管理边缘节点之间和边缘与云端之间的数据传输。
-
边缘计算平台（Edge Computing Platform）：
- 边缘计算平台是用于在边缘设备上运行应用程序和分析任务的软件平台。这些平台可以包括边缘计算框架（如K3s、KubeEdge）和其他边缘计算软件，以便在靠近数据源的位置进行数据处理。
-
存储组件（Storage Components）：
- 边缘存储设备用于本地存储数据，以减轻云存储的压力。它可以包括固态硬盘（SSD）、硬盘驱动器（HDD）等，以快速访问和处理数据。
-
安全组件（Security Components）：
- 边缘网络的安全组件负责对数据传输和存储的保护，包括防火墙、入侵检测和防御系统、虚拟专用网络（VPN）等，以防止数据泄漏和攻击。
-
边缘应用（Edge Applications）：
- 边缘应用程序在边缘节点上运行，以提供更快的用户响应和本地处理功能。典型的边缘应用包括物联网（IoT）数据分析、视频处理、智能制造控制等。
-
边缘控制器（Edge Controllers）：
- 边缘控制器通常用于管理和协调边缘节点的计算资源与任务调度。边缘控制器可以根据不同任务的需求在边缘网络中动态分配计算和存储资源。
这些组件共同作用，提供边缘计算能力，将计算和存储资源下沉至靠近数据源的位置，从而优化网络性能、降低延迟和减轻中心云端的负载。
边缘计算与云安全
边缘安全是对存储或处理在网络边缘的数据的保护。
数据通常存储在一个集中的位置，如数据中心或云。而在边缘计算中，数据被处理并保持在更接近收集地点的位置。这有几个优点，例如减少延迟和增加可靠性和弹性。然而，它也带来了新的安全挑战。这些风险包括：
● 数据丢失：作为与边缘计算相关的最大风险之一，如果设备丢失或被盗，或者损坏或损坏，则可能会发生数据丢失。
● 数据泄露：如果设备没有妥善保护或被黑客攻击，就可能发生数据泄露。
● 性能问题：如果没有足够的可用带宽，或者有太多的设备访问相同的数据，就会出现性能问题。
研究方向结合
边缘安全参考框架
结合SDN（软件定义网络）与机器学习的边缘计算是一个非常热门的研究方向。通过利用机器学习的能力，SDN 可以更智能地控制网络流量，优化资源利用，并提高网络服务的质量。以下是一个简单的 Python 示例，演示如何结合 SDN 和机器学习来做一些智能化的网络流量优化：
python
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import MAIN_DISPATCHER, set_ev_cls
from ryu.ofproto import ofproto_v1_3
class SDN_MachineLearning_Controller(app_manager.RyuApp):
OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
def __init__(self, *args, **kwargs):
super(SDN_MachineLearning_Controller, self).__init__(*args, **kwargs)
# Load or generate dataset
self.dataset = pd.read_csv("network_traffic_data.csv")
self.model = self.train_ml_model()
def train_ml_model(self):
# Prepare dataset for training
features = self.dataset[['src_ip', 'dst_ip', 'packet_count', 'byte_count']]
labels = self.dataset['traffic_class']
X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)
# Train a random forest regressor model
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
return model
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def packet_in_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
# Extract information from packet-in message
pkt = msg.data
src_ip, dst_ip = self.extract_ip(pkt)
packet_count = len(pkt)
byte_count = msg.total_len
# Prepare data for prediction
feature_data = np.array([[src_ip, dst_ip, packet_count, byte_count]])
predicted_class = self.model.predict(feature_data)
# Install flow rule based on predicted class
if predicted_class == 1: # Example: if traffic class indicates high priority
actions = [parser.OFPActionOutput(ofproto.OFPP_HIGH_PRIORITY)]
else:
actions = [parser.OFPActionOutput(ofproto.OFPP_NORMAL)]
match = parser.OFPMatch(in_port=msg.match['in_port'], eth_dst=dst_ip)
self.add_flow(datapath, match, actions)
# Forward packet to the appropriate port
out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id, in_port=msg.match['in_port'],
actions=actions, data=msg.data)
datapath.send_msg(out)
def add_flow(self, datapath, match, actions):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
# Add a flow entry with specific match and actions
inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
mod = parser.OFPFlowMod(datapath=datapath, priority=1, match=match, instructions=inst)
datapath.send_msg(mod)
def extract_ip(self, packet):
# Extract source and destination IP from packet
# Placeholder for demonstration
return "192.168.1.1", "192.168.1.2"
if __name__ == "__main__":
# This script is meant to be run as part of a Ryu controller instance
# Use Ryu's `ryu-manager` to run this file
print("Starting SDN Machine Learning Controller")如果需要同时支持IPV4和IPV6的数据包
python
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import MAIN_DISPATCHER, set_ev_cls
from ryu.ofproto import ofproto_v1_3
from ryu.lib.packet import packet, ethernet, ipv4, ipv6, tcp, udp
import joblib
class SDN_MachineLearning_Controller(app_manager.RyuApp):
OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
def __init__(self, *args, **kwargs):
super(SDN_MachineLearning_Controller, self).__init__(*args, **kwargs)
# Load or generate dataset
self.dataset = pd.read_csv("network_traffic_data.csv")
self.model = self.train_ml_model()
self.datapaths = {}
def train_ml_model(self):
# Prepare dataset for training
features = self.dataset[['src_ip', 'dst_ip', 'packet_count', 'byte_count', 'protocol']]
labels = self.dataset['traffic_class']
X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)
# Train a random forest classifier model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
self.logger.info("Model training complete. Accuracy: %.2f%%", accuracy * 100)
# Save the trained model for future use
joblib.dump(model, 'traffic_classifier_model.pkl')
return model
@set_ev_cls(ofp_event.EventOFPSwitchFeatures, MAIN_DISPATCHER)
def switch_features_handler(self, ev):
datapath = ev.msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
# Install the default flow to handle unmatched packets
match = parser.OFPMatch()
actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER, ofproto.OFPCML_NO_BUFFER)]
self.add_flow(datapath, 0, match, actions)
self.datapaths[datapath.id] = datapath
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def packet_in_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
pkt = packet.Packet(msg.data)
eth = pkt.get_protocol(ethernet.ethernet)
ip_pkt_v4 = pkt.get_protocol(ipv4.ipv4)
ip_pkt_v6 = pkt.get_protocol(ipv6.ipv6)
tcp_pkt = pkt.get_protocol(tcp.tcp)
udp_pkt = pkt.get_protocol(udp.udp)
# Ignore LLDP packets
if eth.ethertype == 0x88cc:
return
if ip_pkt_v4:
src_ip = ip_pkt_v4.src
dst_ip = ip_pkt_v4.dst
protocol = ip_pkt_v4.proto
eth_type = eth.ethertype
elif ip_pkt_v6:
src_ip = ip_pkt_v6.src
dst_ip = ip_pkt_v6.dst
protocol = ip_pkt_v6.nxt
eth_type = eth.ethertype
else:
return
packet_count = len(pkt.protocols)
byte_count = msg.total_len
# Prepare data for prediction
feature_data = pd.DataFrame([[src_ip, dst_ip, packet_count, byte_count, protocol]],
columns=['src_ip', 'dst_ip', 'packet_count', 'byte_count', 'protocol'])
try:
predicted_class = self.model.predict(feature_data)[0]
except ValueError as e:
self.logger.error("Prediction error: %s", str(e))
return
# Install flow rule based on predicted class
if predicted_class == 1: # Example: if traffic class indicates high priority
actions = [parser.OFPActionOutput(ofproto.OFPP_TABLE)]
priority = 10
elif predicted_class == 2: # Example: medium priority
actions = [parser.OFPActionOutput(ofproto.OFPP_NORMAL)]
priority = 5
else: # Low priority
actions = [parser.OFPActionOutput(ofproto.OFPP_LOW_PRIORITY)]
priority = 1
match = parser.OFPMatch(in_port=in_port, eth_type=eth_type, ipv4_src=src_ip if ip_pkt_v4 else None, ipv4_dst=dst_ip if ip_pkt_v4 else None,
ipv6_src=src_ip if ip_pkt_v6 else None, ipv6_dst=dst_ip if ip_pkt_v6 else None)
self.add_flow(datapath, priority, match, actions)
# Forward packet to the appropriate port
out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id, in_port=in_port,
actions=actions, data=msg.data)
datapath.send_msg(out)
def add_flow(self, datapath, priority, match, actions, idle_timeout=0, hard_timeout=0):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
# Add a flow entry with specific match and actions
inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
mod = parser.OFPFlowMod(datapath=datapath, priority=priority, match=match,
instructions=inst, idle_timeout=idle_timeout, hard_timeout=hard_timeout)
datapath.send_msg(mod)
def extract_ip(self, packet):
# Extract source and destination IP from packet
ip_pkt_v4 = packet.get_protocol(ipv4.ipv4)
ip_pkt_v6 = packet.get_protocol(ipv6.ipv6)
if ip_pkt_v4:
return ip_pkt_v4.src, ip_pkt_v4.dst
elif ip_pkt_v6:
return ip_pkt_v6.src, ip_pkt_v6.dst
return None, None
if __name__ == "__main__":
# This script is meant to be run as part of a Ryu controller instance
# Use Ryu's `ryu-manager` to run this file
print("Starting SDN Machine Learning Controller")引用
cite
[1]维基百科-边缘计算
[2]一文看懂什么是边缘计算
[3]边缘计算入门指南
[4]边缘安全白皮书