| commit | dae4b37c7f067becbae331ef8bff60235c53a61c | [log] [tgz] |
|---|---|---|
| author | kurczews <krzysztof.kurczewski@nokia.com> | Tue Jan 16 11:49:07 2018 +0100 |
| committer | Patrick Brady <pb071s@att.com> | Wed Jan 17 20:16:49 2018 +0000 |
| tree | 735eb49fa5c2f38fb8f55ffab94251f7ce0f958c | |
| parent | c554733ede49bd0be16c5a665577ce2a32bae565 [diff] |
Fix some sonar issues Fix sonar issues assigned to me Change-Id: I926c011fd9d2c4f5628c4151e8c50a8fb5f3ea86 Issue-ID: APPC-412 Signed-off-by: kurczews <krzysztof.kurczewski@nokia.com>
The Application Controller (APPC) is one of the components in the ONAP Platform. Its main function is to perform functions to control the lifecycle of Virtual Functions (VNFs) as well as the components that make up these functions. Therefore, this allows the cloud to be abstracted from Virtual Functions in order to enable repeatable actions, as well as enabling automation and a dynamic configuration approach.
ONAP APPC is delivered with 3 Docker Containers, which are deployed using Docker Images already containing the APPC Framework Suite. NOTE: All three containers are hosted on Ubuntu 14.04 LTS OS.
The docker containers described above are set up to be deployed on the same Virtual Machine. Docker Compose is Docker's deployment tool that allows to configure and deploy multiple containers at once.
APPC (structured as a Maven project) uses the Maven tool to help compile, build, and deploy APPC Artifacts (usually made up of Java packages) into a Maven Repository. In order to compile and build APPC, a mvn clean install is executed, which checks for any errors and Java exceptions during compilation process.
In order to deploy APPC, a Docker-ready machine needs to be available in order to deploy the APPC Docker Containers. The following will help explain the requirements in order to run Docker to deploy these containers.
ONAP APPC docker images are currently stored on the Rackspace Nexus Docker Registry (Maven Repository). The deployment code can be found in the Maven Project that builds and deploys the Docker Images to be deployed in the Nexus Repository (current approach is by using Jenkins). These Docker Images are composed of the APPC Artifacts (org.onap.appc.*) compiled and packaged in the "appc" git repository.
The following Docker images are the actual deployment images used for running APPC:
Ther following steps are needed to deploy and start ONAP APPC:
A Jenkins instance for ONAP is required, in which Jenkins Jobs for both the APPC core code and deployment code are maintained.
Jenkins Job for APPC Core git project: The Jenkins Job for the APPC git repository (Core Component) is in charge of compiling and uploading/deploying successfully compiled maven APPC artifacts into a Nexus/Maven Repository.
Jenkins Job for APPC Deployment git project: The Jenkins Job is used to run the APPC Deployment code which ultimately builds and deploy the APPC Docker Image. Once the Jenkins job runs successfully, the newly compiled images are uploaded to the Nexus Repository. The APPC Docker image contains all the SDN-C and APPC artifacts needed to deploy a successful APPC Component.
As explained in the "APPC Docker Containers" section, the configuration and set up of the other two docker containers are not maintained by APPC. MySQL Docker Image is maintained by the Open Source MySQL Community and the Node Red / DGBuilder Docker Image is maintained by SDN-C.
The VM where APPC will be started needs to have Docker Engine and Docker-Compose installed (instructions on how to set Docker Engine can be found here). The stable version of Docker Engine where APPC has been tested to work is v1.12. An important requirement in order to access the Docker Image Repository on Nexus Repository (where docker images are currently stored) need to include the Nexus repository certificate imported in the host VM. This is needed for Docker to be able to access the Docker Images required (NOTE: MySQL Docker Image is obtained from the public Docker Hub).
NOTE ON "docker-compose" COMMANDS: The only work if there is a provided docker-compose YAML script in the cmd path
In order to deploy containers, the following steps need to be taken in your host VM (Assuming instructions on how to set up Docker Engine have already been done):
# Install Docker-Compose apt-get install python-pip pip install docker-compose # Login to Nexus Repo to pull Docker Images (this assumes that Nexus Certificate is already imported in the Host VM on /usr/local/share/ca-certificates/ path): docker login <DOCKER_REGISTRY_REPO> # prompts for user credentials as a way to authenticate # Pull latest version of Docker Images (separately) docker pull <APPC_DOCKER_IMAGE_URL> docker pull mysql/mysql-server:5.6 # Default Open-Source MySQL Docker Image docker pull <SDNC_DOCKER_IMAGE_URL> # Pull latest version of Docker Images docker-compose pull # Deploy Containers docker-compose up # add -d argument to start process as a daemon (background process)
# Stop and Destroy Docker Containers (with docker-compose YAML script) docker-compose down # Stop Docker Containers (without docker-compose YAML script) docker stop <APPC_DOCKER_CONTAINER> docker stop <MYSQL_DOCKER_CONTAINER> docker stop <DGBUILDER_DOCKER_CONTAINER> # Destroy Docker Containers (without docker-compose YAML script) docker rm <APPC_DOCKER_CONTAINER> docker rm <MYSQL_DOCKER_CONTAINER> docker rm <DGBUILDER_DOCKER_CONTAINER>
# Check current docker-compose logs generated during 'docker-compose up' process: docker-compose logs # add -f to display logs in real time # Check out docker container's current details docker inspect <DOCKER_CONTAINER> # Verbose output during docker-compose commands docker-compose --verbose <DOCKER_COMPOSE_CMD_ARG> # Check previous docker volumes docker volume ls # Delete previous docker volume(s) docker volume rm <DOCKER_VOL_ID_1> <DOCKER_VOL_ID_2> ... <DOCKER_VOL_ID_N>
A Heat template that can be used on RackSpace to spin up the APPC Host VM as well as the other ONAP Components is available in gitlab. This template would orchestrate the deployment of all ONAP components, which will trigger docker instantiation techniques to start up the containers (either standard docker or docker-compose - depending on how the component's containers get spun up).
First of all, APPC Features come in the form of Karaf Features (an ODL-OpenDaylight package) which can be composed of one or more OSGI bundles. These features get installed in the ODL framework in order to be used and installed in the APPC Docker Container (NOTE: SDN-C Core Features also get installed since APPC docker image uses the SDN-C Core docker image as a base image).
The following command is used to log in / access the docker containers:
docker exec -it <DOCKER_CONTAINER> bash
The following commands are used to check if the APPC (and SDN-C) Bundles and Features have been installed correctly in ODL (make sure to enter the APPC Docker Container shell session):
# All commands are done inside the appc docker container # Enter the ODL Karaf Console cd /opt/opendaylight/current/bin ./client -u karaf # Check if features have been installed or not (the ones with an 'X' in the "Installed" column have been successfully installed) feature:list | grep appc # filter appc features only feature:list | grep sdnc # filter sdn-c features only # Check if bundles have been loaded successfully (the ones with 'Active' in the "State" column have been successfully loaded) bundle:list | grep appc # filter appc bundles only bundle:list | grep sdnc # grep sdn-c bundles only # Check reason why bundle failed to load bundle:diag | grep <BUNDLE_NAME>
The API Explorer is a GUI provided by OpenDaylight Open Source Framework. This GUI is very useful to send API calls from APIs that are either developed by APPC or SDN-C frameworks. In order to make these REST calls, some APIs use the RESTCONF protocol to make such calls.
Currently, the APIs that have a Directed Graph (DG) mapped to it are the ones that can be tested which are the SDN-C APIs and APPC "appc-provider" APIs (LCM APIs will be available to test in later releases).
In order to access this GUI, you need to go to the following website which will prompt for ODL user credentials in order to authenticate (more details on generic API Explorer here):
APPC Configuration model involves using "default.properties" files (which are usually located in each of the APPC Features - ../<APPC_FEATURE_BUNDLE>/src/<MAIN_OR_TEST>/resources/org/onap/appc/default.properties) for APPC Feature that have default (or null) property values inside the core APPC code. These default (or null) properties should be overwritten in the properties file called "appc.properties" located in the APPC Deployment code (../installation/src/main/appc-properties/appc.properties).
Each APPC component depends on the property values that are defined for them in order to function properly. For example, the APPC Feature "appc-rest-adapter" located in the APPC Core repo is used to listen to events that are being sent and received in the form of DMaaP Messages through a DMaaP Server Instance (which is usually defined as a RESTful API Layer over the Apache Kafka Framework). The properties for this feature need to be defined to point to the right DMaaP set of events to make sure that we are sending and receiving the proper messages on DMaaP.
Currently, there are two ways to change properties for APPC Features: