# Welcome beeta is a digital platform for IoT Innovation. Create and deploy data flows tailored to your needs. Welcome to the documentation of beeta.one, your IoT innovation platform. Beeta.one empowers you to easily develop, implement, and offer customised software solutions based on machine and sensor data. Our platform follows three main principles: * **Modularity**: The modular architecture of our platform allows businesses to select and combine the components they need, thus providing a tailored solution that meets their specific requirements. * **No-Code Approach**: With our user-friendly No-Code platform, even non-technical staff can develop, implement, and distribute custom IoT data flows. This lowers the barrier of entry for the process and allows more people in the organisation to contribute to digital transformation. * **Edge Computing**: Edge Computing refers to the practice of processing data near its source, rather than sending it to a remote server for processing. This approach reduces latency, improves speed, and ensures data privacy. By combining these principles, we provide a complete and user-friendly tool for digital transformation. This tool allows you to fully utilise your data, digitise operational processes, and encourage innovation. With our platform, businesses can effectively create, organise, and improve data streams to capture, analyse, and transmit data from machines and sensors. We offer smooth management of data flow implementations across different Edge devices to ensure efficiency and scalability. ## What will I find here? You will find some more detailed explanation of the features of our platform and some guides you can follow. ## Questions & Feedback If you need any additional support or would like to tell as something, please do not hesitate to contact us [via email](mailto:hello@beeta.one). # beeta.builder The modular IoT data flow construction kit.
Our beeta.builder is a powerful graphical user interface that allows you to easily create and configure IoT data flows. It provides an intuitive environment for designing simple linear or complex data flows with multiple inputs and outputs. The building blocks are divided into three categories: Input, Processing and Output. These blocks can be dragged and dropped onto a canvas and linked together to create a data flow. The intuitive drag-and-drop functionality allows you to visually design your data flows without the need for extensive programming knowledge. Each block can be configured directly on the block itself, making setting up the desired functionality simple and straightforward. Define your input sources, apply different processing functions and set output targets - all in one place. You can easily create and configure your own custom data flows to adapt and digitise IoT implementations to meet specific business requirements. The beeta.builder reduces the complexity of managing IoT data flows and allows users to focus on gaining meaningful insights and taking action. # beeta.agent The beeta.one platform utilises special agent software that is installed on edge devices to enable seamless integration and efficient processing of data flows at the edge. This agent serves as an interface between the edge devices and the beeta.one platform and ensures smooth communication and data transfer. The agent is designed to be hardware-independent and compatible with any edge device that supports a Linux distribution and Docker. This flexibility allows for easy implementation and scalability in a variety of edge computing environments. Some of the key features of the agent are: * **Data collection and pre-processing:** the agent collects data from various sensors and machines connected to the edge device. It performs pre-processing tasks such as data filtering, aggregation and transformation to ensure that the data is in the desired format for further processing. * **Secure communication:** The agent establishes secure and encrypted communication channels between the edge devices and the beeta.one platform. This ensures the confidentiality and integrity of the transmitted data and protects it from unauthorised access or manipulation. * **Resource management:** The agent optimises the use of computing resources on the edge devices. It manages the allocation of CPU, memory and storage resources to ensure efficient processing of data flows while maintaining the overall performance of the edge device. * **Edge computing capabilities:** By running the agent on edge devices, beeta.one enables edge computing capabilities. This means that data processing and analysis can be performed directly on the edge devices, reducing the need for data transfer to a central server. This enables real-time decision making and faster response times, especially in scenarios where low latency is critical. You can find the [GitHub repository here](https://github.com/beetaone/beeta-agent). # Building Blocks & SDK
Our platform offers an extensive collection of over 80 building blocks that allows you to create custom data flows and realise the full potential of your IoT implementations. These building blocks, known as "Blocks" on our platform, are released under an open source licence, giving users the ability to review the code and ensure transparency. The blocks are divided into three categories: Input, Processing and Output, and provide a wide range of data processing capabilities. Each block is implemented as a Docker container, which ensures compatibility and scalability. They communicate via a standardised interface that enables the integration of different programming languages within a single data flow. In addition to the pre-built blocks, users can develop custom blocks with our SDK and add them to their data flows. This flexibility enables the integration of specific functions and customised solutions to meet unique business requirements. In order to run the block, the beeta.platform uses a configuration file to tie together the static assets. The configuration file holds basic metadata for that block, as well as configuration parameters for running the block. Additionally, the configuration file points to externally stored assets. Most importantly, the configuration file holds the URL for the container image, which is held in a container registry. Additionally, user interface affordances are held in the configuration file. Through the modular structure of our blocks and the ability to create custom extensions, our platform provides organisations with the flexibility to customise and digitise their IoT implementations to meet specific business needs. # Data Flows
Data Flows are a type of software, built with the beeta.builder and structured in a block-based manner. A Data Flow is made up if several blocks, minimum one of each kind: 1. **Input Blocks**: These are the data sources for the flow, e.g. sensors or structured data. 2. **Processing Blocks**: These blocks manipulate the data and pass it on to the next block. 3. **Output Blocks**: These blocks send the data from the edge device to a specified endpoint, such as a cloud database, dashboard, or messaging service. The input blocks determines the data source(s), the processing blocks decide how the data is processed, enhanced or manipulated, and the egress block identifies the data destination(s) To deploy a Data Flow, it must be set up and configured to meet the platform requirements and the data input type and capacity of the hardware executing the flow. Each block adheres to a communication specification to receive and forward data. This specification outlines the interface between each block. The blocks are standardised so that the beeta.agent can establish and maintain communication between them. In the beeta.builder, a Data Flow is designed using a drag-and-drop interface, with connections represented as connection lines. The deployment of Data Flows, the beeta.agent receives a message from the beeta.builder describing the Data Flow. The Agent downloads any required container images for the blocks composing the application. These images are stored on the host storage. The Agent then runs each block and establishes all connectivity required. Similarly, the Agent can stop or delete Data Flows. # Orchestration Deploy and maintain data flows on a variety of devices simultaneously.
Orchestration is a central feature of our beeta.one platform that enables you to deploy data flows on a variety of edge devices. With orchestration, users can seamlessly manage and coordinate the execution of data flows on multiple edge devices to ensure efficient and scalable data processing. By providing a centralised platform for orchestrating data flows, beeta.one enables you to efficiently distribute workloads, optimise resource usage and scale your deployments on demand. The benefits of beeta.one's orchestration feature are manifold. Firstly, you now can easily deploy and manage data flows on a large number of edge devices regardless of their geographical location. This enables the efficient processing of data close to its source, reducing latency and improving overall system performance. Secondly, orchestration simplifies the management of complex data flow topologies. You can define dependencies between different components of data flows to ensure that data is processed in the correct order and results are delivered accurately. This ensures data integrity and consistency across the entire edge computing infrastructure. In addition, beeta.one's orchestration feature provides scalability and flexibility. Dynamically scale your deployments by adding or removing edge devices as needed without disrupting the overall data flow. This enables seamless expansion and contraction of the edge computing infrastructure according to changing business requirements. In summary, beeta.one's orchestration feature is a powerful platform feature that enables you to deploy and manage data flows on edge devices in small to large fleets. # Hybrid Architecture Best of both worlds. The hybrid architecture of beeta.one combines the advantages of a cloud-based application with local data processing. This approach allows organisations to take advantage of the latest features and capabilities of the cloud-based application, while data processing takes place on-premises to ensure increased security and performance. The cloud-based application, represented by the beeta.one user interface, provides you with an intuitive and user-friendly interface to design and manage their data flows. Users can benefit from the latest updates and features of the cloud-based application to ensure they have access to the most advanced functionalities. However, the actual processing of the data takes place on edge computers that are located on-premise. This means that sensitive data remains within the organisation, addressing data privacy and security concerns. By processing data locally, organisations can benefit from lower latency, improved response times and increased efficiency. The hybrid architecture of beeta.one enables organisations to strike a balance between the benefits of cloud-based applications and the security and benefits of local data processing. It enables seamless integration of the latest cloud-based capabilities while providing the control and compliance required for on-premise processing of sensitive data. # Edge Computing Explained The word 'edge' is a crucial concept in understanding the beeta.platform. **Introduction** Edge computing in the Internet of Things (IoT) refers to the practice of processing and analysing data at the edge of the network, near the source of data generation, rather than sending it to a centralised cloud or data center. This approach helps to reduce latency, improve real-time decision-making, and decrease bandwidth consumption. **Where is the Edge?** The edge in IoT refers to the location where sensors and devices communicate real-time data to a network. It’s the point in the network where the data is initially collected or used. Edge computing brings computation and data storage closer to these devices, allowing data to be gathered and processed at the edge, rather than sending the data back to a data center or cloud. **How Do I Know If I Already Have an Edge Device?** An edge device is a piece of equipment that serves to transmit data between the local network and a data destination. They are able to translate between the protocols used by local devices into the protocols used by IT systems where the data will be further processed. Edge devices are located at the edge of a network and act as intermediaries between IoT devices and IT systems. They can perform local data processing, filtering, and analytics, run applications or algorithms, and have more computational capabilities, storage capacity, and processing power than typical IoT devices. If you have a device in your facility that fits this description, it’s likely an edge device. **Why Do I Need Edge?** Edge computing is essential in IoT for several reasons: 1. **Reduced Latency**: Edge computing reduces latency, enabling faster response times and real-time analytics while optimising bandwidth requirements and easing the burden on the network. 2. **Cost Efficiency**: Processing data at the edge also reduces costs associated with transmitting and storing large volumes of data in the cloud, decreasing reliance on high-capacity cloud infrastructure. 3. **Reliability**: Relying on a centralised cloud introduces a single point of failure. Edge computing distributes the computational load across edge devices, servers, and gateways, ensuring uninterrupted functionality. 4. **Privacy and Security**: It addresses privacy and security concerns by eliminating transmission of sensitive information over the network, reducing the risk of breaches and ensuring compliance with data protection regulations. **Conclusion** In conclusion, edge computing is a critical component of IoT, helping to reduce latency, improve reliability, and enhance the efficiency of data processing. As the IoT continues to grow, the role of edge computing is expected to become increasingly important. # Getting Started Introduction the the basic functionality and structure of the platform. First, you would need to create an account in order to use beeta.one. You can just sign-up yourself either with email and password or user one of the SSO options like "Sign up with Google".
{% hint style="info" %} Feel free to [contact us](mailto:hello@beeta.one) to get an exclusive trial access to beeta.one. {% endhint %} After you sign up and logged in successfully, you will be ask to create your first workspace. **Workspaces** are a collection of devices and flows you can share with others. Multiple users can belong to one workspace and work on the Data Flows or deploy to the devices registered to the workspace. You can have multiple workspaces, depending on your plan. {% hint style="info" %} You can also manage multiple user groups which are called **Organisations.** This feature is available in our premium plan and ist most suitable for managing multiple customers or different organisational groups. {% endhint %} After you created your first workspace, you will arrive to the main dashboard. Here you will find all the flows you have created so far, monitor the flows which are currently deployed or create a new one from scratch.
From the navigation on the left side, you can switch to the devices page which holds all the devices you have registered to your workspace. You can check their status and which flows are deployed on each device. You can also add and register new devices to your workspace from here. You can follow the instructions you find the the guides section on this page.
If you want to change langauges (beeta.one is available in english and german), switch workspaces or change any other setting, you can just link on the lower icon in the navigation bar. # Add Device Step-by-Step guide on how to add a device to your workspace. The beeta.one platform utilises an Agent software that runs on edge devices to facilitate the seamless integration of data flows and enable efficient processing at the edge. This Agent acts as a bridge between the edge devices and the beeta.one platform, ensuring smooth communication and data transfer. The Agent is designed to be hardware-agnostic, compatible with any edge device running a Linux Distribution and with Docker installed. This flexibility allows for easy deployment and scalability across a wide range of edge computing environments. #### Prerequisites * Ensure that your device is running a Linux OS (Ubuntu, Debian, Raspberry Pi OS, or similar recommended). * Install Docker Engine on your device by following the instructions on the official Docker page [here](https://docs.docker.com/engine/install/) or follow the guidance below. * Ensure you have access to the device via the command-line interface (CLI). #### Minimum Hardware Requirements * **Supported Platforms:** x86, AMD64 (x86-64), ARM. * **Processor:** 32-bit, 64-bit recommended * **CPU Speed:** 1GHz * **Memory (DDR3):** 512MB RAM, 2GB+ RAM recommended * **Internal Storage (Onboard Flash):** 4GB. * **External Storage (Disk):** 2GB. ### Registering the Device and Downloading Configuration 1. Log in to the [beeta.one](http://beeta.one/) platform and navigate to the devices page in the side navigation. 2. Click on the "+ New Device" button to add a new device to the platform. 3. Provide a name for your device and select the appropriate device type from the list. If your device type is not listed, select "other" as long as your device fulfils the listed requirements. 4. Submit the form, and your newly created device will appear in the list with the status "registered." 5. Click on the three dots next to your device and select "Download Agent config." This will download a JSON file containing the necessary configuration for the Agent.

