Quick Start#

Create a new project

We begin with initializing a new project in a directory of your choice.

To create a project, supply the application vendor¹ and the project name as an argument to the edabuilder init command:

edabuilder init --vendor demo example-project && cd example-project

You find yourself in the example-project directory that we just initialized with some top-level project files and directories scaffolded out for you.

Create a Python virtual environment

Create a Python virtual environment since EDA intent applications are written in Python.

If you have uv installed like was suggested in the setting the dev environment section, you can just run:

uv sync

You are free to use any other means to create a venv.

Create an app

Next, create an EDA application by running the edabuilder create app command from the scaffolded ./example-project directory:

Let's call our application - bottom-toolbar - since we will scaffold an app that provisions a bottom toolbar message on the network devices.

edabuilder create app --name bottom-toolbar #(1)!

1. Warning

   If your application name is more than one word, the name must be in a kebab-case format.

An application in EDA is a group that contains one or several resources of the following types:

• application API expressed in a Kubernetes Custom Resource Definition (CRD)
• config and/or state intents that process the configuration and state changes of the resources
• operational workflows
• dashboards

This step should generate the bottom_toolbar directory where you will find the scaffolded layout of the application with no particular logic implemented yet.

Populate the app with the demo app resources

At this stage, you would define your app's API, create the configuration and state intents, define alarm behavior, and create workflows and dashboards.
To keep the quick start simple, we prepared a script that downloads the example BottomToolbar resource and its configuration and state intents into your app directory.

Paste this script into your terminal while in the project's directory:

set -euo pipefail

target="$(pwd)/bottom_toolbar"
tmp="$(mktemp -d)"
trap 'rm -rf "$tmp"' EXIT

commit="4584f841538310a71b318afd83762184e62c66c3"
archive_dir="$tmp/bottom-toolbar-app-$commit"

curl -fsSL "https://github.com/eda-labs/bottom-toolbar-app/archive/$commit.tar.gz" \
-o "$tmp/repo.tar.gz"

tar -xzf "$tmp/repo.tar.gz" -C "$tmp"

source="$archive_dir/bottom_toolbar"

rm -rf "$target/api" "$target/intents" "$target/manifest.yaml"
cp -a "$source/api" "$target/api"
cp -a "$source/intents" "$target/intents"
cp -a "$source/manifest.yaml" "$target/manifest.yaml"

manifest_tmp="$tmp/manifest.yaml"
sed 's/author: eda-labs/author: demo/' \
    "$target/manifest.yaml" > "$manifest_tmp"
mv "$manifest_tmp" "$target/manifest.yaml"

printf 'Downloaded files into %s\n' "$target"

The script downloads the BottomToolbar resource API definition, the Python code behind it, and the manifest file into your app directory.

1. In this guide, a resource (or custom resource) is the declarative API object, while an intent is the Python code that processes changes to that resource.².
2. We cut some corners here, but you can find more in-depth examples in the development section of the documentation.

Deploy the app in development mode

During app development, you can quickly test your changes by deploying the app directly to the EDA cluster. The edabuilder CLI provides a one-shot command:

edabuilder deploy --app bottom_toolbar

The deploy command will generate the necessary artifacts to package the app components in an OCI container image, push it to the container registry deployed for you in the EDA cluster and install the app.

Try the app

After deploying the development version of the app directly to the EDA cluster, you can try it out by creating an instance of the BottomToolbar resource through either the EDA UI or the Kubernetes API using kubectl:

EDA UIKubernetes API/kubectl

In the EDA UI you will see a new resource group named Bottom Toolbars under the Management category:

Selecting the Bottom Toolbars menu will take you to the list of instances of the Bottom Toolbar resource, where you can create a new instance of the resource and commit this transaction.

To use the Kubernetes API, apply a resource in YAML, as shown below:

Resource:

apiVersion: bottom-toolbar.eda.labs/v1alpha1
kind: BottomToolbar
metadata:
  name: demo-toolbar
  namespace: eda
spec:
  message: this is a demo message

Apply:

cat << 'EOF' | kubectl apply -f -
apiVersion: bottom-toolbar.eda.labs/v1alpha1
kind: BottomToolbar
metadata:
  name: demo-toolbar
  namespace: eda
spec:
  message: this is a demo message

EOF

Regardless of the interface you choose, you should see this is a demo message in the bottom toolbar when you log in to an SR Linux switch in your fabric.