...

This page describes how to get the Guilin release version of Non-RT RIC up and running locally with two separate Near-RT RIC A1 simulator docker containers providing OSC_2.1.0 version of A1 interface.

All four components of the Non-RT RIC (from three different repos) run inside docker containers and communicate via a docker network. Details of the architecture can be found from Guilin Release page.

• Project Requirements

• Build Code

  • Build Policy Management Service container

    • Configure Policy Management Service

    • Build the code and create docker image

    Build near-rt-ric-simulator container

    • Create docker image

  • Build

    NONRTRIC / A1 Policy control panel container

    A1 Controller

    • Verify controlpanel configuration

    • Build the code and create docker imageimages

• Run A1 Controller Docker Container

  • Open Daylight GUI

  Controller 

• Run Near-RT RIC A1 Simulator Docker Containers

• Run Policy -agent Management Service Docker Container

  • policy-agent Policy Management Service Swagger API

• Run Non-RT RIC Control Panel Docker Container

  • Open NONRTRIC / A1 Policy Control Panel UI

Project Requirements

• Java 11 (make sure that JAVA_HOME environment variable points to correct Java version)

• Maven 3.6

• Docker and docker-compose (latest)

Build Code

Build Policy Management Service container

• Download the ccsdk/oran repo, guilin branch: 

  
  

  Code Block
  language

...

• bash

  $ git clone "https://gerrit.onap.org/r/ccsdk/oran" -b guilin

  
  

Configure the Policy Management Service

To support local test with two separate Near-RT RIC simulator instances:  

• Update Copy the existing file oran/a1-policy-management/config/application_configuration.json  to the current directory and update it with the configuration below

• The controller hostname and port values come from and must match those defined in in the sdnc/oam repo oam/installation/src/main/yaml/docker-compose.yml (see the step "Build A1 Controller" further below). The port for http is 8181.

• Any defined ric host names (in the name and baseUrl for each ric) must match the given docker container names in Near-RT RIC A1 simulator startup described further down - port is always the simulator's internal 8085 for http or 8185 for https

...

{
  "config": {
    "//description": "Application configuration",
    "controller": [
      {
        "name": "controller1",
        "baseUrl": "http://sdnc_controller_container:8181",
        "userName": "admin",
        "password": "Kp8bJ4SXszM0WXlhak3eHlcse2gAw84vaoGGmJvUy2U"
      }
    ],
    "ric": [
      {
        "name": "ric1",
        "baseUrl": "http://ric1:8085/",
        "controller": "controller",
        "managedElementIds": [
          "kista_1",
          "kista_2"
        ]
      },
      {
        "name": "ric2",
        "baseUrl": "http://ric2:8085/",
        "controller": "controller",
        "managedElementIds": [
          "kista_3",
          "kista_4"
        ]
      }
    ]
  }
}

Build the code and create docker image

To build docker image of the policy management service:

$ cd oran/a1-policy-management/
$ mvn clean install -Dmaven.test.skip=true
$ docker images

If the build is successful an image with following name and tag shall be built, use the command 'docker images' to view newly built the image in the local docker registry.

onap/ccsdk-oran-a1policymanagementservice 1.0.2-SNAPSHOT

Build A1 Controller

Build the code and create docker images

A1 Policy Adapter is a feature developed within CCSDK which is then installed in SDNC Karaf Server. To build & run the A1 Adapter, you need to build the ccsdk & sdnc repo's.

...

Use the downloaded repo 'ccsk/oran' as in the previous step, "Build Policy Management Service container"

$ cd a1-adapter

$ mvn clean install -Dmaven.test.skip=true
$ docker images

After you build the A1 adapter artefacts, down below CCSDK/SDNC repo's and build it,them in order.

If the build is successful an image builds are successful, images with following name and tag shall be builtexist, use the command 'docker images' to view newly built the image in the local docker registry.

$ docker images | grep onap
onap/sdnc-image latest
onap/sdnc-ansible-server-image latest
onap/admportal-sdnc-image latest
onap/ccsdk-dgbuilder-image latest
onap/sdnc-ueb-listener-image latest
onap/sdnc-dmaap-listener-image:latest

Run A1

...

Controller

To view the A1 policy operations, you need to run the SDNC docker image. This image has few other docker image dependency but not all are important for A1 policy testing. To bring up the sdnc container for A1 Policy Management testing you can do below change to the docker compose file.

In sdnc/oam repo 
export MTU=1500
docker network create nonrtric-docker-net
cd sdnc/oam/installation/src/main/yaml
docker-compose up 

...

Edit the docker compose file, oam/installation/src/main/yaml/docker-compose.yaml and keep only sdnc, maria db and ansible images. Rest of the images are not necessary for A1 Policy testing. However if you want to change the DG and run your own DG, you may need to keep the Directed Graph image.

$ export MTU=1500
$ docker network create nonrtric-docker-net
$ cd oam/installation/src/main/yaml
$ docker-compose up 
$ docker network connect nonrtric-docker-net sdnc_controller_container (use another shell)

