1 .. This work is licensed under a Creative Commons Attribution 4.0
2 .. International License.
3 .. http://creativecommons.org/licenses/by/4.0
4 .. Copyright 2018-2020 Amdocs, Bell Canada, Orange, Samsung
7 .. _Helm: https://docs.helm.sh/
8 .. _Helm Charts: https://github.com/kubernetes/charts
9 .. _Kubernetes: https://Kubernetes.io/
10 .. _Docker: https://www.docker.com/
11 .. _Nexus: https://nexus.onap.org/#welcome
12 .. _AWS Elastic Block Store: https://aws.amazon.com/ebs/
13 .. _Azure File: https://docs.microsoft.com/en-us/azure/storage/files/storage-files-introduction
14 .. _GCE Persistent Disk: https://cloud.google.com/compute/docs/disks/
15 .. _Gluster FS: https://www.gluster.org/
16 .. _Kubernetes Storage Class: https://Kubernetes.io/docs/concepts/storage/storage-classes/
17 .. _Assigning Pods to Nodes: https://Kubernetes.io/docs/concepts/configuration/assign-pod-node/
20 .. _developer-guide-label:
25 .. figure:: oomLogoV2-medium.png
28 ONAP consists of a large number of components, each of which are substantial
29 projects within themselves, which results in a high degree of complexity in
30 deployment and management. To cope with this complexity the ONAP Operations
31 Manager (OOM) uses a Helm_ model of ONAP - Helm being the primary management
32 system for Kubernetes_ container systems - to drive all user driven life-cycle
33 management operations. The Helm model of ONAP is composed of a set of
34 hierarchical Helm charts that define the structure of the ONAP components and
35 the configuration of these components. These charts are fully parameterized
36 such that a single environment file defines all of the parameters needed to
37 deploy ONAP. A user of ONAP may maintain several such environment files to
38 control the deployment of ONAP in multiple environments such as development,
39 pre-production, and production.
41 The following sections describe how the ONAP Helm charts are constructed.
50 Linux containers allow for an application and all of its operating system
51 dependencies to be packaged and deployed as a single unit without including a
52 guest operating system as done with virtual machines. The most popular
53 container solution is Docker_ which provides tools for container management
54 like the Docker Host (dockerd) which can create, run, stop, move, or delete a
55 container. Docker has a very popular registry of containers images that can be
56 used by any Docker system; however, in the ONAP context, Docker images are
57 built by the standard CI/CD flow and stored in Nexus_ repositories. OOM uses
58 the "standard" ONAP docker containers and three new ones specifically created
61 Containers are isolated from each other primarily via name spaces within the
62 Linux kernel without the need for multiple guest operating systems. As such,
63 multiple containers can be deployed with little overhead such as all of ONAP
64 can be deployed on a single host. With some optimization of the ONAP components
65 (e.g. elimination of redundant database instances) it may be possible to deploy
66 ONAP on a single laptop computer.
70 A Helm chart is a collection of files that describe a related set of Kubernetes
71 resources. A simple chart might be used to deploy something simple, like a
72 memcached pod, while a complex chart might contain many micro-service arranged
73 in a hierarchy as found in the `aai` ONAP component.
75 Charts are created as files laid out in a particular directory tree, then they
76 can be packaged into versioned archives to be deployed. There is a public
77 archive of `Helm Charts`_ on GitHub that includes many technologies applicable
78 to ONAP. Some of these charts have been used in ONAP and all of the ONAP charts
79 have been created following the guidelines provided.
81 The top level of the ONAP charts is shown below:
88 │ ├── requirements.yaml
91 │ │ │ └── docker-entrypoint.sh
96 │ │ │ ├── configmap.yaml
97 │ │ │ ├── cronjob.yaml
100 │ │ ├── configmap.yaml
103 │ │ └── statefulset.yaml
108 │ │ ├── _createPassword.tpl
113 │ │ ├── _namespace.tpl
114 │ │ ├── _repository.tpl
115 │ │ ├── _resources.tpl
119 │ │ └── _tplValue.tpl
124 ├── requirements.yaml
128 The common section of charts consists of a set of templates that assist with
129 parameter substitution (`_name.tpl`, `_namespace.tpl` and others) and a set of charts
130 for components used throughout ONAP. When the common components are used by other charts they
131 are instantiated each time or we can deploy a shared instances for several components.
133 All of the ONAP components have charts that follow the pattern shown below:
139 ├── requirements.yaml
141 │ └── subcomponent-folder
143 │ └── subchart-folder
155 │ ├── deployment.yaml
162 Note that the component charts / components may include a hierarchy of sub
163 components and in themselves can be quite complex.
165 You can use either `charts` or `components` folder for your subcomponents.
166 `charts` folder means that the subcomponent will always been deployed.
168 `components` folders means we can choose if we want to deploy the
171 This choice is done in root `values.yaml`:
184 Then in `requirements.yaml`, you'll use these values:
195 repository: 'file://components/component1'
196 condition: component1.enabled
199 repository: 'file://components/component2'
200 condition: component2.enabled
202 Configuration of the components varies somewhat from component to component but
203 generally follows the pattern of one or more `configmap.yaml` files which can
204 directly provide configuration to the containers in addition to processing
205 configuration files stored in the `config` directory. It is the responsibility
206 of each ONAP component team to update these configuration files when changes
207 are made to the project containers that impact configuration.
209 The following section describes how the hierarchical ONAP configuration system
210 is key to management of such a large system.
212 Configuration Management
213 ========================
215 ONAP is a large system composed of many components - each of which are complex
216 systems in themselves - that needs to be deployed in a number of different
217 ways. For example, within a single operator's network there may be R&D
218 deployments under active development, pre-production versions undergoing system
219 testing and production systems that are operating live networks. Each of these
220 deployments will differ in significant ways, such as the version of the
221 software images deployed. In addition, there may be a number of application
222 specific configuration differences, such as operating system environment
223 variables. The following describes how the Helm configuration management
224 system is used within the OOM project to manage both ONAP infrastructure
225 configuration as well as ONAP components configuration.
227 One of the artifacts that OOM/Kubernetes uses to deploy ONAP components is the
228 deployment specification, yet another yaml file. Within these deployment specs
229 are a number of parameters as shown in the following example:
237 app.kubernetes.io/name: zookeeper
238 helm.sh/chart: zookeeper
239 app.kubernetes.io/component: server
240 app.kubernetes.io/managed-by: Tiller
241 app.kubernetes.io/instance: onap-oof
242 name: onap-oof-zookeeper
249 app.kubernetes.io/name: zookeeper
250 app.kubernetes.io/component: server
251 app.kubernetes.io/instance: onap-oof
252 serviceName: onap-oof-zookeeper-headless
256 app.kubernetes.io/name: zookeeper
257 helm.sh/chart: zookeeper
258 app.kubernetes.io/component: server
259 app.kubernetes.io/managed-by: Tiller
260 app.kubernetes.io/instance: onap-oof
267 image: gcr.io/google_samples/k8szk:v3
268 imagePullPolicy: Always
271 - containerPort: 2181
274 - containerPort: 3888
277 - containerPort: 2888
282 Note that within the statefulset specification, one of the container arguments
283 is the key/value pair image: gcr.io/google_samples/k8szk:v3 which
284 specifies the version of the zookeeper software to deploy. Although the
285 statefulset specifications greatly simplify statefulset, maintenance of the
286 statefulset specifications themselves become problematic as software versions
287 change over time or as different versions are required for different
288 statefulsets. For example, if the R&D team needs to deploy a newer version of
289 mariadb than what is currently used in the production environment, they would
290 need to clone the statefulset specification and change this value. Fortunately,
291 this problem has been solved with the templating capabilities of Helm.
293 The following example shows how the statefulset specifications are modified to
294 incorporate Helm templates such that key/value pairs can be defined outside of
295 the statefulset specifications and passed during instantiation of the component.
302 name: {{ include "common.fullname" . }}
303 namespace: {{ include "common.namespace" . }}
304 labels: {{- include "common.labels" . | nindent 4 }}
306 replicas: {{ .Values.replicaCount }}
308 matchLabels: {{- include "common.matchLabels" . | nindent 6 }}
309 # serviceName is only needed for StatefulSet
310 # put the postfix part only if you have add a postfix on the service name
311 serviceName: {{ include "common.servicename" . }}-{{ .Values.service.postfix }}
315 labels: {{- include "common.labels" . | nindent 8 }}
316 annotations: {{- include "common.tplValue" (dict "value" .Values.podAnnotations "context" $) | nindent 8 }}
317 name: {{ include "common.name" . }}
321 - name: {{ include "common.name" . }}
322 image: {{ .Values.image }}
323 imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
325 {{- range $index, $port := .Values.service.ports }}
326 - containerPort: {{ $port.port }}
327 name: {{ $port.name }}
329 {{- range $index, $port := .Values.service.headlessPorts }}
330 - containerPort: {{ $port.port }}
331 name: {{ $port.name }}
335 This version of the statefulset specification has gone through the process of
336 templating values that are likely to change between statefulsets. Note that the
337 image is now specified as: image: {{ .Values.image }} instead of a
338 string used previously. During the statefulset phase, Helm (actually the Helm
339 sub-component Tiller) substitutes the {{ .. }} entries with a variable defined
340 in a values.yaml file. The content of this file is as follows:
345 image: gcr.io/google_samples/k8szk:v3
350 Within the values.yaml file there is an image key with the value
351 `gcr.io/google_samples/k8szk:v3` which is the same value used in
352 the non-templated version. Once all of the substitutions are complete, the
353 resulting statefulset specification ready to be used by Kubernetes.
355 When creating a template consider the use of default values if appropriate.
356 Helm templating has built in support for DEFAULT values, here is
362 - name: "{{ .Values.nsPrefix | default "onap" }}-docker-registry-key"
364 The pipeline operator ("|") used here hints at that power of Helm templates in
365 that much like an operating system command line the pipeline operator allow
366 over 60 Helm functions to be embedded directly into the template (note that the
367 Helm template language is a superset of the Go template language). These
368 functions include simple string operations like upper and more complex flow
369 control operations like if/else.
371 OOM is mainly helm templating. In order to have consistent deployment of the
372 different components of ONAP, some rules must be followed.
374 Templates are provided in order to create Kubernetes resources (Secrets,
375 Ingress, Services, ...) or part of Kubernetes resources (names, labels,
376 resources requests and limits, ...).
378 a full list and simple description is done in
379 `kubernetes/common/common/documentation.rst`.
384 In order to create a Service for a component, you have to create a file (with
385 `service` in the name.
386 For normal service, just put the following line:
390 {{ include "common.service" . }}
392 For headless service, the line to put is the following:
396 {{ include "common.headlessService" . }}
398 The configuration of the service is done in component `values.yaml`:
403 name: NAME-OF-THE-SERVICE
407 someAnnotationsKey: value
419 `annotations` and `postfix` keys are optional.
420 if `service.type` is `NodePort`, then you have to give `nodePort` value for your
421 service ports (which is the end of the computed nodePort, see example).
423 It would render the following Service Resource (for a component named
424 `name-of-my-component`, with version `x.y.z`, helm deployment name
425 `my-deployment` and `global.nodePortPrefix` `302`):
433 someAnnotationsKey: value
434 name: NAME-OF-THE-SERVICE-MY-POSTFIX
436 app.kubernetes.io/name: name-of-my-component
437 helm.sh/chart: name-of-my-component-x.y.z
438 app.kubernetes.io/instance: my-deployment-name-of-my-component
439 app.kubernetes.io/managed-by: Tiller
443 targetPort: tcp-MyPort
449 targetPort: https-api
452 app.kubernetes.io/name: name-of-my-component
453 app.kubernetes.io/instance: my-deployment-name-of-my-component
456 In the deployment or statefulSet file, you needs to set the good labels in
457 order for the service to match the pods.
459 here's an example to be sure it matches (for a statefulSet):
466 name: {{ include "common.fullname" . }}
467 namespace: {{ include "common.namespace" . }}
468 labels: {{- include "common.labels" . | nindent 4 }}
471 matchLabels: {{- include "common.matchLabels" . | nindent 6 }}
472 # serviceName is only needed for StatefulSet
473 # put the postfix part only if you have add a postfix on the service name
474 serviceName: {{ include "common.servicename" . }}-{{ .Values.service.postfix }}
478 labels: {{- include "common.labels" . | nindent 8 }}
479 annotations: {{- include "common.tplValue" (dict "value" .Values.podAnnotations "context" $) | nindent 8 }}
480 name: {{ include "common.name" . }}
484 - name: {{ include "common.name" . }}
486 {{- range $index, $port := .Values.service.ports }}
487 - containerPort: {{ $port.port }}
488 name: {{ $port.name }}
490 {{- range $index, $port := .Values.service.headlessPorts }}
491 - containerPort: {{ $port.port }}
492 name: {{ $port.name }}
496 The configuration of the service is done in component `values.yaml`:
501 name: NAME-OF-THE-SERVICE
505 anotherAnnotationsKey : value
506 publishNotReadyAddresses: true
515 `headless.annotations`, `headless.postfix` and
516 `headless.publishNotReadyAddresses` keys are optional.
518 If `headless.postfix` is not set, then we'll add `-headless` at the end of the
521 If it set to `NONE`, there will be not postfix.
523 And if set to something, it will add `-something` at the end of the service
526 It would render the following Service Resource (for a component named
527 `name-of-my-component`, with version `x.y.z`, helm deployment name
528 `my-deployment` and `global.nodePortPrefix` `302`):
536 anotherAnnotationsKey: value
537 name: NAME-OF-THE-SERVICE
539 app.kubernetes.io/name: name-of-my-component
540 helm.sh/chart: name-of-my-component-x.y.z
541 app.kubernetes.io/instance: my-deployment-name-of-my-component
542 app.kubernetes.io/managed-by: Tiller
547 targetPort: tcp-MyPort
553 targetPort: https-api
555 publishNotReadyAddresses: true
557 app.kubernetes.io/name: name-of-my-component
558 app.kubernetes.io/instance: my-deployment-name-of-my-component
561 Previous example of StatefulSet would also match (except for the `postfix` part
564 Creating Deployment or StatefulSet
565 ----------------------------------
567 Deployment and StatefulSet should use the `apps/v1` (which has appeared in
569 As seen on the service part, the following parts are mandatory:
576 name: {{ include "common.fullname" . }}
577 namespace: {{ include "common.namespace" . }}
578 labels: {{- include "common.labels" . | nindent 4 }}
581 matchLabels: {{- include "common.matchLabels" . | nindent 6 }}
582 # serviceName is only needed for StatefulSet
583 # put the postfix part only if you have add a postfix on the service name
584 serviceName: {{ include "common.servicename" . }}-{{ .Values.service.postfix }}
588 labels: {{- include "common.labels" . | nindent 8 }}
589 annotations: {{- include "common.tplValue" (dict "value" .Values.podAnnotations "context" $) | nindent 8 }}
590 name: {{ include "common.name" . }}
594 - name: {{ include "common.name" . }}
596 ONAP Application Configuration
597 ------------------------------
599 Dependency Management
600 ---------------------
601 These Helm charts describe the desired state
602 of an ONAP deployment and instruct the Kubernetes container manager as to how
603 to maintain the deployment in this state. These dependencies dictate the order
604 in-which the containers are started for the first time such that such
605 dependencies are always met without arbitrary sleep times between container
606 startups. For example, the SDC back-end container requires the Elastic-Search,
607 Cassandra and Kibana containers within SDC to be ready and is also dependent on
608 DMaaP (or the message-router) to be ready - where ready implies the built-in
609 "readiness" probes succeeded - before becoming fully operational. When an
610 initial deployment of ONAP is requested the current state of the system is NULL
611 so ONAP is deployed by the Kubernetes manager as a set of Docker containers on
612 one or more predetermined hosts. The hosts could be physical machines or
613 virtual machines. When deploying on virtual machines the resulting system will
614 be very similar to "Heat" based deployments, i.e. Docker containers running
615 within a set of VMs, the primary difference being that the allocation of
616 containers to VMs is done dynamically with OOM and statically with "Heat".
617 Example SO deployment descriptor file shows SO's dependency on its mariadb
620 SO deployment specification excerpt:
627 name: {{ include "common.fullname" . }}
628 namespace: {{ include "common.namespace" . }}
629 labels: {{- include "common.labels" . | nindent 4 }}
631 replicas: {{ .Values.replicaCount }}
633 matchLabels: {{- include "common.matchLabels" . | nindent 6 }}
637 app: {{ include "common.name" . }}
638 release: {{ .Release.Name }}
649 Kubernetes Container Orchestration
650 ==================================
651 The ONAP components are managed by the Kubernetes_ container management system
652 which maintains the desired state of the container system as described by one
653 or more deployment descriptors - similar in concept to OpenStack HEAT
654 Orchestration Templates. The following sections describe the fundamental
655 objects managed by Kubernetes, the network these components use to communicate
656 with each other and other entities outside of ONAP and the templates that
657 describe the configuration and desired state of the ONAP components.
661 Within the namespaces are Kubernetes services that provide external
662 connectivity to pods that host Docker containers.
664 ONAP Components to Kubernetes Object Relationships
665 --------------------------------------------------
666 Kubernetes deployments consist of multiple objects:
668 - **nodes** - a worker machine - either physical or virtual - that hosts
669 multiple containers managed by Kubernetes.
670 - **services** - an abstraction of a logical set of pods that provide a
672 - **pods** - one or more (but typically one) container(s) that provide specific
673 application functionality.
674 - **persistent volumes** - One or more permanent volumes need to be established
675 to hold non-ephemeral configuration and state data.
677 The relationship between these objects is shown in the following figure:
683 .. component Service {
692 .. figure:: kubernetes_objects.png
694 OOM uses these Kubernetes objects as described in the following sections.
698 OOM works with both physical and virtual worker machines.
700 * Virtual Machine Deployments - If ONAP is to be deployed onto a set of virtual
701 machines, the creation of the VMs is outside of the scope of OOM and could be
702 done in many ways, such as
704 * manually, for example by a user using the OpenStack Horizon dashboard or
706 * automatically, for example with the use of a OpenStack Heat Orchestration
707 Template which builds an ONAP stack, Azure ARM template, AWS CloudFormation
709 * orchestrated, for example with Cloudify creating the VMs from a TOSCA
710 template and controlling their life cycle for the life of the ONAP
713 * Physical Machine Deployments - If ONAP is to be deployed onto physical
714 machines there are several options but the recommendation is to use Rancher
715 along with Helm to associate hosts with a Kubernetes cluster.
719 A group of containers with shared storage and networking can be grouped
720 together into a Kubernetes pod. All of the containers within a pod are
721 co-located and co-scheduled so they operate as a single unit. Within ONAP
722 Amsterdam release, pods are mapped one-to-one to docker containers although
723 this may change in the future. As explained in the Services section below the
724 use of Pods within each ONAP component is abstracted from other ONAP
729 OOM uses the Kubernetes service abstraction to provide a consistent access
730 point for each of the ONAP components independent of the pod or container
731 architecture of that component. For example, the SDNC component may introduce
732 OpenDaylight clustering as some point and change the number of pods in this
733 component to three or more but this change will be isolated from the other ONAP
734 components by the service abstraction. A service can include a load balancer
735 on its ingress to distribute traffic between the pods and even react to dynamic
736 changes in the number of pods if they are part of a replica set.
740 To enable ONAP to be deployed into a wide variety of cloud infrastructures a
741 flexible persistent storage architecture, built on Kubernetes persistent
742 volumes, provides the ability to define the physical storage in a central
743 location and have all ONAP components securely store their data.
745 When deploying ONAP into a public cloud, available storage services such as
746 `AWS Elastic Block Store`_, `Azure File`_, or `GCE Persistent Disk`_ are
747 options. Alternatively, when deploying into a private cloud the storage
748 architecture might consist of Fiber Channel, `Gluster FS`_, or iSCSI. Many
749 other storage options existing, refer to the `Kubernetes Storage Class`_
750 documentation for a full list of the options. The storage architecture may vary
751 from deployment to deployment but in all cases a reliable, redundant storage
752 system must be provided to ONAP with which the state information of all ONAP
753 components will be securely stored. The Storage Class for a given deployment is
754 a single parameter listed in the ONAP values.yaml file and therefore is easily
755 customized. Operation of this storage system is outside the scope of the OOM.
759 Insert values.yaml code block with storage block here
761 Once the storage class is selected and the physical storage is provided, the
762 ONAP deployment step creates a pool of persistent volumes within the given
763 physical storage that is used by all of the ONAP components. ONAP components
764 simply make a claim on these persistent volumes (PV), with a persistent volume
765 claim (PVC), to gain access to their storage.
767 The following figure illustrates the relationships between the persistent
768 volume claims, the persistent volumes, the storage class, and the physical
774 label = "Persistance Volume Claim to Physical Storage Mapping"
776 node [shape=cylinder]
782 node [shape=Mrecord label="StorageClass:ceph"]
790 subgraph clusterSDC {
795 subgraph clusterSDNC {
814 # force all of these nodes to the same line in the given order
816 rank = same; PV0;PV1;PV2;PVn;p0;p1;p2
817 PV0->PV1->PV2->p0->p1->p2->PVn [style=invis]
821 rank = same; D0;D1;Dx;p3;p4;p5
822 D0->D1->p3->p4->p5->Dx [style=invis]
827 In-order for an ONAP component to use a persistent volume it must make a claim
828 against a specific persistent volume defined in the ONAP common charts. Note
829 that there is a one-to-one relationship between a PVC and PV. The following is
830 an excerpt from a component chart that defines a PVC:
834 Insert PVC example here
836 OOM Networking with Kubernetes
837 ------------------------------
840 - Ports - Flattening the containers also expose port conflicts between the
841 containers which need to be resolved.
848 OOM will use the rich set of Kubernetes node and pod affinity /
849 anti-affinity rules to minimize the chance of a single failure resulting in a
850 loss of ONAP service. Node affinity / anti-affinity is used to guide the
851 Kubernetes orchestrator in the placement of pods on nodes (physical or virtual
852 machines). For example:
854 - if a container used Intel DPDK technology the pod may state that it as
855 affinity to an Intel processor based node, or
856 - geographical based node labels (such as the Kubernetes standard zone or
857 region labels) may be used to ensure placement of a DCAE complex close to the
858 VNFs generating high volumes of traffic thus minimizing networking cost.
859 Specifically, if nodes were pre-assigned labels East and West, the pod
860 deployment spec to distribute pods to these nodes would be:
865 failure-domain.beta.Kubernetes.io/region: {{ .Values.location }}
867 - "location: West" is specified in the `values.yaml` file used to deploy
868 one DCAE cluster and "location: East" is specified in a second `values.yaml`
869 file (see OOM Configuration Management for more information about
870 configuration files like the `values.yaml` file).
872 Node affinity can also be used to achieve geographic redundancy if pods are
873 assigned to multiple failure domains. For more information refer to `Assigning
877 One could use Pod to Node assignment to totally constrain Kubernetes when
878 doing initial container assignment to replicate the Amsterdam release
879 OpenStack Heat based deployment. Should one wish to do this, each VM would
880 need a unique node name which would be used to specify a node constaint
881 for every component. These assignment could be specified in an environment
882 specific values.yaml file. Constraining Kubernetes in this way is not
885 Kubernetes has a comprehensive system called Taints and Tolerations that can be
886 used to force the container orchestrator to repel pods from nodes based on
887 static events (an administrator assigning a taint to a node) or dynamic events
888 (such as a node becoming unreachable or running out of disk space). There are
889 no plans to use taints or tolerations in the ONAP Beijing release. Pod
890 affinity / anti-affinity is the concept of creating a spacial relationship
891 between pods when the Kubernetes orchestrator does assignment (both initially
892 an in operation) to nodes as explained in Inter-pod affinity and anti-affinity.
893 For example, one might choose to co-located all of the ONAP SDC containers on a
894 single node as they are not critical runtime components and co-location
895 minimizes overhead. On the other hand, one might choose to ensure that all of
896 the containers in an ODL cluster (SDNC and APPC) are placed on separate nodes
897 such that a node failure has minimal impact to the operation of the cluster.
898 An example of how pod affinity / anti-affinity is shown below:
900 Pod Affinity / Anti-Affinity
907 name: with-pod-affinity
911 requiredDuringSchedulingIgnoredDuringExecution:
918 topologyKey: failure-domain.beta.Kubernetes.io/zone
920 preferredDuringSchedulingIgnoredDuringExecution:
929 topologyKey: Kubernetes.io/hostname
931 - name: with-pod-affinity
932 image: gcr.io/google_containers/pause:2.0
934 This example contains both podAffinity and podAntiAffinity rules, the first
935 rule is is a must (requiredDuringSchedulingIgnoredDuringExecution) while the
936 second will be met pending other considerations
937 (preferredDuringSchedulingIgnoredDuringExecution). Preemption Another feature
938 that may assist in achieving a repeatable deployment in the presence of faults
939 that may have reduced the capacity of the cloud is assigning priority to the
940 containers such that mission critical components have the ability to evict less
941 critical components. Kubernetes provides this capability with Pod Priority and
942 Preemption. Prior to having more advanced production grade features available,
943 the ability to at least be able to re-deploy ONAP (or a subset of) reliably
944 provides a level of confidence that should an outage occur the system can be
945 brought back on-line predictably.
950 Monitoring of ONAP components is configured in the agents within JSON files and
951 stored in gerrit under the consul-agent-config, here is an example from the AAI
952 model loader (aai-model-loader-health.json):
958 "name": "A&AI Model Loader",
961 "id": "model-loader-process",
962 "name": "Model Loader Presence",
963 "script": "/consul/config/scripts/model-loader-script.sh",
974 These liveness probes can simply check that a port is available, that a
975 built-in health check is reporting good health, or that the Consul health check
976 is positive. For example, to monitor the SDNC component has following liveness
977 probe can be found in the SDNC DB deployment specification:
981 sdnc db liveness probe
985 command: ["mysqladmin", "ping"]
986 initialDelaySeconds: 30 periodSeconds: 10
989 The 'initialDelaySeconds' control the period of time between the readiness
990 probe succeeding and the liveness probe starting. 'periodSeconds' and
991 'timeoutSeconds' control the actual operation of the probe. Note that
992 containers are inherently ephemeral so the healing action destroys failed
993 containers and any state information within it. To avoid a loss of state, a
994 persistent volume should be used to store all data that needs to be persisted
995 over the re-creation of a container. Persistent volumes have been created for
996 the database components of each of the projects and the same technique can be
997 used for all persistent state information.
1007 The \ `Microservices Bus
1008 Project <https://wiki.onap.org/pages/viewpage.action?pageId=3246982>`__ provides
1009 facilities to integrate micro-services into ONAP and therefore needs to
1010 integrate into OOM - primarily through Consul which is the backend of
1011 MSB service discovery. The following is a brief description of how this
1012 integration will be done:
1014 A registrator to push the service endpoint info to MSB service
1017 - The needed service endpoint info is put into the kubernetes yaml file
1018 as annotation, including service name, Protocol,version, visual
1019 range,LB method, IP, Port,etc.
1021 - OOM deploy/start/restart/scale in/scale out/upgrade ONAP components
1023 - Registrator watch the kubernetes event
1025 - When an ONAP component instance has been started/destroyed by OOM,
1026 Registrator get the notification from kubernetes
1028 - Registrator parse the service endpoint info from annotation and
1029 register/update/unregister it to MSB service discovery
1031 - MSB API Gateway uses the service endpoint info for service routing
1034 Details of the registration service API can be found at \ `Microservice
1036 Documentation <https://wiki.onap.org/display/DW/Microservice+Bus+API+Documentation>`__.
1038 ONAP Component Registration to MSB
1039 ----------------------------------
1040 The charts of all ONAP components intending to register against MSB must have
1041 an annotation in their service(s) template. A `sdc` example follows:
1043 .. code-block:: yaml
1051 namespace: "{{ .Values.nsPrefix }}"
1053 msb.onap.org/service-info: '[
1055 "serviceName": "sdc",
1063 "serviceName": "sdc-deprecated",
1075 MSB Integration with OOM
1076 ------------------------
1077 A preliminary view of the OOM-MSB integration is as follows:
1079 .. figure:: MSB-OOM-Diagram.png
1081 A message sequence chart of the registration process:
1085 participant "OOM" as oom
1086 participant "ONAP Component" as onap
1087 participant "Service Discovery" as sd
1088 participant "External API Gateway" as eagw
1089 participant "Router (Internal API Gateway)" as iagw
1091 box "MSB" #LightBlue
1097 == Deploy Servcie ==
1100 oom -> sd: Register service endpoints
1101 sd -> eagw: Services exposed to external system
1102 sd -> iagw: Services for internal use
1104 == Component Life-cycle Management ==
1106 oom -> onap: Start/Stop/Scale/Migrate/Upgrade
1107 oom -> sd: Update service info
1108 sd -> eagw: Update service info
1109 sd -> iagw: Update service info
1111 == Service Health Check ==
1113 sd -> onap: Check the health of service
1114 sd -> eagw: Update service status
1115 sd -> iagw: Update service status
1118 MSB Deployment Instructions
1119 ---------------------------
1120 MSB is helm installable ONAP component which is often automatically deployed.
1121 To install it individually enter::
1123 > helm install <repo-name>/msb
1126 TBD: Vaidate if the following procedure is still required.
1128 Please note that Kubernetes authentication token must be set at
1129 *kubernetes/kube2msb/values.yaml* so the kube2msb registrator can get the
1130 access to watch the kubernetes events and get service annotation by
1131 Kubernetes APIs. The token can be found in the kubectl configuration file
1134 More details can be found here `MSB installation <http://onap.readthedocs.io/en/latest/submodules/msb/apigateway.git/docs/platform/installation.html>`__.
1138 .. Note that although OOM uses Kubernetes facilities to minimize the effort
1139 .. required of the ONAP component owners to implement a successful rolling
1140 .. upgrade strategy there are other considerations that must be taken into
1142 .. For example, external APIs - both internal and external to ONAP - should be
1143 .. designed to gracefully accept transactions from a peer at a different
1144 .. software version to avoid deadlock situations. Embedded version codes in
1145 .. messages may facilitate such capabilities.
1147 .. Within each of the projects a new configuration repository contains all of
1148 .. the project specific configuration artifacts. As changes are made within
1149 .. the project, it's the responsibility of the project team to make appropriate
1150 .. changes to the configuration data.