crea un controlador ryu que tenga las siguientes reglas: Configuración de Reglas por VLAN​: VLAN 10: Aislamiento completo (bloqueo de tráfico externo). VLAN 20: Comunicación permitida con VLAN 30. VLAN 30: Comunicación permitida con VLAN 20. Configuración de QoS​: Prioridades de tráfico: Alta prioridad: 150 Mbps (para VoIP). Prioridad media: 100 Mbps (para tráfico HTTP). Baja prioridad: 50 Mbps (para tráfico general). Manejo de ACLs y Reglas de Control​: Bloqueo de tráfico externo para VLAN 10. Permitir comunicación entre VLAN 20 y VLAN 30. Identificación y gestión de tráfico por tipo (VoIP, HTTP, general). Función add_flow: Agrega flujos con prioridad específica y acciones determinadas.

Aquí te muestro un ejemplo de cómo podrías implementar un controlador Ryu con las reglas que mencionaste:

```python
from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import MAIN_DISPATCHER, DEAD_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_3
from ryu.lib.packet import packet
from ryu.lib.packet import ethernet
from ryu.lib.packet import vlan
from ryu.lib.packet import ipv4
from ryu.lib.packet import tcp
from ryu.lib.packet import udp
from ryu.lib.packet import icmp
from ryu.lib import hub

class Controlador(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

    def __init__(self, *args, **kwargs):
        super(Controlador, self).__init__(*args, **kwargs)
        self.mac_to_port = {}
        self.flujos = {}

    @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

        match = parser.OFPMatch()
        actions = [parser.OFPActionOutput(ofproto.OFPORT_ALL)]
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]

        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

    def add_flow(self, datapath, priority, match, actions, buffer_id=None):
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        if buffer_id:
            mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
                                    match=match, instructions=inst, buffer_id=buffer_id)
        else:
            mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
                                    match=match, instructions=inst)
        datapath.send_msg(mod)

    @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

        pkt = packet.Packet(msg.data)
        eth = pkt.get_protocol(ethernet.ethernet)
        vlan = pkt.get_protocol(vlan.vlan)
        ipv4_pkt = pkt.get_protocol(ipv4.ipv4)
        tcp_pkt = pkt.get_protocol(tcp.tcp)
        udp_pkt = pkt.get_protocol(udp.udp)
        icmp_pkt = pkt.get_protocol(icmp.icmp)

        if vlan:
            vlan_id = vlan.vlan_id
        else:
            vlan_id = 0

        if ipv4_pkt:
            src_ip = ipv4_pkt.src
            dst_ip = ipv4_pkt.dst
        else:
            src_ip = None
            dst_ip = None

        if tcp_pkt:
            src_port = tcp_pkt.src_port
            dst_port = tcp_pkt.dst_port
        elif udp_pkt:
            src_port = udp_pkt.src_port
            dst_port = udp_pkt.dst_port
        else:
            src_port = None
            dst_port = None

        if icmp_pkt:
            icmp_type = icmp_pkt.type
        else:
            icmp_type = None

        match = parser.OFPMatch(eth_dst=eth.dst, eth_src=eth.src, vlan_id=vlan_id,
                                ipv4_src=src_ip, ipv4_dst=dst_ip, tcp_src=src_port,
                                tcp_dst=dst_port, udp_src=src_port, udp_dst=dst_port,
                                icmp_type=icmp_type)

        if vlan_id == 10:
            actions = [parser.OFPActionOutput(ofproto.OFPORT_ALL)]
            self.add_flow(datapath, 0, match, actions)
        elif vlan_id == 20:
            if dst_ip in ['10.0.0.1', '10.0.0.2']:
                actions = [parser.OFPActionOutput(ofproto.OFPORT_ALL)]
                self.add_flow(datapath, 0, match, actions)
            else:
                actions = []
                self.add_flow(datapath, 0, match, actions)
        elif vlan_id == 30:
            if src_ip in ['10.0.0.1', '10.0.0.2']:
                actions = [parser.OFPActionOutput(ofproto.OFPORT_ALL)]
                self.add_flow(datapath, 0, match, actions)
            else:
                actions = []
                self.add_flow(datapath, 0, match, actions)

        if src_ip and dst_ip:
            if src_ip.startswith('10.0.0.') and dst_ip.startswith('10.0.0.'):
                if src_port == 5060 or dst_port == 5060:
                    actions = [parser.OFPActionOutput(ofproto.OFPORT_ALL)]
                    self.add_flow(datapath, 1, match, actions)
                elif src_port == 80 or dst_port == 80:
                    actions = [parser.OFPActionOutput(ofproto.OFPORT_ALL)]
                    self.add_flow(datapath, 2, match, actions)
                else:
                    actions = []
                    self.add_flow(datapath, 0, match, actions)
            else:
                actions = []
                self.add_flow(datapath, 0, match, actions)

        actions = []
        self.add_flow(datapath, 0, match, actions)

    def configurar_reglas(self):
        datapath = self.datapaths[0]
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        match = parser.OFPMatch(eth_dst='ff:ff:ff:ff:ff:ff')
        actions = [parser.OFPActionOutput(ofproto.OFPORT_ALL)]
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_dst='00:00:00:00:00:01', vlan_id=10)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_dst='00:00:00:00:00:02', vlan_id=20)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_dst='00:00:00:00:00:03', vlan_id=30)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_dst='00:00:00:00:00:01', vlan_id=20)
        actions = [parser.OFPActionOutput(ofproto.OFPORT_ALL)]
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_dst='00:00:00:00:00:02', vlan_id=30)
        actions = [parser.OFPActionOutput(ofproto.OFPORT_ALL)]
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=10)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=20)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=30)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=10, ip_proto=6, tcp_dst=5060)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=1,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=10, ip_proto=6, tcp_src=5060)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=1,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=10, ip_proto=6, tcp_dst=80)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=2,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=10, ip_proto=6, tcp_src=80)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=2,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=10, ip_proto=1)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=20, ip_proto=6, tcp_dst=5060)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=1,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=20, ip_proto=6, tcp_src=5060)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=1,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=20, ip_proto=6, tcp_dst=80)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=2,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=20, ip_proto=6, tcp_src=80)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=2,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=20, ip_proto=1)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

        match = parser.OFPMatch(eth_type=0x0800, vlan_id=30, ip_proto=6, tcp_dst=5060)
        actions = []
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(dat