diff --git a/src/kubernetes-api/internal/controller/networkedgedevice_controller.go b/src/kubernetes-api/internal/controller/networkedgedevice_controller.go
index 943f23a47ef820fedecc39ba741df676b022e956..56aec14f90a26826d9b556018f58857d784d9dbc 100644
--- a/src/kubernetes-api/internal/controller/networkedgedevice_controller.go
+++ b/src/kubernetes-api/internal/controller/networkedgedevice_controller.go
@@ -174,7 +174,7 @@ func (r *NetworkEdgeDeviceReconciler) createExternalResources(ctx context.Contex
 	if err != nil {
 		return err
 	}
-	nedName := fmt.Sprintf("%s-%s", netEdgeDevice.Spec.NodeConfig.NodeName, netEdgeDevice.Spec.NetworkController.Name)
+	nedName := utils.GetBridgeName(utils.BridgeParams{NodeName: netEdgeDevice.Spec.NodeConfig.NodeName, ProviderName: netEdgeDevice.Spec.NetworkController.Name})
 
 	nedConfig, err := json.Marshal(nedv1.NedSettings{ControllerIP: netEdgeDevice.Spec.NetworkController.Domain, NodeName: netEdgeDevice.Spec.NodeConfig.NodeName, NedName: nedName})
 	if err != nil {
diff --git a/src/kubernetes-api/internal/controller/pod_controller.go b/src/kubernetes-api/internal/controller/pod_controller.go
index 34adae6ba1b4e85abdcc11f37ff3d005851ce10a..fc0ff9f55fbd158947ed086da6b123f65054f1e3 100644
--- a/src/kubernetes-api/internal/controller/pod_controller.go
+++ b/src/kubernetes-api/internal/controller/pod_controller.go
@@ -84,29 +84,27 @@ func (r *PodReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.R
 
 			// If the pod is being deleted, we should free the interface, both the net-attach-def crd and the openflow port.
 			// This is done for each interface in the pod.
-			multusAnnotations, ok := pod.Annotations[MULTUS_ANNOTATION_KEY]
+			// multusAnnotations, ok := pod.Annotations[MULTUS_ANNOTATION_KEY]
 
-			if !ok {
-				logger.Error(nil, "Error detaching the pod from the network attachment definitions")
-				return ctrl.Result{}, nil
-			}
+			// if !ok {
+			// 	logger.Error(nil, "Error detaching the pod from the network attachment definitions")
+			// }
 
-			multusNetAttachDefinitions, err := extractNetworks(pod.Annotations[multusAnnotations], r.SwitchesNamespace)
+			// multusNetAttachDefinitions, err := extractNetworks(pod.Annotations[multusAnnotations], r.SwitchesNamespace)
 
-			if err != nil {
-				logger.Error(nil, "Error detaching the pod from the network attachment definitions")
-				return ctrl.Result{}, nil
-			}
+			// if err != nil {
+			// 	logger.Error(nil, "Error detaching the pod from the network attachment definitions")
+			// }
 
-			for _, multusNetAttachDef := range multusNetAttachDefinitions {
+			// for _, multusNetAttachDef := range multusNetAttachDefinitions {
 
-				fmt.Println(multusNetAttachDef)
-				// We liberate the specific attachment from the node, so it can be used again
-				//r.DetachNetAttachDef(ctx, multusNetAttachDef, r.SwitchesNamespace)
+			// 	fmt.Println(multusNetAttachDef)
+			// 	// We liberate the specific attachment from the node, so it can be used again
+			// 	//r.DetachNetAttachDef(ctx, multusNetAttachDef, r.SwitchesNamespace)
 
-				// We liberate the port in the onos app
-				//r.InternalClient.DetachPodFromNetwork("vnet",multusNetAttachDef)
-			}
+			// 	// We liberate the port in the onos app
+			// 	//r.InternalClient.DetachPodFromNetwork("vnet",multusNetAttachDef)
+			// }
 
 			// Remove our finalizer from the list and update it.
 			pod.SetFinalizers(utils.RemoveString(pod.GetFinalizers(), l2smFinalizer))
@@ -191,27 +189,41 @@ func (r *PodReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.R
 				logger.Error(err, "Error attaching pod to the l2network")
 				return ctrl.Result{}, nil
 			}
-
 			// If the L2Network is of type inter-domain (has a provider), attach the associated NED
 			// and communicate with it
 			if network.Spec.Provider != nil {
-
+				logger.Info("Attaching pod to the external sdn controller")
 				// First we get information from the NED, required to perform the next operations.
 				// The info we need is the node name it is residing in.
-				nedNodeName := nedinterface.GetNodeName(network.Spec.Provider.Name)
+				ned, err := nedinterface.GetNetworkEdgeDevice(ctx, r.Client, network.Spec.Provider.Name)
 
+				if err != nil {
+					fmt.Printf("error getting NED: %v", err)
+					return ctrl.Result{}, nil
+
+				}
 				// Then, we create the connection between the NED and the l2sm-switch, in the internal SDN Controller
-				nedNetworkAttachDef, err := r.ConnectInternalSwitchToNED(ctx, network.Name, nedNodeName)
+				nedNetworkAttachDef, err := r.ConnectInternalSwitchToNED(ctx, network.Name, ned.Spec.NodeConfig.NodeName)
 				if err != nil {
+					fmt.Printf("error connecting NED: %v", err)
 					return ctrl.Result{}, nil
 				}
 				// We attach the ned to this new network, connecting with the IDCO SDN Controller. We need
 				// The Network name so we can know which network to attach the port to.
 				// The multus network attachment definition that will be used as a bridge between the internal switch and the NED.
-				err = r.CreateNewNEDConnection(network, nedNetworkAttachDef.Name, nedNodeName)
+				bridgeName, err := utils.GetPortNumberFromNetAttachDef(nedNetworkAttachDef.Name)
 				if err != nil {
+					// If there is an error, it must be that the name is not compliant, so we can't be certain of which
+					// port we are trying to attach.
+					return ctrl.Result{}, fmt.Errorf("could not get port number from the multus network annotation: %v. Can't attach pod to network", err)
+				}
+				err = r.CreateNewNEDConnection(network, fmt.Sprintf("br%s", bridgeName), ned)
+				if err != nil {
+					fmt.Printf("error attaching NED to the l2network: %v", err)
+
 					return ctrl.Result{}, nil
 				}
+				logger.Info("Connected pod to inter-domain network")
 
 			}
 		}
@@ -239,10 +251,11 @@ func (r *PodReconciler) SetupWithManager(mgr ctrl.Manager) error {
 }
 
 // CreateNEDConnection is a method that given the name of the network and the
-func (r *PodReconciler) CreateNewNEDConnection(network l2smv1.L2Network, nedNetworkAttachDef, nedNodeName string) error {
+func (r *PodReconciler) CreateNewNEDConnection(network l2smv1.L2Network, nedNetworkAttachDef string, ned l2smv1.NetworkEdgeDevice) error {
 
-	clientConfig := sdnclient.ClientConfig{BaseURL: fmt.Sprintf("http://%s/onos/v1", network.Spec.Provider.Domain), Username: "karaf", Password: "karaf"}
+	clientConfig := sdnclient.ClientConfig{BaseURL: fmt.Sprintf("http://%s/onos", network.Spec.Provider.Domain), Username: "karaf", Password: "karaf"}
 
+	fmt.Println(clientConfig)
 	externalClient, err := sdnclient.NewClient(sdnclient.InternalType, clientConfig)
 
 	if err != nil {
@@ -251,16 +264,16 @@ func (r *PodReconciler) CreateNewNEDConnection(network l2smv1.L2Network, nedNetw
 	}
 	// AddPort returns the port number to attach so we can talk directly with the IDCO
 	// It needs to know which exiting interface to add to the network
-	nedPortNumber, err := nedinterface.AttachInterface(nedNetworkAttachDef)
+	nedPortNumber, err := nedinterface.AttachInterface(fmt.Sprintf("%s:50051", ned.Spec.NodeConfig.IPAddress), nedNetworkAttachDef)
 
 	if err != nil {
-		return fmt.Errorf("no connection could be made with external sdn controller: %s", err)
+		return fmt.Errorf("no connection could be made with ned: %v", err)
 	}
 
-	nedOFID := fmt.Sprintf("of:%s", utils.GenerateDatapathID(fmt.Sprintf("%s-%s", nedNodeName, network.Spec.Provider.Name)))
+	nedOFID := fmt.Sprintf("of:%s", utils.GenerateDatapathID(utils.GetBridgeName(utils.BridgeParams{NodeName: ned.Spec.NodeConfig.NodeName, ProviderName: network.Spec.Provider.Name})))
 	nedOFPort := fmt.Sprintf("%s/%s", nedOFID, nedPortNumber)
 
-	err = externalClient.AttachPodToNetwork("vnets", sdnclient.VnetPortPayload{NetworkId: network.Name, Port: []string{nedOFPort}})
+	err = externalClient.AttachPodToNetwork(network.Spec.Type, sdnclient.VnetPortPayload{NetworkId: network.Name, Port: []string{nedOFPort}})
 	if err != nil {
 		return errors.Join(err, errors.New("could not update network attachment definition"))
 
diff --git a/src/kubernetes-api/internal/nedinterface/nedinterface.go b/src/kubernetes-api/internal/nedinterface/nedinterface.go
index 6c5708660c9f2f9150738bf2fa3b4f200925ad02..09c8364c6322e132e9f992cfc5656affa11c4a39 100644
--- a/src/kubernetes-api/internal/nedinterface/nedinterface.go
+++ b/src/kubernetes-api/internal/nedinterface/nedinterface.go
@@ -3,22 +3,18 @@ package nedinterface
 import (
 	"context"
 	"fmt"
-	"os"
 	"time"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 
+	l2smv1 "l2sm.k8s.local/controllermanager/api/v1"
 	nedpb "l2sm.local/ovs-switch/pkg/nedpb"
 )
 
 // GetConnectionInfo communicates with the NED via gRPC and returns the InterfaceNum and NodeName.
-func AttachInterface(nedNetworkAttachDef string) (string, error) {
-	// Get the NED address (e.g., from environment variable or configuration)
-	nedAddress := os.Getenv("NED_ADDRESS")
-	if nedAddress == "" {
-		nedAddress = "localhost:50051" // default address
-	}
+func AttachInterface(nedAddress, nedNetworkAttachDef string) (string, error) {
 
 	// Set up a connection to the server.
 	client, err := grpc.NewClient(nedAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
@@ -47,7 +43,20 @@ func AttachInterface(nedNetworkAttachDef string) (string, error) {
 	return fmt.Sprint(attachRes.GetInterfaceNum()), nil
 }
 
-// TODO
-func GetNodeName(providerName string) string {
-	return ""
+func GetNetworkEdgeDevice(ctx context.Context, c client.Client, providerName string) (l2smv1.NetworkEdgeDevice, error) {
+	neds := &l2smv1.NetworkEdgeDeviceList{}
+
+	if err := c.List(ctx, neds); err != nil {
+		return l2smv1.NetworkEdgeDevice{}, fmt.Errorf("failed to list NetworkEdgeDevices: %w", err)
+	}
+
+	for _, ned := range neds.Items {
+		if ned.Spec.NetworkController.Name == providerName {
+			// Return the first matching device
+			return ned, nil
+		}
+	}
+
+	// Return a clearer message indicating the provider was not found.
+	return l2smv1.NetworkEdgeDevice{}, fmt.Errorf("no NetworkEdgeDevice found for provider: %s", providerName)
 }