This documentation and the Cisco Observability Platform functionalities it describes are subject to change. Data saved on the platform may disappear and APIs may change without notice.

Quickstart

This page helps solution developers to explore and build on the Cisco Observability Platform, and assumes that you have a login on the platform. To get started, follow these steps. If you just need a quick overview, skip the advanced steps (marked ).

Install and configure the Cisco Observability Platform's command line interface, fsoc.
Log into fsoc with your developer credentials:
```
fsoc login
```
Create an empty solution with the fsoc solution init command. Give it a name that is unique across the entire Cisco Observability Platform. For naming rules, see Solution Names.
```
fsoc solution init --name=sample-<your-username>
```
Note: You can also clone an existing solution with the fsoc solution fork command.
Declare your own observability domain, named stores, in a new fmm:namespace object, and add that object to your solution:

a. Create subdirectories within your solution directory: sample-<your-username>/fmm and sample-<your-username>/fmm/objects/namespace.json:
```
mkdir sample-<your-username>/fmm
mkdir sample-<your-username>/fmm/objects
```
b. Create a file named sample-<your-username>/fmm/objects/namespace.json and paste these lines into it:
```
{
    "name": "stores"
}
```
These lines define an fmm:namespace object named stores.

c. Run the contents of sample-<your-username>/manifest.json through a pretty printer like js-beautify -r or an online equivalent like https://jsonformatter.org/jsbeautifier. This makes it easier to edit.

d. In sample-<your-username>/manifest.json, add fmm to the dependencies array, and add the location of the new file to the objects array:
```
{
    "manifestVersion": "1.0.0",
    "name": "sample-<your-username>",
    "solutionVersion": "1.0.0",
    "dependencies": [
        "fmm"
    ],
    "description": "description of your solution",
    "contact": "the email for this solution's point of contact",
    "homepage": "the url for this solution's homepage",
    "gitRepoUrl": "the url for the git repo holding your solution",
    "readme": "the url for this solution's readme file",
    "objects": [
        {
            "type": "fmm:namespace",
            "objectsFile": "fmm/objects/namespace.json"
        }
    ]
}
```

Declare an entity named atm within your new domain in a new fmm:entity object, and add that object your solution:

a. Create a file named sample-<your-username>/fmm/objects/entity.json, and paste these lines into it:

{
    "namespace": {
        "name": "stores",
        "version": 1
    },
    "kind": "entity",
    "name": "atm",
    "displayName": "ATM",
    "lifecycleConfiguration": {
        "purgeTtlInMinutes": 4200,
        "retentionTtlInMinutes": 1440
    },
    "attributeDefinitions": {
        "optimized": [
            "atm.name",
            "atm.namespace"
        ],
        "required": [
            "atm.name",
            "atm.namespace"
        ],
        "attributes": {
            "atm.name": {
                "type": "string",
                "description": "Name of the ATM"
            },
            "atm.namespace": {
                "type": "string",
                "description": "Namespace of the ATM"
            }
        }
    },
    "metricTypes": [
        "stores:fee"
    ]
}

b. In sample-<your-username>/manifest.json, add the location of the new file to the objects array. Your sample-<your-username>/manifest.json should now look like this:

{
    "manifestVersion": "1.0.0",
    "name": "sample-<your-username>",
    "solutionVersion": "1.0.0",
    "dependencies": [
        "fmm"
    ],
    "description": "description of your solution",
    "contact": "the email for this solution's point of contact",
    "homepage": "the url for this solution's homepage",
    "gitRepoUrl": "the url for the git repo holding your solution",
    "readme": "the url for this solution's readme file",
    "objects": [
        {
            "type": "fmm:namespace",
            "objectsFile": "fmm/objects/namespace.json"
        },
        {
            "type": "fmm:entity",
            "objectsFile": "fmm/objects/entity.json"
        }
    ]
}

Make sure you have access to a Tenant that sends metrics, events, logs, and traces to the Cisco Observability Platform.
Declare the MELT types you expect to see in incoming data, and map MELT incoming data to the entities you declared as part of your solution.

Publish your solution to the Cisco Observability Platform:

a. Check and package your solution with the fsoc solution check and fsoc solution validate commands:

fsoc solution check --entities --metrics
cd ..
fsoc solution validate --solution-bundle=sample-<your-username>.zip

Sample output:

The components defined in the file fmm/objects/entity.json are valid definitions of type fmm:entity
Generating solution sample-<your-username> - 1.0.1 bundle archive
Creating sample-<your-username>.zip archive...
Solution sample-<your-username> - 1.0.1 bundle is ready.
Solution bundle sample-<your-username>.zip validated successfully

b. Package and upload your solution with the fsoc solution push command:

fsoc solution push --solution-bundle=sample-<your-username>.zip

Sample output:

Deploying solutionSolution bundle sample-<your-username>.zip was successfully deployed.

c. Verify that your solution is available on the Cisco Observability Platform:

fsoc solution list | grep docs

Subscribe to your solution using the fsoc solution subscribe command:
```
fsoc solution subscribe --name=sample-<your-username>
```
Sample output:
```
Tenant <tenant-id> has successfully subscribed to solution sample-<your-username>
```
After you've subscribed to your solution, the Cisco Observability Platform automatically creates your entities based on incoming MELT data, and displays those entities in its user interface.

Note: The domain and entities that your solution defines will not appear on the UI until the platform creates those entities based on incoming MELT data.
Each time you modify your solution, increment solutionVersion in manifest.json and republish it.

These steps will get you started and illustrate how easy and straightforward it is to create or extend solutions on the Cisco Observability Platform. When you're done with the basics, you can do a lot more, like correlate telemetry across multiple domains, define custom resource mappings, and ultimately even create extensions to the user interface in a low-code, declarative manner.