Service

Replace an end-of-life network controller in planned stages, with the network in service

We move networks off an SDN controller or orchestrator that is losing support, such as Tungsten Fabric or Contrail, onto a target chosen to what you use it for. Old and new run side by side while workloads move in waves. Our engineers have built Tungsten Fabric integrations for OpenStack, OpenShift and SmartNICs, and a custom ONOS control plane in production.

Our controller engineering, measured

What changes for your organization

  • Today

    A controller with no future

    The controller the network depends on gets no new releases, fixes or security patches, and every month on it adds risk.

    With a planned migration

    A supported foundation

    The network runs on a controller or stack with an active roadmap, patches and people who know it.

  • Today

    A move that looks all-or-nothing

    Overlays, policies and every workload hang on one controller, so replacing it reads as one risky cut-over.

    With a planned migration

    A move in planned stages

    Old and new controllers run side by side, and workloads move in waves you schedule, with the network in service.

  • Today

    Features with no obvious successor

    Service chaining, multi-tenancy, analytics and integrations with OpenStack or Kubernetes rarely map one to one onto a single new product.

    With a planned migration

    Every function accounted for

    Each function you use has a home in the target, from an open-source stack, a commercial product or an extension we build.

  • Today

    Know-how that has thinned out

    The people who built the SDN layer have moved on, and the community that supported it has gone quiet.

    With a planned migration

    A team that owns the result

    The target is documented and handed over, and your engineers run it with our support for as long as you want it.

  • Today

    A decision under time pressure

    The replacement gets picked from datasheets, late in the support window, when there is little time left to test it.

    With a planned migration

    A choice on tested results

    Candidate targets are tested in a lab on your topology and workloads before you commit.

What we deliver

  • Inventory of what the controller does

    Every function the network uses today mapped: overlays, policies, service chains, tenants, analytics, and the integrations with your orchestrators.

  • Target choice and proof of concept

    Candidate targets compared on your requirements, and the shortlisted one proved in a lab with automated functional and performance tests.

    Read the case study →
  • Integration with your orchestrators

    The target wired into OpenStack through ML2 or into Kubernetes and OpenShift through CNI and operators, with CI changes and automated tests.

    Read the case study →
  • Gaps closed in code

    Where the target lacks a function you rely on, we build it: missing device adapters, forwarding apps, plugins and UI components.

    Read the case study →
  • Migration in waves

    Old and new controllers under one management point while compute nodes and workloads move in scheduled waves, each checked before the next.

    Read the case study →
  • Decommission and handover

    The old controller retired once the last workload has moved, and the new one documented and handed to your team, with our support after.

How it runs

The order stays the same whatever the source and target; the scope scales with the estate and the functions you use.

  1. Discovery

    What the controller does in your network today, the target architecture, and a migration plan with its waves.

  2. Proof of concept

    The shortlisted target proved in a lab on your topology, with the extensions it needs confirmed and tested.

  3. Build and integration

    The target built as code, integrated with OpenStack, Kubernetes or OpenShift, and the missing functions developed.

  4. Coexistence

    Old and new controllers run side by side under one management point, with policies carried across.

  5. Migration

    Workloads and compute nodes moved in waves, each validated by automated tests before the next begins.

  6. Decommission and support

    The old controller retired, your team trained on the new one, and our support for as long as you want it.

The target fits what you use the controller for

Often no single product covers every function the old controller had. The discovery maps each function to one of these.

  • An open-source stack

    Open-source SDN components, such as ONOS or OpenStack Neutron with ML2 drivers, combined to cover your functions.

  • A commercial controller

    A supported product, when vendor support and a roadmap lead the decision.

  • Kubernetes-native networking

    CNI plugins and operators, when the workloads have moved or are moving to Kubernetes and OpenShift.

  • Extended in code

    A target of any kind, with the functions it lacks built by us: adapters, forwarding apps, plugins and drivers.

Proof

The engineering a controller migration rests on, from our projects: integrations, coexistence, custom control planes and test labs.

Why CodiLime

  • Tungsten Fabric from the inside

    We have extended the Tungsten Fabric vRouter, written its CNI and its OpenShift operator, and offloaded its data plane to SmartNICs, so we know what a network on it depends on.

  • Controllers side by side

    We ran OVS, SR-IOV and vRouter workloads under one OpenStack management point and live migrated computes between them: the pattern a staged migration uses.

  • Controller changes in production

    For a telco we automated SDN controller upgrades across tens of Tungsten Fabric and OpenStack telco clouds, with pre- and post-checks, database backup and rollback.

FAQ

Good to know

  • Have you migrated a network off Tungsten Fabric before?

    Our record is the engineering a migration rests on: Tungsten Fabric integrations with OpenStack, OpenShift and SmartNICs, coexistence and live migration through ML2, and a custom ONOS control plane in production. The migration itself runs on that experience, with a proof of concept first.

  • Can the network stay in service during the move?

    That is how the work is planned. The old and new controllers run side by side, and workloads move in waves, each tested before the next.

  • What do we move to?

    It depends on what you use the controller for. The discovery maps each function to an open-source stack, a commercial product, Kubernetes-native networking or an extension we build, and the proof of concept tests the choice.

  • What if the target lacks a feature we rely on?

    We build it. On our ONOS project we wrote the missing device adapters, forwarding apps and UI components, and took them to production.

  • Who runs the network afterwards?

    Your team, with the target documented and built as code. We stay on for support and extensions for as long as you want us to.

Start with a controller assessment

Tell us which controller your network runs on and what it does for you. We map its functions, weigh the targets, and hand you a target architecture and a migration plan in waves.