The SDNC image will take a while to install all the features into Karaf The SDNC image will take a while to install all the features into Karaf Server. You can check the logs of the server at /opt/opendaylight/data/log/karaf.log

The A1 Policy in ODL GUI can be accessed by this URL (it may take several minutes before the URL works)

http://localhost:8282/apidoc/explorer/index.html
Username/password: admin/Kp8bJ4SXszM0WXlhak3eHlcse2gAw84vaoGGmJvUy2U

Run Near-RT RIC A1 Simulator Docker Containers

• Start docker containers for each ric defined in oran/a1-policy-management/config/application_configuration.json in previous steps (in this example for ric1 and ric2) and providing A1 interface version OSC_2.1.0 with the following commands:: commands (use separate shells):

  Code Block
  language bash
  $ docker run -p 8085:8085 -p 8185:8185 -e A1_VERSION=OSC_2.1.0 -e ALLOW_HTTP=true --network=nonrtric-docker-net --name=ric1 nexus3.o-ran-sc.org:10004/o-ran-sc/a1-simulator:2.0.0

  $ docker run -p 8086:8085 -p 8186:8185 -e A1_VERSION=OSC_2.1.0 -e ALLOW_HTTP=true --network=nonrtric-docker-net --name=ric2 nexus3.o-ran-sc.org:10004/o-ran-sc/a1-simulator:2.0.0

  
  

• Create a policy type json to load into the A1 simulators

  Code Block
  language bash title pt1.json
  { "name": "pt1", "description": "pt1 policy type", "policy_type_id": 1, "create_schema": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "OSC_Type1_1.0.0", "description": "Type 1 policy type", "type": "object", "properties": { "scope": { "type": "object", "properties": { "ueId": { "type": "string" }, "qosId": { "type": "string" } }, "additionalProperties": false, "required": [ "ueId", "qosId" ] }, "qosObjectives": { "type": "object", "properties": { "priorityLevel": { "type": "number" } }, "additionalProperties": false, "required": [ "priorityLevel" ] } }, "additionalProperties": false, "required": [ "scope", "qosObjectives" ] } }

  
  

• Put the example policy type into the started A1 simulator instances by running these curl commands (in this example to ric1 exposed to port 8085 and ric2 exposed to port 8086):

  Code Block
  language bash
  $ curl -X PUT -v "http://localhost:8085/a1-p/policytypes/123" -H "accept: application/json" \ -H "Content-Type: application/json" --data-binary @pt1.json $ curl -X PUT -v "http://localhost:8086/a1-p/policytypes/123" -H "accept: application/json" \ -H "Content-Type: application/json" --data-binary @pt1.json

  
  

Run Policy Management Service Docker Container

• Run docker container using this command once A1 Controller and simulators have been fully started and optionally set the logging to trace (the curl command will not work until the container is fully up and running).to trace (the curl command will not work until the container is fully up and running).
  The configuration of the controller and rics must be mounted as a volume to the container.

  Code Block
  language bash
  $ docker run -p 8081:8081

  --network=nonrtric-docker-net --name=policy-management-service

  --network=nonrtric-docker-net --name=policy-agent-container --volume <Absolute path to application_configuration.json created above>:/opt/app/policy-agent/data/application_configuration.json onap/ccsdk-oran-a1policymanagementservice:1.0.2-SNAPSHOT

  
  

  Code Block
  language bash
  $ curl -X POST  http://localhost:8081/actuator/loggers/org.onap.ccsdk.oran.a1policymanagementservice -H "Content-Type:application/json" -d {\"configuredLevel\":\"trace\"}

  
  

• Once the Policy Management Service is up and running, it establishes connections to all configured Near-RT RICs (ric1 and ric2).

• If policy-agent-container is configured to log at DEBUG level, the following logs should appear to log to show that connection to the configured RICs has been established successfully via A1 Controller.

...

$ docker logs policy-management-service | grep "protocol version" 
2020-0411-1723 1116:1000:1127.357484 DEBUG 1 --- [or-http-epoll-15] o.o.c.o.policyagenta.clients.A1ClientFactory        : Established protocol version:SDNC_OSC_OSC_V1 for RicNear-RT RIC: ric1 
2020-0411-1723 1116:1000:1127.387495 DEBUG 1 --- [or-http-epoll-16] o.o.policyagentc.o.a.clients.A1ClientFactory        : Established protocol version:SDNC_OSC_OSC_V1 for RicNear-RT RIC: ric2

Policy Management Service Swagger API

For troubleshooting/verification purposes you can view/access the policy-agent swagger API from url: http://localhost:8081/swagger-ui.html

Run Non-RT RIC Control Panel Docker Container

Run docker container using this command: 

$ docker run -p 8080:8080 --network=nonrtric-docker-net nexus3.o-ran-sc.org:10004/o-ran-sc/nonrtric-controlpanel:2.0.0

Open NONRTRIC / A1 Policy Control Panel UI

...