Offline Install

Often, CORD PODs' (management networks) don't have access to Internet.

This section of the guide provides guidelines, best-practices and examples to deploy the CORD/SEBA software without Internet connectivity.

NOTE: The guide assumes that the Operating Systems (both on servers and on network devices) and Kubernetes are already installed and running.

The offline installation is useful

  • When the CORD POD has no access to Internet, so artifacts used for the installation (i.e. Docker images) cannot be downloaded directly to the POD.

  • While developing, you may want to test your changes pushing artifacts to the POD, before uploading them to the official docker repository.

Target Infrastructure, requirements overview

Your target infrastructure (where the POD runs) needs

  • A local Docker Registry where to push your Docker images (previously pulled from the web). If you don't have one, follow the notes below to deploy with helm a local Docker registry on top of your existing Kubernetes cluster.

More informations about docker registries can be found at

  • A local webserver to host the ONOS applications (.oar files), that are instead normally downloaded from Sonatype. If you don't have one, follow the notes below to quickly deploy a webserver on top of your existing Kubernetes cluster.

  • Kubernetes servers default gateway: In order for kube-dns to work, a default route (even pointing to a non-exisiting/working gateway) needs to be set on the machines hosting Kubernetes. This is something related to Kubernetes, not to CORD.

Prepare the offline installation

This should be done from a machine that has access to Internet.

  • Clone the helm-charts repository
git clone

Next steps largely depend on the type of profile you want to install.

  • Add external helm repositories and pull external dependencies.

  • Fetch helm-charts not available locally.

  • Modify the CORD helm charts to instruct kubernetes to pull the images from your local registry (where images will be pushed), instead of DockerHub. One option is to modify the values.yaml in each chart. A better option consists in extending the charts, rather than directly modifying them. This way, the original configuration can be kept as is, just overriding some values as needed. You can do this by writing your additional configuration yaml file, and parsing it as needed, adding -f my-additional-config.yml while using the helm install/upgrade commands. The full CORD helm charts reference documentation is available here.

  • Download the ONOS applications (OAR files). Informations about the oar applications used can be found here:

  • Pull from DockerHub all the Docker images that need to be used on your POD. The automation-tools repository has a utility inside the developer folder that can help you to get all the image names given the helm-chart repository and a list of chart names. More informations in the sections below.

  • Override the default helm chart values for the ONOS applications download links, pointing them to the HTTP addresses of the files, once they'll be on your local web server.

  • Optionally download the OpenOLT driver deb files from your vendor website (i.e. EdgeCore).

  • Optionally, save as tar files the Docker images downloaded. This can be useful if you'll use a different machine to upload the images on the local registry running in your infrastructure. To do that, for each image use the Docker command.

docker save IMAGE_NAME:TAG > FILE_NAME.tar
  • If the artifacts need to be deployed to the target infrastructure from a different machine, save the helm-charts directory, the ONOS applications, the docker images downloaded and the additional helm charts variable extension file.

Deploy the artifacts to your infrastructure and install CORD/SEBA

This should not require any Internet connectivity. To deploy the artifacts to your POD, do the following from machine that has access to your Kubernetes cluster:

  • Optionally, if at the previous step you saved the Docker images on an external hard drive as .tar files, restore them in the deployment machine Docker registry. For each image (file), use the docker command
docker load < FILE_NAME.tar
  • Tag and push your Docker images to the local Docker registry running in your infrastructure. More info on this can be found in the paragraph below.

  • Copy the ONOS applications to your local web server. The procedure largely varies from the web server you run, its configuration, and what ONOS applications you need.

  • Deploy CORD/SEBA using the helm charts. Remember to load with the -f option the additional configuration file to extend the helm charts, if any.

Tag and Push Images to the Docker Registry

For the images to be consumed on the Kubernetes cluster, they need to be first tagged, and pushed to the local registry:

Supposing your docker-registry address is:

and that your original image name is called:


you'll need to tag the image as

For example, you can use the docker tag command to do this:

docker tag xosproject/vsg-synchronizer:candidate

Now, you can push the image to the registry. For example, with docker push:

docker push

The image should now be in the local docker registry on your cluster.

Identify, download, tag and push images

Sometimes you may need to identify, download, tag and push lots of images. This can become a long and error prone operation if done manually. For this reason, we provide a set of tool that automate procedure. The script can be found here. identify images

The script prints the list of images used by one or multiple charts. The script needs to be executed from the helm-charts directory. More info can be found invoking the -h or --help option of the command. The output can be piped in other utility scripts. pull images from DockerHub

The script pulls from DockerHub the list of images provided in input and prints the image name if the image is correctly pulled. More info can be found invoking the -h or --help option of the command. The output can be piped in other utility scripts. tag and push images to a target Docker registry

The script tags and push images to a target Docker registry (including DockerHub itself). It can add a prefix (useful for example when deploying on local registries) to images and change the tag of an image. More info can be found invoking the -h or --help option of the command. The output can be piped in other utility scripts.


Assume you'd like to prepare an offline SEBA installation. As such, you need to identify all the images used in the charts, download them, tag them and push them to a local Docker registry (in the example,, port 30500). From the helm-charts folder, this can be done in one command:

bash voltha onos xos-core xos-profiles/att-workflow nem-monitoring logging | bash | bash -r

Optional packages

Install a Docker Registry using helm

If you don't have a local Docker registry deployed in your infrastructure, you can install an insecure one using the official Kubernetes helm-chart.

Note: Insecure registries can be used for development, POCs or lab trials. You should not use this in production. There are planty of documents online that guide you through secure registries setup.

The following command deploys the registry and exposes the port 30500. (You may want to change it with any value that fit your deployment needs).

helm install stable/docker-registry --set service.nodePort=30500,service.type=NodePort -n docker-registry

The registry can be queried at any time, for example:

curl -X GET http://KUBERNETES_IP:30500/v2/_catalog

Install a local web server using helm (optional)

If you don't have a local web server that can be accessed from the POD, you can easily install one on top of your existing Kubernetes cluster.

# From the helm-charts directory, while preparing the offline install
helm repo add bitnami
helm fetch bitnami/nginx --untar

# Then, while deploying offline
helm install -n mavenrepo --set service.nodePorts.http=30160,service.type=NodePort nginx

The webserver will be up in few seconds and you'll be able to reach the root web page using the IP of one of your Kubernetes nodes, port 30160. For example, you can do:

wget KUBERNETES_IP:30160

OAR images can be copied to the document root of the web server using the kubectl cp command. For example:

kubectl cp my-onos-app.oar `kubectl get pods | grep mavenrepo | awk '{print $1;}'`:/opt/bitnami/nginx/html

Example: offline SEBA install

The following section provides an exemplary list of commands to perform an offline SEBA POD installation. Please, note that some command details (i.e. chart names, image names, tools) may have changed over time.


  • The Operating Systems (both on servers and network devices) is already installed and running.

  • The EdgeCore asfvolt16 OLT is used as access device. The device has an IP address

  • For convenience, the example makes also use of some automation tools, also described in paragraphs above.

  • The same machine used to prepare the installation files (while still connected to Internet) is also used to perform the offline install.

  • The infrastructure doesn't have a local Docker registry. As such, a dedicated local Docker registry is deployed on top of the existing Kubernetes cluster, while the Kubernetes cluster can still access Internet.

  • The infrastructure doesn't have a local web server. As such, an additional web server (to host ONOS applications) is deployed on top of the existing Kubernetes cluster.

  • Configuration files for SEBA have been already created. They live in the root directory and they are called fabric.yaml, olt.yaml, subscriber.yaml.

  • The IP address of the machine hosting Kubernetes is

Prepare the installation

# Clone repos
git clone
git clone