Add new device form

### Connect to a Device via SSH Now you need to connect to the device you want to install the Agent on. To securely connect to your device using SSH, follow these steps: 1. **Open the Terminal**: On your local machine, open the terminal. On Linux and macOS, you can do this by pressing `Ctrl + Alt + T` or searching for "Terminal" in your applications menu. On Windows, you can use PowerShell or Command Prompt. 2. **Run the SSH Command**: Use the following command to initiate an SSH connection: ```bash ssh [username]@[host_ip_address] ``` Replace `[username]` with your username on the remote device and `[host_ip_address]` with the IP address of the device you want to connect to. For example: ```bash ssh pi@192.168.1.100 ``` 3. **Confirm the Connection**: If this is your first time connecting to the device, you will be prompted to confirm the connection by typing `yes` and pressing `Enter`. 4. **Enter Your Password**: When prompted, enter the password for the remote device. Note that the terminal will not display characters as you type the password for security reasons. 5. **Access the Command Line Interface**: Once authenticated, you will have access to the command line interface of the remote device, allowing you to run commands as if you were physically present at the machine. 6. **Close the SSH Session**: To end the SSH session, type `exit` and press `Enter`, or use the shortcut `Ctrl + D`. **Example** Here is an example of connecting to a Raspberry Pi with the default username `pi` and an IP address of `192.168.1.100`: ``` bashssh pi@192.168.1.100 ``` After entering the password, you will be logged into the Raspberry Pi's command line interface. **Troubleshooting** If you encounter issues connecting via SSH, ensure that: * The IP address of the remote device is correct. * The SSH server is running on the remote device. * The port (default is 22) is not blocked by a firewall. * The username and password are correct. Next, you will need to install the Docker Engine on your device if you don't already have it. [Follow the instructions on this page.](/guides/add-device/install-docker-engine) ### Installing the Agent on Your Device 1. Connect to your device via the command-line interface (CLI). 2. Copy the previously downloaded configuration file to your device or create a new configuration file on the device by running the following command: ```bash sudo nano agent-conf.json ``` Copy the content from the downloaded JSON file and paste it into the newly created `agent-conf.json` file. Save and close the file. 3. Run the following command to install the Agent on your device, replacing `` with the path to the configuration file: 
curl -sO https://file-service.theone.beeta.one/agent/installer.sh && sh installer.sh <config-file>
4. The installation process will begin and connect your device to your workspace. Once the process is complete, your device will appear in the list with the status "Connected". If you run into trouble the first time, before diving into a deeper troubleshoot, try to run the installer again.

