Symphony

(last edit: 02/02/2024)

Symphony is a powerful service orchestration engine that enables the organization of multiple intelligent edge services into a seamless, end-to-end experience. Its primary purpose is to address the inherent complexity of edge deployment by providing a set of technology-agnostic workflow APIs, which are designed to deliver a streamlined experience for users across all device profiles.

Symphony is uniquely capable of providing consistency across the entire software stack, from drivers to containers to configurations and policies. This comprehensive approach ensures that all aspects of your intelligent edge projects are effectively managed and optimized. Moreover, Symphony provides full support for the entire lifecycle of your edge computing initiatives, spanning from the initial deployment to ongoing updates and maintenance.

With Symphony, users can benefit from a powerful and versatile platform that streamlines edge service orchestration and management, while also ensuring seamless integration with existing technology stacks. Whether you are a small business owner or a large enterprise, Symphony is an ideal solution for enhancing the efficiency and effectiveness of your edge computing initiatives.

Symphony Characteristics

• Standard-based

  Symphony is a versatile and standards-based solution that delivers exceptional flexibility and extensibility. It natively runs on Kubernetes, which means users can leverage all existing Kubernetes tooling to interact with Symphony. Moreover, Symphony supports a wide range of popular industrial standards, protocols, and frameworks, including OpenTelemetry, Distributed Application Runtime (Dapr), Message Queuing Telemetry Transport (MQTT), Open Neural Network Exchange (ONNX), Akri, kubectl, Helm, and many others. This broad range of support makes Symphony an ideal solution for organizations seeking to build and deploy edge services that meet their specific needs.

  Symphony also supports running in a standalone mode independent from Kubernetes. All you need is a single Symphony binary and nothing else!

• Meet customers where they are

  Another key advantage of Symphony is its extensibility. It supports the integration of first-party and third-party services, and all Symphony capabilities, including device registry, device updates, and solution deployment, can be replaced with custom implementations. This means that Symphony can be tailored to meet the specific needs of any organization, regardless of their size or complexity.

• Zero-friction adoption

  Symphony's zero-friction adoption approach is another key feature that sets it apart from other solutions. Users can get started with Symphony using a single computer, and there is no need for special hardware, an Azure subscription, or Kubernetes to start experimenting with the solution. Additionally, the same Symphony artifacts used during testing and development can be carried over into production deployments, ensuring a smooth transition and reducing overall deployment time and costs.

• Symphony is platform agnostic

  Symphony was started by Microsoft as a platform-agnostic project, making it an ideal solution for organizations that already use Azure Edge and AI services like Azure IoT Hub, Azure IoT Edge, Azure Cognitive Services, Azure Storage, Azure ML, Azure Monitor, and Azure Arc. However, Symphony is also fully compatible with other non-Azure services or open-source software tools, allowing organizations to modify the solution to meet their specific needs. This flexibility ensures that Symphony meets customers where they are, making it an ideal solution for organizations of all sizes and complexities.

Getting Started

There are several ways to get started with Symphony, including using the CLI tool, Helm, Docker, or the symphony-api binary.

Using Symphony CLI

NOTE: The following GitHub URL is a temporary parking location and is sugject to change.

The easiest way to get started with Symphony is by using Symphony's CLI tool, called maestro. The CLI tool can be installed on Linux, WSL, and Mac using the following command:

wget -q https://raw.githubusercontent.com/eclipse-symphony/symphony/master/cli/install/install.sh -O - | /bin/bash

For Windows, the following PowerShell command can be used:

powershell -Command "iwr -useb https://raw.githubusercontent.com/eclipse-symphony/symphony/master/cli/install/install.ps1 | iex"

After Symphony is installed, you can use maestro to try out sample scenarios.

maestro up

Using Helm

You can also install Symphony using Helm by running the following command:

helm install symphony oci://ghcr.io/eclipse-symphony/helm/symphony --version '0.48.28'

After Symphony is installed, you can use maestro to try out sample scenarios.

Using Docker

You can also install Symphony using Docker with the bundled symphony-api.json or volume mounting your own & injecting its reference via CONFIG env:

docker run -d --name symphony-api -p 8080:8080 -e CONFIG=/symphony-api.json ghcr.io/eclipse-symphony/symphony-api:0.48.28

Using symphony-api binary

You can also run Symphony in standalone mode as a single process by running the following command:

./symphony-api -c ./symphony-api-dev.json -l Debug

Provider Conformance Test Results

Symphony is an extensible system with the concept of providers. For each provider types, we define one or multiple conformance test suites that ensure provider implementations behaves consistently and predictably.

Target Providers

Provider	Basic1
providers.target.adb
providers.target.azure.adu
providers.target.azure.iotedge
providers.target.docker
providers.target.helm
providers.target.http
providers.target.k8s
providers.target.kubectl
providers.target.mqtt
providers.target.proxy
providers.target.script
providers.target.staging
providers.target.win10

1. Basic conformance level requires a provider to properly respond to missing properties

What's Next

• The Symphony Book
• Set up a local environment

Contributing

This project welcomes contributions and suggestions.

Eclipse Contributor Agreement

Before your contribution can be accepted by the project team contributors must electronically sign the Eclipse Contributor Agreement (ECA).

http://www.eclipse.org/legal/ECA.php Commits that are provided by non-committers must have a Signed-off-by field in the footer indicating that the author is aware of the terms by which the contribution has been provided to the project. The non-committer must additionally have an Eclipse Foundation account and must have a signed Eclipse Contributor Agreement (ECA) on file.

For more information, please see the Eclipse Committer Handbook: https://www.eclipse.org/projects/handbook/#resources-commit

Trademarks

This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks or logos is subject to and must follow Microsoft's Trademark & Brand Guidelines. Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. Any use of third-party trademarks or logos are subject to those third-party's policies.