# Copy automation scripts in the right place
cp automation-tools/developer/ helm-charts
cp automation-tools/developer/ helm-charts
cp automation-tools/developer/ helm-charts

cd helm-charts

# Add online helm repositories and update dependencies
helm repo add incubator
helm repo add rook-beta
helm repo add bitnami
helm dep update voltha
helm dep update xos-core
helm dep update xos-profiles/att-workflow
helm dep update xos-profiles/base-kubernetes
helm dep update nem-monitoring
helm dep update logging
helm dep update storage/rook-operator

# Fetch helm-charts not available locally
helm fetch stable/docker-registry --untar
helm fetch --version 0.8.0 stable/etcd-operator --untar
helm fetch --version 0.8.8 incubator/kafka --untar
helm fetch bitnami/nginx --untar

# Update Kafka dependencies
helm dep update kafka

# For demo, install the local, helm-based Docker Registry on the remote POD (this will require POD connectivity to download the docker registry image)
helm install stable/docker-registry --set service.nodePort=30500,service.type=NodePort -n docker-registry

# For demo, install the local web-server to host ONOS images
helm install -n mavenrepo bitnami/nginx

# Identify images form the official helm charts and pull images from DockerHub. If you see some "skipped value for filters" warning that's fine
bash kafka etcd-cluster etcd-operator voltha onos xos-core xos-profiles/att-workflow xos-profiles/base-kubernetes nem-monitoring logging storage/rook-operator | bash > images

# Download ONOS apps
curl -L "" > olt.oar
curl -L "" > sadis.oar
curl -L "" > dhcpl2relay.oar
curl -L "" > aaa.oar
curl -L "" > kafka.oar

# Create file to extend the helm charts (call it extend.yaml)

imageTag: 4.1.2-2










# Download the openolt.deb driver installation file from the vendor website (command varies)
scp/wget... openolt.deb

Offline deployment

cd helm-charts

# Tag and push the images to the local Docker registry
cat images | bash -r

# Copy the ONOS applications to the local web server
MAVEN_REPO=$(kubectl get pods | grep mavenrepo | awk '{print $1;}')
kubectl cp olt.oar $MAVEN_REPO:/opt/bitnami/nginx/html
kubectl cp sadis.oar $MAVEN_REPO:/opt/bitnami/nginx/html
kubectl cp dhcpl2relay.oar $MAVEN_REPO:/opt/bitnami/nginx/html
kubectl cp aaa.oar $MAVEN_REPO:/opt/bitnami/nginx/html
kubectl cp kafka.oar $MAVEN_REPO:/opt/bitnami/nginx/html

# Install SEBA
helm install -n etcd-operator -f extend.yaml --version 0.8.0 etcd-operator
helm install -n cord-kafka -f examples/kafka-single.yaml -f extend.yaml --version 0.8.8 kafka
helm install -n voltha -f extend.yaml voltha
helm install -n onos -f configs/onos.yaml -f extend.yaml onos
helm install -n xos-core -f extend.yaml xos-core
helm install -n att-workflow -f extend.yaml xos-profiles/att-workflow
helm install -n base-kubernetes -f extend.yaml xos-profiles/base-kubernetes
helm install -n nem-monitoring -f extend.yaml nem-monitoring
helm install -n logging -f extend.yaml logging

# On the OLT, copy, install and run openolt.deb
scp openolt.deb root@
ssh root@ 'dpkg -i openolt.deb'
ssh root@ 'service bal_core_dist start'
ssh root@ 'service openolt start'

# Configure SEBA
curl -H "xos-username:" -H "xos-password: letmein" -X POST --data-binary @fabric.yaml
curl -H "xos-username:" -H "xos-password: letmein" -X POST --data-binary @olt.yaml
curl -H "xos-username:" -H "xos-password: letmein" -X POST --data-binary @subscriber.yaml

results matching ""

    No results matching ""