边缘计算的学习

4v1d2024-11-15 9:00

文章目录

概要

edge

何为边缘计算？

边缘计算（英语：Edge computing），是一种分布式计算的架构，将应用程序、数据资料与服务的计算，由网络中心节点，移往网络逻辑上的边缘节点来处理。边缘计算将原本完全由中心节点处理大型服务加以分解，切割成更小与更容易管理的部分，分散到边缘节点去处理。边缘节点更接近于用户终端设备，可以加快资料的处理与发送速度，减少延迟。在这种架构下，资料的分析与知识的产生，更接近于数据资料的来源，因此更适合处理大数据。[1]

现阶段，企业使用边缘计算

作为一种战略，边缘计算会将统一的环境从核心数据中心一直扩展到用户和数据附近的物理位置。通过采用混合云战略，企业可以在自己的数据中心和公共云基础架构（如 Amazon Web Services、Microsoft Azure 或 Google Cloud ）上运行相同的工作负载，同样地，边缘战略则将云环境扩展到更多地方。

如今，边缘计算已广泛用于许多行业，包括电信、制造、运输、公用事业等。同样地，企业实施边缘计算的原因也各不相同。[2]

边缘计算3.0

相对云计算

✔其实如果说云计算是集中式大数据处理，边缘计算则可以理解为边缘式大数据处理。

但不同的是，只是这一次，数据不用再传到遥远的云端，在边缘侧就能解决。

✔边缘计算更适合实时的数据分析和智能化处理，相较单纯的云计算也更加高效而且安全！

边缘计算和云计算两者实际上都是处理大数据的计算运行的一种方式。

边缘计算更准确的说应该是对云计算的一种补充和优化！[3]

整体架构流程

edge

边缘网络组件

边缘网络（Edge Network）的组件可以根据其功能和用途进行分类，通常包括以下主要部分：

  1. 边缘节点（Edge Nodes）：

    • 边缘节点是位于靠近数据源或用户的设备，负责处理和存储数据，以减少延迟并优化带宽。边缘节点可能是边缘服务器、路由器、网关、物联网设备、智能传感器等。

  2. 边缘网关（Edge Gateway）：

    • 边缘网关用于在边缘节点和云端之间实现数据通信和协议转换。它连接本地设备和更大范围的网络，提供数据聚合、协议转换和安全管理功能。

  3. 网络设备（Network Devices）：

    • 这些设备包括交换机、路由器、负载均衡器等，负责网络流量的管理和数据的路由。在边缘网络中，网络设备负责管理边缘节点之间和边缘与云端之间的数据传输。

  4. 边缘计算平台（Edge Computing Platform）：

    • 边缘计算平台是用于在边缘设备上运行应用程序和分析任务的软件平台。这些平台可以包括边缘计算框架（如K3s、KubeEdge）和其他边缘计算软件，以便在靠近数据源的位置进行数据处理。

  5. 存储组件（Storage Components）：

    • 边缘存储设备用于本地存储数据，以减轻云存储的压力。它可以包括固态硬盘（SSD）、硬盘驱动器（HDD）等，以快速访问和处理数据。

  6. 安全组件（Security Components）：

    • 边缘网络的安全组件负责对数据传输和存储的保护，包括防火墙、入侵检测和防御系统、虚拟专用网络（VPN）等，以防止数据泄漏和攻击。

  7. 边缘应用（Edge Applications）：

    • 边缘应用程序在边缘节点上运行，以提供更快的用户响应和本地处理功能。典型的边缘应用包括物联网（IoT）数据分析、视频处理、智能制造控制等。

  8. 边缘控制器（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]边缘安全白皮书

相关推荐
Chef_Chen3 分钟前
从0开始学习机器学习--Day22--优化总结以及误差作业（上）
人工智能·学习·机器学习
Mr.简锋8 分钟前
opencv常用api
人工智能·opencv·计算机视觉
虾球xz19 分钟前
游戏引擎学习第11天
stm32·学习·游戏引擎
心怀梦想的咸鱼21 分钟前
Ue5 umg学习（三）文本控件
学习·ue5
心怀梦想的咸鱼23 分钟前
Ue5 umg学习（二）图像控件，锚点
学习·ue5
DevinLGT37 分钟前
6Pin Type-C Pin脚定义：【图文讲解】
人工智能·单片机·嵌入式硬件
宋一诺3341 分钟前
机器学习—高级优化方法
人工智能·机器学习
龙的爹23331 小时前
论文 | The Capacity for Moral Self-Correction in LargeLanguage Models
人工智能·深度学习·机器学习·语言模型·自然语言处理·prompt
Mr.简锋1 小时前
opencv视频读写
人工智能·opencv·音视频
Baihai_IDP1 小时前
「混合专家模型」可视化指南：A Visual Guide to MoE
人工智能·llm·aigc
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04新版微信小程序获取用户手机号05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10【Flutter】基于 GetX 实现 Dio 的生命周期自动化