Merge "Added validation on matching required fields"
[policy/engine.git] / docs / platform / installBeijingController.rst
1 .. This work is licensed under a Creative Commons Attribution 4.0 International License.
2 .. http://creativecommons.org/licenses/by/4.0
3
4 Installation of Beijing Controller and Policies
5 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
6
7 .. contents::
8     :depth: 2
9
10 This article explains how to install the Beijing policy controller and the Beijing policies on a raw ONAP Policy Framework installation running in Docker.
11
12 To build a raw Policy Framework installation, please follow either of the HowTo articles below prior to using this HowTo:
13
14     * `Standalone Quick Start <installation.html>`_
15     * `Standalone installation in Virtual Machine <installationVM.html>`_
16
17 You should have the ONAP Policy Framework running in Docker and started the Policy Framework with *docker-compose*.
18
19
20 Test that the ONAP Policy Framework is up and is empty
21 ------------------------------------------------------
22
23 **Step 1:** Run the command below.
24
25         .. code-block:: bash 
26
27            curl --silent --user @1b3rt:31nst31n -X GET http://localhost:9696/policy/pdp/engine/controllers/beijing | python -m json.tool
28
29         You should get a response similar to the following:
30
31         .. code-block:: bash 
32
33            {
34                "error": "beijing not found"
35            }
36
37 Install the Beijing policy controller
38 ---------------------------------------
39
40 **Step 1:** Log onto the Drools PDP.  
41
42         .. code-block:: bash 
43
44            docker exec -it drools bash
45
46         You now have a shell open in the Drools PDP container running in docker
47
48
49 **Step 2:** Create a temporary directory for controller installation
50
51         .. code-block:: bash
52
53            mkdir /tmp/apps-controlloop
54            cd /tmp/apps-controlloop
55
56 **Step 3:** Download the latest controller from Nexus (1.2.0 at the time of writing)
57
58         .. code-block:: bash 
59
60            wget https://nexus.onap.org/content/repositories/releases/org/onap/policy/drools-applications/controlloop/packages/apps-controlloop/1.2.0/apps-controlloop-1.2.0.zip
61
62         Alternatively, you can build the drools-applications component of the Policy Framework from source and install it from the following location on your build host
63
64         .. code-block:: bash 
65
66            ~/.m2/repository/org/onap/policy/drools-applications/controlloop/packages/apps-controlloop/1.2.0/apps-controlloop-1.2.0.zip
67
68
69 **Step 4:** Unzip the controller
70
71         .. code-block:: bash 
72
73            unzip apps-controlloop-1.2.0.zip
74
75 **Step 5:** Update the installation script to install the Beijing controller
76
77         .. code-block:: bash 
78
79            vi apps-controlloop-installer
80
81            # Change the line
82            #    "features enable controlloop-amsterdam"
83            # to
84            #    "features enable controlloop-beijing"
85
86  
87 **Step 6:** Stop the policy engine
88
89         .. code-block:: bash 
90
91            policy stop
92
93 **Step 7:** Install the controller by running the controller installation script
94
95         .. code-block:: bash 
96
97            ./apps-controlloop-installer
98  
99 **Step 8:** Install the *controlloop-utils* Drools PDP feature to allow standalone execution of control loop policies
100
101         .. code-block:: bash 
102
103            features install controlloop-utils
104            features enable controlloop-utils
105  
106 **Step 9:** Start the policy engine
107
108         .. code-block:: bash 
109
110            policy start
111
112         Monitor the CPU for a few minutes with the top command until it settles down after the policy start.
113
114 **Step 10:** Check if the Beijing controller is loaded 
115         .. code-block:: bash 
116  
117            curl --silent --user @1b3rt:31nst31n -X GET http://localhost:9696/policy/pdp/engine/controllers/beijing | python -m json.tool
118
119         You should get a response similar to the following:
120
121         .. code-block:: bash 
122            :caption: Beijing Controller JSON Response
123            :linenos:
124
125                "alive": true,
126                "drools": {
127                    "alive": true,
128                    "artifactId": "controller-beijing",
129                    "brained": true,
130                    "groupId": "org.onap.policy.drools-applications.controlloop.common",
131                    "locked": false,
132                    "modelClassLoaderHash": 1562533966,
133                    "recentSinkEvents": [],
134                    "recentSourceEvents": [],
135                    "sessionCoordinates": [
136                        "org.onap.policy.drools-applications.controlloop.common:controller-beijing:1.2.0:beijing"
137                    ],
138                    "sessions": [
139                        "beijing"
140                    ],
141                    "version": "1.2.0"
142                },
143                "locked": false,
144                "name": "beijing",
145                "topicSinks": [
146                    {
147                        "alive": true,
148                        "allowSelfSignedCerts": false,
149                        "apiKey": "",
150                        "apiSecret": "",
151                        "locked": false,
152                        "partitionKey": "86d1234b-e431-4191-b7c6-56d2d2909a97",
153                        "recentEvents": [],
154                        "servers": [
155                            "vm1.mr.simpledemo.openecomp.org"
156                        ],
157                        "topic": "APPC-CL",
158                        "topicCommInfrastructure": "UEB",
159                        "useHttps": false
160                    },
161                    {
162                        "alive": true,
163                        "allowSelfSignedCerts": false,
164                        "apiKey": "",
165                        "apiSecret": "",
166                        "locked": false,
167                        "partitionKey": "dea0f440-0232-4f63-b79e-6d51f3674d35",
168                        "recentEvents": [],
169                        "servers": [
170                            "vm1.mr.simpledemo.openecomp.org"
171                        ],
172                        "topic": "APPC-LCM-READ",
173                        "topicCommInfrastructure": "UEB",
174                        "useHttps": false
175                    },
176                    {
177                        "alive": true,
178                        "allowSelfSignedCerts": false,
179                        "apiKey": "",
180                        "apiSecret": "",
181                        "locked": false,
182                        "partitionKey": "2918d779-870d-429b-b469-78677d027deb",
183                        "recentEvents": [],
184                        "servers": [
185                            "vm1.mr.simpledemo.openecomp.org"
186                        ],
187                        "topic": "POLICY-CL-MGT",
188                        "topicCommInfrastructure": "UEB",
189                        "useHttps": false
190                    }
191                ],
192                "topicSources": [
193                    {
194                        "alive": true,
195                        "allowSelfSignedCerts": false,
196                        "apiKey": "",
197                        "apiSecret": "",
198                        "consumerGroup": "31740f8e-f878-4347-849e-3b3352c28dff",
199                        "consumerInstance": "drools",
200                        "fetchLimit": 100,
201                        "fetchTimeout": 15000,
202                        "locked": false,
203                        "recentEvents": [],
204                        "servers": [
205                            "vm1.mr.simpledemo.openecomp.org"
206                        ],
207                        "topic": "PDPD-CONFIGURATION",
208                        "topicCommInfrastructure": "UEB",
209                        "useHttps": false
210                    },
211                    {
212                        "alive": true,
213                        "allowSelfSignedCerts": false,
214                        "apiKey": "",
215                        "apiSecret": "",
216                        "consumerGroup": "429aa858-633e-43dc-8619-7004e133d650",
217                        "consumerInstance": "drools",
218                        "fetchLimit": 100,
219                        "fetchTimeout": 15000,
220                        "locked": false,
221                        "recentEvents": [],
222                        "servers": [
223                            "vm1.mr.simpledemo.openecomp.org"
224                        ],
225                        "topic": "unauthenticated.DCAE_CL_OUTPUT",
226                        "topicCommInfrastructure": "UEB",
227                        "useHttps": false
228                    },
229                    {
230                        "alive": true,
231                        "allowSelfSignedCerts": false,
232                        "apiKey": "",
233                        "apiSecret": "",
234                        "consumerGroup": "1bf6854d-a0f1-4d03-baaf-084e6f365a86",
235                        "consumerInstance": "drools",
236                        "fetchLimit": 100,
237                        "fetchTimeout": 15000,
238                        "locked": false,
239                        "recentEvents": [],
240                        "servers": [
241                            "vm1.mr.simpledemo.openecomp.org"
242                        ],
243                        "topic": "APPC-CL",
244                        "topicCommInfrastructure": "UEB",
245                        "useHttps": false
246                    },
247                    {
248                        "alive": true,
249                        "allowSelfSignedCerts": false,
250                        "apiKey": "",
251                        "apiSecret": "",
252                        "consumerGroup": "3f0d7fdf-956d-4749-be54-1adb32ccfa4f",
253                        "consumerInstance": "drools",
254                        "fetchLimit": 100,
255                        "fetchTimeout": 15000,
256                        "locked": false,
257                        "recentEvents": [],
258                        "servers": [
259                            "vm1.mr.simpledemo.openecomp.org"
260                        ],
261                        "topic": "APPC-LCM-WRITE",
262                        "topicCommInfrastructure": "UEB",
263                        "useHttps": false
264                    }
265                ]
266            }
267
268
269
270 Install the Beijing vCPE Policy
271 ---------------------------------
272
273 We now install the Beijing policies for the vCPE, vFirewall, vDNS & VOLTE use cases.
274
275 **Step 1:** Log onto (or remain logged onto) the Drools PDP.  
276
277         .. code-block:: bash 
278
279            docker exec -it drools bash
280
281         You now have a shell open in the Drools PDP container running in docker
282
283 **Step 2:** Check that the Beijing policies are not loaded by querying for Drools facts
284
285         .. code-block:: bash 
286
287            curl --silent --user @1b3rt:31nst31n -X GET http://localhost:9696/policy/pdp/engine/controllers/beijing/drools/facts/beijing | python -m json.tool
288
289         Expect the response {} indicating no policies are loaded.
290
291 **Step 3:** Create a temporary directory for policy installation
292
293         .. code-block:: bash
294
295            mkdir /tmp/basex-controlloop
296            cd /tmp/basex-controlloop
297
298 **Step 4:** Extract the policies from the control loop zip file previously downloaded from Nexus and expanded in steps 3 and 4 above.
299
300         .. code-block:: bash 
301
302            tar zxvf /tmp/apps-controlloop/basex-controlloop-1.2.0.tar.gz
303  
304 **Step 5:** Install the Beijing policy rules, the script asks for a number of input parameters, accept the default for all parameters
305
306         .. code-block:: bash 
307
308            bin/create-cl-beijing
309
310            # - Type Y when asked for confirmation of parameters
311            # - Accept /tmp as the install directory
312            # - Type Y to agree to creation of a Maven Artifact
313
314  
315 **Step 6:** Maven artifact creation now proceeds.  After some minutes, confirmation is requested for deployment of rules into Maven. 
316         .. code-block:: bash 
317
318            # - Type Y to deploy the rules. 
319
320         The rules are deployed into Maven. Expect the rule deployment process to take a number of minutes, perhaps 10 minutes.
321
322
323 **Step 7:** Copy the Beijing properties file into the Drools PDP configuration directory. This file configures the Drools PDP with the Beijing policies
324
325         .. code-block:: bash 
326
327            cp /tmp/beijing/beijing-controller.properties /opt/app/policy/config
328  
329 **Step 8:** Stop and start the Drools PDP
330
331         .. code-block:: bash 
332
333            policy stop
334            policy start
335
336         Again, monitor the processes with top and wait for the PDP to fully start.
337
338 **Step 9:** Push the Beijing policy facts to the Drools PDP
339
340         .. code-block:: bash 
341
342            bin/push-policies-beijing
343
344            # When the script prompts for the path to the properties file, enter the following:
345            #    /opt/app/policy/config/beijing-controller.properties
346
347
348 **Step 10:** Now verify that the Beijing policies are loaded, there should be four facts (one per use case) in the Drools PDP
349
350         .. code-block:: bash 
351
352            curl --silent --user @1b3rt:31nst31n -X GET http://localhost:9696/policy/pdp/engine/controllers/beijing/drools/facts/beijing | python -m json.tool
353
354         Expect the response:
355
356         .. code-block:: bash 
357
358            {
359               "org.onap.policy.controlloop.params.ControlLoopParams": 4
360            }
361
362
363 Execute the vCPE Use Case Manually
364 ----------------------------------
365
366 You can now run the vCPE Policy use case manually using the HowTos below:
367     * `Tutorial: Testing the vCPE use case in a standalone PDP-D <tutorial_vCPE.html>`_
368     * `Tutorial: Testing the vDNS Use Case in a standalone PDP-D <tutorial_vDNS.html>`_
369     * `Tutorial: Testing the vFW flow in a standalone PDP-D <tutorial_vFW.html>`_
370     * `Tutorial: Testing the VOLTE Use Case in a standalone PDP-D <tutorial_VOLTE.html>`_
371
372
373 .. note:: 
374         1. You should check that the topic names you use match those in the Beijing configuration file */opt/app/policy/config/beijing-controller.properties*.
375         2. You should ensure that you change to the directory */tmp/beijing* prior to running those HowTos
376
377
378
379 .. Installation of Beijing Controller and Policies : https://wiki.onap.org/display/DW/ONAP+Policy+Framework%3A+Installation+of+Beijing+Controller+and+Policies
380
381
382
383 End of Document
384