Terminal installation progress

By following these steps, you can easily add a device to your workspace and install the Agent, enabling efficient data collection, preprocessing, and analysis at the edge. This empowers organisations to harness the full potential of edge computing, leading to improved operational efficiency, reduced latency, and enhanced decision-making capabilities. # Install Docker Engine This guide will walk you through the installation of Docker Engine on popular Linux platforms such as Ubuntu, Raspberry Pi OS, Debian, and Alpine Linux. ollow the steps below to get Docker up and running on your system. If you are missing an OS or you would like to learn more about Docker, please visit the official Docker page. **Prerequisites** Before you begin, ensure that you have the following: * A 64-bit version of your Linux distribution. * Sudo privileges on the system. ### Installation Steps You can go directly to the section of your OS: * [Ub](#ubuntu)[untu](#ubuntu) * [Raspberry Pi OS](#raspberry-pi-os) * [Debian](#debian) * [Alpine Linux](#alpine-linux) * [Troubleshooting](#troubleshooting) #### **Ubuntu** 1. **Update the Package Index**: ```bash sudo apt-get update ``` 2. **Install Required Packages**: ```bash sudo apt-get install ca-certificates curl gnupg lsb-release ``` 3. **Add Docker’s Official GPG Key**: ```bash sudo mkdir -p /etc/apt/keyrings curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg ``` 4. **Set Up the Docker Repository**: ```bash echo \ "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null ``` 5. **Install Docker Engine**: ```bash sudo apt-get update sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin ``` 6. **Verify the Installation**: ```bash sudo docker run hello-world ``` #### Raspberry Pi OS 1. **Update the Package Index**: ```bash sudo apt-get update sudo apt-get upgrade ``` 2. **Download and Run the Docker Installation Script**: ```bash curl -fsSL https://get.docker.com -o get-docker.sh sudo sh get-docker.sh ``` 3. **Add Your User to the Docker Group**: ```bash sudo usermod -aG docker $USER ``` 4. **Verify the Installation**: ```bash docker run hello-world ``` #### Debian 1. **Update the Package Index**: ```bash sudo apt-get update ``` 2. **Install Required Packages**: ```bash sudo apt-get install ca-certificates curl gnupg lsb-release ``` 3. **Add Docker’s Official GPG Key**: ```bash sudo mkdir -p /etc/apt/keyrings curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg ``` 4. **Set Up the Docker Repository**: ```bash echo \ "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null ``` 5. **Install Docker Engine**: ```bash sudo apt-get update sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin ``` 6. **Verify the Installation**: ```bash sudo docker run hello-world ``` #### Alpine Linux 1. **Update the Package Index**: ```bash sudo apk update ``` 2. **Install Docker**: ```bash sudo apk add docker ``` 3. **Start the Docker Daemon**: ```bash sudo service docker start ``` 4. **Add Your User to the Docker Group**: ```bash sudo addgroup $USER docker ``` 5. **Verify the Installation**: ```bash docker run hello-world ``` ### Post-Installation Steps After installing Docker, you may want to configure Docker to start on boot: ```bash sudo systemctl enable docker ``` To check the status of Docker: ```bash sudo systemctl status docker ``` ### Troubleshooting If you encounter any issues, ensure that: * Your system meets the prerequisites. * You have followed each step correctly. * You have a stable internet connection during the installation process. As soon as the docker engine is up and running, you can go back to "Add Device" and continue with insalling the Agent on the device. # Create a Block Detailed guide to build your won block with our SDK {% hint style="info" %} This documentation is still under development. Please feel free to [contact us ](mailto:hello@beeta.one)to get access to a the current resources. {% endhint %} Here are links to the open-source references the blocks are based on: [Input Boilerplate](https://github.com/weeve-modules/python-input-module-boilerplate) [Processing Boilerplate](https://github.com/weeve-modules/python-processing-module-boilerplate) [Output Boilerplate](https://github.com/weeve-modules/python-output-module-boilerplate)