CBA
The Controller Blueprint Archived is the overall service design, fully model-driven, package needed to automate the instantiation and any config provisioning operation, such as day0 or day2 configuration.
The CBA is .zip file, comprised of the following structure:
Code Block |
---|
.
├── Definitions
│ ├── blueprint.json
│ ├── artifact_types.json
│ ├── data_types.json
│ ├── node_types.json
│ ├── policy_types.json
│ ├── relationship_types.json
│ ├── resources_definition_types.json
│ └── *-mapping.json
├── Plans
│ ├── ResourceAssignment.xml
│ ├── ConfigAssign.xml
│ └── ConfigDeploy.xml
├── Scripts
│ └── python
│ |
-------------------- To be finished --------------------
This guide is geared to provide information regarding how to do service design to automate instantiation and day0 configuration.
Deck of Cards | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||
Card | | |||||||||
|
Code Block | ||||
---|---|---|---|---|
| ||||
helm serve &
helm repo add local http://127.0.0.1:8879 |
Get the chart
Make sure to checkout the release to use, by replacing $release-tag
in bellow command
Code Block | ||||
---|---|---|---|---|
| ||||
git clone https://gerrit.onap.org/r/oom
git checkout tags/$release-tag
cd oom/kubernetes
make cds |
Install CDS
Code Block | ||||
---|---|---|---|---|
| ||||
helm install --name cds cds |
Result
title | kubectl output |
---|---|
collapse | true |
├── ConfigDeployExample.py │ ├── ResourceResolutionExample.py │ └── __init__.py ├── TOSCA-Metadata │READY
└── TOSCA.meta └── TemplatesSTATUS
RESTARTS AGE
pod/cds-blueprints-processor-54f758d69f-p98c2 0/1 Running 1 2m
pod/cds-cds-6bd674dc77-4gtdf 1/1 Running 0 2m
pod/cds-cds-db-0 1/1 Running 0 2m
pod/cds-controller-blueprints-545bbf98cf-zwjfc 1/1 Running 0 2m
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/blueprints-processor ClusterIP 10.43.139.9 <none> 8080/TCP,9111/TCP 2m
service/cds NodePort 10.43.254.69 <none> 3000:30397/TCP 2m
service/cds-db ClusterIP None <none> 3306/TCP 2m
service/controller-blueprints ClusterIP 10.43.207.152 <none> 8080/TCP 2m
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
deployment.apps/cds-blueprints-processor 1 1 1 0 2m
deployment.apps/cds-cds 1 1 1 1 2m
deployment.apps/cds-controller-blueprints 1 1 1 1 2m
NAME DESIRED CURRENT READY AGE
replicaset.apps/cds-blueprints-processor-54f758d69f 1 1 0 2m
replicaset.apps/cds-cds-6bd674dc77 1 1 1 2m
replicaset.apps/cds-controller-blueprints-545bbf98cf 1 1 1 2m
NAME DESIRED CURRENT AGE
statefulset.apps/cds-cds-db 1 1 2mlabel | Design Time |
---|
Design time
Bellow are the requirements to enable automation for a service within ONAP.
For instantiation, the goal is to be able to automatically resolve all the HEAT/Helm variables, called cloud parameters.
For post-instantiation, the goal is to configure the VNF with initial configuration.
id | Design time |
---|
default | true |
---|---|
label | Prerequisite |
Prerequisite
Gather the cloud parameters:
id | prerequisite |
---|
Card | ||
---|---|---|
| ||
Have the HEAT template along with the HEAT environment file. or Have the Helm chart along with the Values.yaml file (CDS supports, but whether SO → Multicloud support for Helm/K8S is different story) or ... |
Card | ||
---|---|---|
| ||
Have the configuration template to apply on the VNF. XML for NETCONF
|
Create and fill-in the a table for all the dynamic values
While doing so, identify the resources using the same process to be resolved; for instance, if two IPs has to be resolved through the same IPAM, the process the resolve the IP is the same.
label | instantiation |
---|
Here are the information to capture for each dynamic cloud parameters
id | how to resolve |
---|
Card | ||
---|---|---|
| ||
Value will be given as input in the request. |
Card | ||
---|---|---|
| ||
Value will be defaulted in the model. |
label | REST |
---|
Value will be resolved by sending a query to the REST system
Supported Auth type
id | auth |
---|
Card | ||
---|---|---|
| ||
Use token based authentication
|
Card | ||
---|---|---|
| ||
Use basic authentication
|
Card | ||
---|---|---|
| ||
Use SSL basic authentication
|
label | SQL |
---|
Value will be resolved by sending a SQL statement to the DB system
maria-db
supported for nowCard | ||
---|---|---|
| ||
Value will be resolved through the execution of a script. |
These are all the required parameters to process the resolution of that particular resources.
id | input |
---|
Card | ||
---|---|---|
| ||
List of placeholders used for
|
Card | ||
---|---|---|
| ||
List of placeholders used for
|
This is the expected result from the system, and you should know what value out of the response is of interest for you.
If it's a JSON payload, then you should think about the json path to access to value of interest.
label | Data Dictionary |
---|
Data dictionary
For each unique identified dynamic resource, along with all their ingredients, we need to create a data dictionary.
Here are the modeling guideline: Modeling Concepts#resourceDefinition-modeling
Bellow are examples of data dictionary
id | DD |
---|
label | input |
---|
Value will be pass as input.
Code Block | ||||
---|---|---|---|---|
| ||||
{
"tags": "unit-number",
"name": "unit-number",
"property": {
"description": "unit-number",
"type": "string"
},
"updated-by": "adetalhouet",
"sources": {
"input": {
"type": "source-input"
}
}
} |
label | default |
---|
Value will be defaulted.
Code Block | ||||
---|---|---|---|---|
| ||||
{
"tags": "prefix-id",
"name": "prefix-id",
"property" :{
"description": "prefix-id",
"type": "integer"
},
"updated-by": "adetalhouet",
"sources": {
"default": {
"type": "source-default"
}
}
} |
label | rest |
---|
Value will be resolved through REST.
Modeling reference: Modeling Concepts#rest
title | primary-config-data via rest source type |
---|
In this example, we're making a POST request to an IPAM system with no payload.
Some ingredients are required to perform the query, in this case, $prefixId
. Hence It is provided as an input-key-mapping
and defined as a key-dependencies.
Please refer to the modeling guideline for more in depth understanding.
As part of this request, the expected response will be as bellow. What is of interest is the address
field, as this is what we're trying to resolve.
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
{
"id": 4,
"address": "192.168.10.2/32",
"vrf": null,
"tenant": null,
"status": 1,
"role": null,
"interface": null,
"description": "",
"nat_inside": null,
"created": "2018-08-30",
"last_updated": "2018-08-30T14:59:05.277820Z"
} |
To tell the resolution framework what is of interest in the response, the path
property can be used, which uses JSON_PATH, to get the value.
Code Block | ||||
---|---|---|---|---|
| ||||
{
"tags" : "oam-local-ipv4-address",
"name" : "create_netbox_ip",
"property" : {
"description" : "netbox ip",
"type" : "string"
},
"updated-by" : "adetalhouet",
"sources" : {
"primary-config-data" : {
"type" : "source-rest",
"properties" : {
"type" : "JSON",
"verb" : "POST",
"endpoint-selector" : "ipam-1",
"url-path" : "/api/ipam/prefixes/$prefixId/available-ips/",
"path" : "/address",
"input-key-mapping" : {
"prefixId" : "prefix-id"
},
"output-key-mapping" : {
"address" : "address"
},
"key-dependencies" : [ "prefix-id" ]
}
}
}
} |
title | primary-aai-data via rest source type |
---|
primary-aai-data via type source-rest
TBD
Code Block | ||
---|---|---|
| ||
{
"name" : "primary-aai-data",
"tags" : "primary-aai-data",
"updated-by" : "Steve, Siani <steve.djissitchi@bell.ca>",
"property" : {
"description" : "primary-aai-data",
"type" : "string"
},
"sources" : {
"default": {
"type": "source-default",
"properties": {
}
},
"input": {
"type": "source-input",
"properties": {
}
},
"primary-aai-data" : {
"type" : "source-rest",
"properties": {
"type": "JSON",
"url-path": "$aai-port/aai/v14/network/generic-vnfs/generic-vnf/$vnf-id",
"path": "",
"input-key-mapping": {
"aai-port": "port",
"vnf-id": "vnf-id"
},
"output-key-mapping": {
},
"key-dependencies": [
"port",
"vnf-id"
]
}
}
}
} |
label | db |
---|
Value will be resolved through a database.
Modeling reference: Modeling Concepts#sql
In this example, we're making a SQL to the primary database.
Some ingredients are required to perform the query, in this case, $vfmoudleid
. Hence It is provided as an input-key-mapping
and defined as a key-dependencies.
Please refer to the modeling guideline for more in depth understanding.
As part of this request, the expected response will be as put in value
. In the output-key-mapping
section, that value will be mapped to the expected resource name to resolve.
Code Block | ||||
---|---|---|---|---|
| ||||
{
"name": "vf-module-type",
"tags": "vf-module-type",
"property": {
"description": "vf-module-type",
"type": "string"
},
"updated-by": "adetalhouet",
"sources": {
"primary-db": {
"type": "source-primary-db",
"properties": {
"type": "SQL",
"query": "select sdnctl.demo.value as value from sdnctl.demo where sdnctl.demo.id=:vfmoduleid",
"input-key-mapping": {
"vfmoduleid": "vf-module-number"
},
"output-key-mapping": {
"vf-module-type": "value"
},
"key-dependencies": [
"vf-module-number"
]
}
}
}
} |
label | capability |
---|
Value will be resolved through the execution of a script.
Modeling reference: Modeling Concepts#Capability
In this example, we're making use of a Python script.
Some ingredients are required to perform the query, in this case, $vf-module-type
. Hence It is provided as a key-dependencies.
Please refer to the modeling guideline for more in depth understanding.
As part of this request, the expected response will set within the script itself.
Code Block | ||||
---|---|---|---|---|
| ||||
{
"tags": "interface-description",
"name": "interface-description",
"property": {
"description": "interface-description",
"type": "string"
},
"updated-by": "adetalhouet",
"sources": {
"capability": {
"type": "source-capability",
"properties": {
"script-type": "jython",
"script-class-reference": "Scripts/python/DescriptionExample.py",
"instance-dependencies": [],
"key-dependencies": [
"vf-module-type"
]
}
}
}
} |
The script itself is as bellow.
The key is to have the script class derived from the framework standards.
In the case of resource resolution, the class to derive from is AbstractRAProcessor
It will give the required methods to implement: process
and recover
, along with some utility functions,
such as set_resource_data_value
or addError
.
These functions either come from the AbstractRAProcessor
class, or from the class it derived from.
If the resolution fail, the recover method will get called with the exception as parameter.
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
# Copyright (c) 2019 Bell Canada.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from abstract_ra_processor import AbstractRAProcessor
from blueprint_constants import *
from java.lang import Exception as JavaException
class DescriptionExample(AbstractRAProcessor):
def process(self, resource_assignment):
try:
# get key-dependencies value
value = self.raRuntimeService.getStringFromResolutionStore("vf-module-type")
# logic based on key-dependency outcome
result = ""
if value == "vfw":
result = "This is the Virtual Firewall entity"
elif value == "vsn":
result = "This is the Virtual Sink entity"
elif value == "vpg":
result = "This is the Virtual Packet Generator"
# set the value of resource getting currently resolved
self.set_resource_data_value(resource_assignment, result)
except JavaException, err:
log.error("Java Exception in the script {}", err)
except Exception, err:
log.error("Python Exception in the script {}", err)
return None
def recover(self, runtime_exception, resource_assignment):
print self.addError(runtime_exception.getMessage())
return None
|
label | complex type |
---|
Value will be resolved through REST., and output will be a complex type.
Modeling reference: Modeling Concepts#rest
In this example, we're making a POST request to an IPAM system with no payload.
Some ingredients are required to perform the query, in this case, $prefixId
. Hence It is provided as an input-key-mapping
and defined as a key-dependencies.
Please refer to the modeling guideline for more in depth understanding.
As part of this request, the expected response will be as bellow.
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
{
"id": 4,
"address": "192.168.10.2/32",
"vrf": null,
"tenant": null,
"status": 1,
"role": null,
"interface": null,
"description": "",
"nat_inside": null,
"created": "2018-08-30",
"last_updated": "2018-08-30T14:59:05.277820Z"
} |
What is of interest is the address
and id
fields. For the process to return these two values, we need to create a custom data-type, as bellow
Code Block | ||||
---|---|---|---|---|
| ||||
{
"version": "1.0.0",
"description": "This is Netbox IP Data Type",
"properties": {
"address": {
"required": true,
"type": "string"
},
"id": {
"required": true,
"type": "integer"
}
},
"derived_from": "tosca.datatypes.Root"
} |
The type of the data dictionary will be dt-netbox-ip
.
To tell the resolution framework what is of interest in the response, the output-key-mapping section is used. The process will map the output-key-mapping to the defined data-type.
Code Block | ||||
---|---|---|---|---|
| ||||
{
"tags" : "oam-local-ipv4-address",
"name" : "create_netbox_ip",
"property" : {
"description" : "netbox ip",
"type" : "dt-netbox-ip"
},
"updated-by" : "adetalhouet",
"sources" : {
"primary-config-data" : {
"type" : "source-rest",
"properties" : {
"type" : "JSON",
"verb" : "POST",
"endpoint-selector" : "ipam-1",
"url-path" : "/api/ipam/prefixes/$prefixId/available-ips/",
"path" : "",
"input-key-mapping" : {
"prefixId" : "prefix-id"
},
"output-key-mapping" : {
"address" : "address",
"id" : "id"
},
"key-dependencies" : [ "prefix-id" ]
}
}
}
} |
label | Workflow |
---|
Workflows
The following workflows are contracts established between SO, SDNC and CDS to cover the instantiation and the post-instantiation use cases.
Please refer to the modeling guide to understand workflow concept: Modeling Concepts#workflow
id | Workflow |
---|
label | resource-assignment |
---|
resource-assignment
This action is meant to assign resources needed to instantiate the service, e.g. to resolve all the cloud parameters.
Also, this action has the ability to perform a dry-run, meaning that result from the resolution will be made visible to the user.
If user is fine with the result, he can proceed, else, (TDB) he will have opportunity to re-trigger the resolution.
Context
This action is triggered by Generic-Resource-API (GR-API) within SDNC as part of the AssignBB orchestrated by SO.
It will be triggered for the service, and each VNF(s) and VF-Module(s) (referred as entity bellow).
See SO Building blocks Assignment.
Steps
This is a single action type of workflow, hence the target will refer to a node_template of type component-resource-resolution
Inputs
These templates are identified using artifact prefix. See Modeling Concepts#template
So in order to know for which entity the action is triggered, this is required as input is required.
The dry-run functionality requires the ability to retrieve the resolution that has been made later point in time in the process.
The combination of the artifact-name and the resolution-key will be used to uniquely identify the result.
Output
In order to perform dry-run, it is necessary to provide the meshed resolved template as output. To do so, the use of Modeling Concepts#getAttribute expression is required.
Also, as mentioned here Modeling Concepts#resourceResolution, the resource resolution component node will populate an attribute named assignment-params with the result.
Finally, the name of the ouput has to be meshed-template so SDNC GR-API knows how to properly parse the response.
Example
Here is an example of the resource-assignment workflow:
Code Block | ||||
---|---|---|---|---|
| ||||
{
"workflows": {
"resource-assignment": {
"steps": {
"resource-assignment-process": {
"description": "Resource Assign Workflow",
"target": "resource-assignment-process"
}
},
"inputs": {
"artifact-name": {
"required": true,
"type": "string"
},
"resolution-key": {
"required": true,
"type": "string"
},
"resource-assignment-properties": {
"description": "Dynamic PropertyDefinition for workflow(resource-assignment).",
"required": true,
"type": "dt-resource-assignment-properties"
}
},
"outputs": {
"meshed-template": {
"type": "json",
"value": {
"get_attribute": [
"SELF",
"assignment-params"
]
}
}
}
}
}
} |
label | config-assign |
---|
config-assign
This action is meant to assign all the resources and mesh the templates needed for the configuration to apply during post-instantiation (day0 config).
If user is fine with the result, he can proceed, else, (TDB) he will have opportunity to re-trigger the resolution.
Context
This action is triggered by SO after the AssignBB has been executed for Service, VNF and VF-Module. It corresponds to the ConfigAssignBB.
See SO Building blocks Assignment.
Steps
This is a single action type of workflow, hence the target will refer to a node_template of type component-resource-resolution
Inputs
The dry-run functionality requires the ability to retrieve the resolution that has been made later point in time in the process.
The combination of the artifact-name and the resolution-key will be used to uniquely identify the result.
Output
In order to perform dry-run, it is necessary to provide the meshed resolved template as output. To do so, the use of Modeling Concepts#getAttribute expression is required.
Also, as mentioned here Modeling Concepts#resourceResolution, the resource resolution component node will populate an attribute named assignment-params with the result.
Example
Here is an example of the config-assign workflow:
Code Block | ||||
---|---|---|---|---|
| ||||
{
"workflows": {
"config-assign": {
"steps": {
"config-assign-process": {
"description": "Config Assign Workflow",
"target": "config-assign-process"
}
},
"inputs": {
"resolution-key": {
"required": true,
"type": "string"
},
"config-assign-properties": {
"description": "Dynamic PropertyDefinition for workflow(config-assign).",
"required": true,
"type": "dt-config-assign-properties"
}
},
"outputs": {
"dry-run": {
"type": "json",
"value": {
"get_attribute": [
"SELF",
"assignment-params"
]
}
}
}
}
}
} |
label | config-deploy |
---|
config-deploy
This action is meant to push the configuration templates defined during the config-assign step for the post-instantiation.
This action is triggered by SO during after the CreateBB has been executed for all the VF-Modules.
Context
This action is triggered by SO after the CreateVnfBB has been executed. It corresponds to the ConfigDeployBB.
See SO Building blocks Assignment.
Steps
This is a single action type of workflow, hence the target will refer to a node_template of type component-netconf-executor or component-jython-executor or component-restconf-executor.
Inputs
Needed to retrieve the resolution that has been made earlier point in time in the process.
The combination of the artifact-name and the resolution-key will be used to uniquely identify the result.
Output
SUCCESS or FAILURE
Example
Here is an example of the config-deploy workflow:
Code Block | ||||
---|---|---|---|---|
| ||||
{
"workflow": {
"config-deploy": {
"steps": {
"config-deploy": {
"description": "Config Deploy using Python (Netconf) script",
"target": "config-deploy-process"
}
},
"inputs": {
"resolution-key": {
"required": true,
"type": "string"
},
"config-deploy-properties": {
"description": "Dynamic PropertyDefinition for workflow(config-deploy).",
"required": true,
"type": "dt-config-deploy-properties"
}
}
}
}
} |
label | Component |
---|
id | Component |
---|
Card | ||
---|---|---|
| ||
resource-assignment-process |
Card | ||
---|---|---|
| ||
config-assign-process |
Card | ||
---|---|---|
| ||
config-deploy-process |
label | Template |
---|
label | Requirement |
---|
label | Design a new CBA |
---|---|
title | How to create a new CBA from scratch. |
Starting from Dublin release, CDS offers a new package configuration to design the services provisioning. This section describes step by step the procedure of designing a new CBA from scratch.
The CBA package content is well described in CDS Modeling Concepts and also in Design Time section, it shows the structure of a CBA and the different definitions/artifacts. This section will be more focus on the creation of new CBA (The structure: required folder and files), the enrichment procedure to generate the complete config file and the testing properties.
Usecase: Execute remote Ansible playbook to create or delete EVPN
The example of execute Ansible playbook will be illustrated here to describe all the design process.
1. Description before self-service provisioning in CDS: To create or delete an EVPN using Ansible playbook, a request is sent to Ansible with the following parameters and configurations.
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
- job-template-name (Required): Primary key or name of the job template to launch new job.
- Ansible server parameters (required): Remote AWX Server selector parameters.
- limit: Specify host limit for job template to run.
- inventory: Specify inventory for job template to run.
- extra-vars: Action content to run
├── Example config file (yaml format):
├── interface_groups:
├── - <interface group 1>
├── - <interface group 2>
├── ansible_ssh_user: <username>
├── ansible_ssh_pass: <password>
├── netconf_operation: <action> # "remove" to delete an EVPN or "merge" to create EVPN
├── tenant_name: <tenant name>
├── evi_id: <EVI ID> # Required only for delete EVPN
├── site_id: <Site ID>
├── service_db_url: <Service DB URL>
├── topology_url: <TOPOLOGY URL>
├── resource_allocator_url: <Resource allocator URL>
├── evi_description: <EVI Description> |
2. Design the Model-driven CBA for this Ansible service:
The above description shows that there are some actions and artifacts needed before sending the request to Ansible.
- DSL Definition:
We define here all parameters in JSON needed in service provisioning. Ex. Endpoint selector
- Two workflows execution:
- create-evpn: This is a workflow to describe the action that create an EVPN, it defines the input and output needed in this case.
- remove-evpn: This workflow describes the action that delete EVPN, it defines the input and output needed.
In this approach, the two workflows will target the same node template: evpn-executor-process
- Resource resolution: Some parameters need to be resolved to fulfill the template. In this approach, the service will get some parameters from environment file. The designer could define 2 Ansible environments:
Code Block | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||
env-prod.ansible_ssh_user=<username>
env-prod.ansible_ssh_pass=<password>
env-prod.evi_id=<id>
env-prod.service_db_url=<service_db_url>
env-prod.topology_url=<topology_url>
env-prod.resource_allocator_url=<resource_allocator> |
Code Block | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||
env-test.ansible_ssh_user=<username>
env-test.ansible_ssh_pass=<password>
env-test.evi_id=<id>
env-test.service_db_url=<service_db_url>
env-test.topology_url=<topology_url>
env-test.resource_allocator_url=<resource_allocator> |
To resolve these parameters, one way to do that could be to use a capability resource resolution with a python script.
- Directed graph: Describes the sequence flow to complete this Ansible playbook execution.
The above DG set the following sequence: [Resource resolution] → [Component Ansible Execution]
language | xml |
---|---|
title | CONFIG_ExecAnsiblePlaybook.xml |
linenumbers | true |
collapse | true |
└── *-template.vtl
Data Dictionary
A data dictionary defines a specifc resource that can be resolved using the bellow the supported sources.
A data dictionary can support multiple resources.
The main goal of data dictionary is to define generic entity that could be shared accross the service catalog.
Resolution sources
Input
Default
SQL
Default (SDNC DB)
Generic
REST
Default (SDNC MDSAL)
Generic
Capability (scripts)
Python
Kotlin script
Netconf (through Python)
Workflow
A workflow defines an overall action to be taken for the service; it can be composed of a set of node to execute. Currently, workflows are backed by Directed Graph engine.
A CBA can have as many workflow as needed.
Required workflows
The following workflows are contracts being established between SO, SDNC and CDS to cover the instantiation and the post-instantiation use cases.
resource-assignment
This action is meant to assign resources needed to instantiate the service. The goal is to resolved all the HEAT environment variables.
This action is triggered by Generic-Resource-API (GR-API) within SDNC as part of the AssignBB orchestrated by SO. Hence it will be triggered for each VNF(s) and VF-Module(s).
In order to know what to resolved, one input is required, that is the artifact prefix (see bellow for explanation).
artifacts
For each VNF and VF-Module comprising the service, a combinaison of a template and mapping is needed.
The requirement is as follow for VNF:
${vnf-name}-template
${vnf-name}-mapping
and as follow for VF-Module, where the vf-module-label
is actually the name of the HEAT template file.
${vf-module-label}-template
${vf-module-label}-mapping
${vnf-name}
and ${vf-module-label}
is what we call the artifact prefix, so the requirement could be seen as follow:
${artifact-prefix}-template
${artifact-prefix}-mapping
template
The template has to be a resource accumulator template; that be composed of the following sections:
resource-accumulator-resolved-data: defines all the resources that can be resolved directly from the context. It expresses a direct mapping between the name of the resource and its value.
Code Block title RA resolved data collapse true "resource-accumulator-resolved-data": [ { "param-name": "service-instance-id", "param-value": "${service-instance-id}" }, { "param-name": "vnf_id", "param-value": "${vnf-id}" } ]
capability-data: defines what capability to use to create a specific resource, along with the ingredients required to invoke the capability and the output mapping.
Code Block title RA capability payload collapse true { "capability-name": "netbox-ip-assign", "key-mapping": [ { "payload": [ {
...
...
"param-name": "service-instance-id",
...
"param-value": "${service-instance-id}" },
...
{ "param-name": "prefix-id",
...
"param-value": "${private-prefix-id}"
...
}, {
...
"param-name": "vf-module-id", "param-value": "${vf-module-id}"
...
}, {
...
"param-name": "external_key",
...
"param-value": "${vf-module-id}-vpg_private_ip_1"
...
}
...
],
...
3. Create the CBA directory and structure:
Code Block | ||||
---|---|---|---|---|
| ||||
├── iaas-evpn-operations # CBA Root Directory
├── Definitions/
│ └── iaas-evpn-operations.json # CBA configuration file (Mandatory)
├── Environments/ # All environment files contained in this folder are loaded in Blueprint processor run-time
│ └── env-prod.properties
│ └── env-test.properties
├── Plans/
│ └── CONFIG_ExecAnsiblePlaybook.xml # Directed graph artifact
├── Scripts/
│ └── python/
│ └── ResolvProperties.py # Script python used for capability resource resolution
├── TOSCA-Metadata/
│ └── TOSCA.meta # CBA entry point (Mandatory)
├── Templates/
│ └── resolve-evpn-vars-template.jinja # Template file that will dynamic represent the extra-vars payload for ansible.
│ └── resolve-evpn-vars-mapping.json # List of variables that will be resolved to fulfill the template
|
"output-key-mapping": [ { "resource-name": "vpg_private_ip_1", "resource-value": "${vpg_private_ip_1}" } ] } ] }
mapping
Defines the contract of each resource to be resolved. Each placeholder in the template must have a corresponding mapping definition.
A mapping is comprised of:
- name
- required / optional
- type (support complex type)
- dictionary-name
- dictionary-source
- dependencies: this allows to make sure given resources get resolved prior the resolution of the resources defining the dependency.
The dictionary fields reference to a specific data dictionary.
scripts
If any of the mapping uses a source capabbility to resolve a parameters.
config-assign
This action is meant to assign all the resources and mesh the templates needed for the configuration to apply post-instantiation.
This action is triggered by SO during after the AssignBB has been executed for Service, VNF and VF-Module.
artifacts
Combinaison of templates with respective mappings
Scripts if needed
config-deploy
This action is meant to push the configuration templates defined during the config-assign step for the post-instantiation.
This action is triggered by SO during after the CreateBB has been executed for all the VF-Modules.
artifacts
Combinaison of templates with respective mappings
Scripts using Netconf or Restconf to push configure the network element. View file