Skip to end of metadata
Go to start of metadata

This page documents how to build a CORD POD on physical hardware. It also documents how to build a virtual CORD development environment on a single server. We call this virtualized version CORD-in-a-Box. (An alternative testing environment, called CORD-in-the-Cloud is also available for evaluation.)

Our approach follows best practices in DevOps, with the goal of supporting Continuous Integration / Continuous Delivery (CI/CD). As a consequence, the process involves a full build from source. Expect it to take a while (there are many components to download), but in return for your patience, you will have a complete development environment going forward.

Check the Troubleshooting page for any issues you encounter during the build process.

Release

There are two releases of CORD:

The most recent development branch is master.

Overview

Building a POD is a multi-stage/multi-layer process, where each stage/layer corresponds to a different repository. There are also small variations depending on whether you are building a full POD or CORD-in-a-Box.

Stage/LayerRepositoryFull PODCORD-in-a-Box
Build Master: Drive the build/deploy/test process (using Gradle) from a single entry point.https://github.com/opencord/cordEntry point for the build process; see docs/quickstart_physical.md for instructions.Entry point for the build process; see docs/quickstart.md  for instructions.
Boot Hardware: Install base OS on servers and switches; set up Maven, Docker, and Glance registries.

https://github.com/opencord/maas

Automatically kicked off by Gradle; check here for more info about maas internals and here for troubleshooting hints.

Manually install Ubuntu LTS 14.04.
Install Platform: Install core platform software (XOS, ONOS, OpenStack) in VMs/containers.

https://github.com/opencord/platform-install

Previous stage automatically initiates platform install.

Automatically kicked off by Gradle; check here for info about platform-install internals.

On-Board Services: Configure XOS and bring up service graph.

https://github.com/opencord/service-profile

Previous stage automatically initiates service on-boarding with a service graph configured for the ON.Lab POD; manual customization is required for other environments (see below).

Previous stage automatically initiates service on-boarding with default service graph.

The rest of this page focuses on the full POD, where the first three stages are well-defined, but the final stage (described in the "Customize the POD" section) requires the developer to take other manual steps to integrate the POD into their local environment. 

Note that the full POD installation process also makes it possible to boot a POD as a set of VMs on a single physical machine (see docs/quickstart_vm.md), but this is not (yet) equivalent to the single node case, due to a lack of support for nested virtualization. This variant is useful for working on the MaaS machinery, but it is not currently integrated with the platform install or service on-boarding stages.

Configure the CORD Platform

The first step is to bring up the CORD Platform, which includes a cluster of commodity servers and white-box switches running the CORD software stack. Specific access devices (e.g., OLT blades) are not considered part of the platform, and are brought up separately during the following customization step.

Hardware Bill-of-Materials

Servers – OCP-qualified QuantaGrid D51B-1U server. Each server is configured with 2x Intel E5-2630 v4 10C 2.2GHz 85W, 64GB of RAM 2133MHz DDR4, 2x hdd500GB and a 40 Gig adapter: Intel Ethernet Converged Network Adapters XL710 10/40 GbE PCIe 3.0, x8 Dual port.

Switches – OCP-qualified Accton 6712 switch. Each switch is configured with 32x40GE ports, and can double as both leaf and spine switches in the CORD fabric.

The reference POD includes four servers (one serving as a head node and three serving as compute nodes), two virtual racks with one leaf (ToR) switch each, and two spine switches connecting the (virtual) racks. Alternative configurations are also possible (e.g., more head nodes, additional racks, two ToR per rack).

POD Assembly

Servers and switches in the reference POD are wired as follows:

As POD assembly involves local specifics, you will need to manually edit a handful of configuration files (as instructed in docs/quickstart_physical.md). In preparation for doing that, it will be helpful to familiarize yourself with the network sub-system, including

Install CORD Software

Building and installing the CORD software stack is kicked off by Gradle from the uber cord respository. It's a mostly automated process, but internally involves three steps. The first step uses MaaS to boot Ubuntu on the bare metal. The second step brings up VMs running OpenStack, XOS, and ONOS. The third on-boards services into XOS.

  • Configure Service Graph – The previous step automatically initiates the on-boarding process by invoking the following commands:
    • cd service-profile/cord-pod; make; make vtn; make fabric; make cord

Customize the POD

After booting the base platform, the next step is to configure the POD for the local environment. This is currently a manual process that includes:

 

  • No labels