TinyAutomator brings the power of Waylay automation technology to the edge, in response to the increasing global demand for edge automation solutions.
Here you can find step-by-step instructions on how to install and run TinyAutomator. Once you have done it, please share your experience with us! Create your own automation rules, push data and enjoy the simplicity and easiness of the Waylay platform.
Hardware requirements: Raspberry PI 3 or 4 with 1 Gb RAM (2 Gb recommended), SD card for Raspberry Pi OS 16 Gb (32 Gb recommended)
sudo apt update
sudo apt upgrade
Reboot Raspberry Pi. Re-login after it has started back up and continue with:
curl -sSL https://get.docker.com | sh
sudo usermod $USER -aG docker
exit
<login again to raspberry pi console>
sudo apt-get install -y libffi-dev libssl-dev libnss3-tools
sudo apt install -y python3-dev python3 python3-pip
sudo pip3 install docker-compose
echo "deb http://ftp.de.debian.org/debian sid main" | sudo tee -a /etc/apt/sources.list
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 648ACFD622F3D138
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 0E98404D386FA1D9
sudo apt update
sudo apt install -y libseccomp2
sudo sed -i '$ d' /etc/apt/sources.list
sudo apt update
sudo dphys-swapfile setup
sudo dphys-swapfile swapon
127.0.0.1 localhost standalone.waylay.io
wget -O tinyautomator-raspberrypi.yml https://tinyurl.com/waylay-tinyautomator-alarmsarm
docker-compose -f tinyautomator-raspberrypi.yml up -d
192.168.0.223 standalone.waylay.io
You can check the IP address of your Raspberry Pi by executing the “ip a” command on your Raspberry Pi and finding the IP address assigned to the network interface.
You can also watch the video here:
sudo usermod $USER -aG docker
127.0.0.1 localhost standalone.waylay.io
wget -O tinyautomator-x86.yml https://tinyurl.com/waylay-tinyautomator-alarms
docker-compose -f tinyautomator-x86.yml up -d
This Mac OS installation guide follows the same principles as the Linux one, with specific adaptations.
curl -L https://tinyurl.com/waylay-tinyautomator-alarms --output tinyautomator-x86.yml
docker-compose -f tinyautomator-x86.yml up -d
127.0.0.1 localhost standalone.waylay.io
You can run TinyAutomator inside Amazon AWS EC2 instance. It is possible to do some installation/startup during VM initialization/startup using cloud-init scripting. Amazon AWS EC2 provides auto-generated public DNS name, so you will be able to access your TinyAutomator instance without the need to adjust your /etc/hosts file. Prerequisites: you should install AWS CLI and configure it (you can follow https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html for installation steps and https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html for configuration), create a security group that will open ports 22(SSH),80(HTTP port),443 (HTTPS port), 1883 (MQTT port) and generate a key-pair for ssh communication with your EC2 instance. Here the steps:
wget -O /tmp/cloud-init.txt https://tinyurl.com/tinyautomator-cloud-init
[
{
"DeviceName": "/dev/sda1",
"Ebs": {
"VolumeSize": 16
}
}
]
aws ec2 create-key-pair --key-name tinyautomator-key --output text > tinyautomatorkey.pem
chmod 600 tinyautomatorkey.pem
aws ec2 create-security-group --group-name tinyautomator-sg --description "TinyAutomator security group" --output text > securitygroup.id.txt
aws ec2 authorize-security-group-ingress --group-id $(cat securitygroup.id.txt) --protocol tcp --port 22 --cidr 0.0.0.0/0
aws ec2 authorize-security-group-ingress --group-id $(cat securitygroup.id.txt) --protocol tcp --port 80 --cidr 0.0.0.0/0
aws ec2 authorize-security-group-ingress --group-id $(cat securitygroup.id.txt) --protocol tcp --port 443 --cidr 0.0.0.0/0
aws ec2 authorize-security-group-ingress --group-id $(cat securitygroup.id.txt) --protocol tcp --port 1883 --cidr 0.0.0.0/0
aws ec2 run-instances --image-id $(aws ec2 describe-images --filters 'Name=description,Values="Canonical, Ubuntu, 20.04 LTS, arm64 focal image build on 2021-04-29"' | jq -r '.Images[0].ImageId') --count 1 --instance-type t4g.small --key-name tinyautomator-key --security-group-ids $(cat securitygroup.id.txt) --user-data file:///tmp/cloud-init.txt --block-device-mappings file:///tmp/storage.json
Give it some time to start and deploy all required packages and docker containers. You can log in to your instance by checking the public DNS name of your instance in aws console (URL for ec2 runnning instances overview https://eu-west-2.console.aws.amazon.com/ec2/v2/home?#Instances:instanceState=running ) and check the progress of installation process in file /var/log/cloud-init-output.log. Here is example of that (replace public-dns-name by your instance real public DNS name)
ssh -i tinyautomatorkey.pem ubuntu@public-dns-name
sudo cat /var/log/cloud-init-output.log
Normally once you see last line similar to following line, it means that installation is finished and you can access TinyAutomator using your public DNS name in browser https://public-dns-name-of-your-ec2-instance/:
Cloud-init v. 21.1-19-gbad84ad4-0ubuntu1~20.04.2 running 'modules:final' at Wed, 29 Sep 2021 13:29:14 +0000. Up 16.34 seconds.
You can run TinyAutomator inside Google Cloud Platform VM instance. You can run shell script during VM instance creation which will install required components, docker, download tinyautomator docker compose file, adjust configurations and start tinyautomator. Google Cloud Platform does not auto-create DNS name. You can use free dynamic DNS service providers that can do automatic check and assignment of DNS name to external IP address that will be added by Google Cloud Platform. In example startup script the dynu.com DNS service provider is used. The ddclient will be used to update dynamic DNS in the initial script. So from your side you just need to create an account on dynu.com and create one dynamic DNS name which will be used for your TinyAutomator using their web management console.
Here the steps:
wget -O /tmp/google-init.sh https://tinyurl.com/tinyautomator-google-init
gcloud compute instances create mytiny --project=my-google-project-id --zone=europe-west1-d --machine-type=e2-medium --network-interface=network-tier=PREMIUM,subnet=default --maintenance-policy=MIGRATE --scopes=https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring.write,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/trace.append --tags=http-server,https-server --create-disk=auto-delete=yes,boot=yes,device-name=mytiny,image=projects/ubuntu-os-cloud/global/images/ubuntu-minimal-2004-focal-v20220203,mode=rw,size=20 --no-shielded-secure-boot --shielded-vtpm --shielded-integrity-monitoring --reservation-affinity=any --metadata-from-file=startup-script=/tmp/google-init.sh
Wait some time in order to initialization to finish. Then you will be able to access it via https://your-ddns-name URL.
You can run TinyAutomator inside Microsoft Azure virtual machine instance. Here the steps:
Start a Virtual machine using the Azure portal (or azure CLI).See details about VM creation at https://learn.microsoft.com/en-us/azure/virtual-machines/linux/quick-create-portal?tabs=ubuntu . During creation use following parameters:
Once VM is created and started you can assign DNS name for it. It will be used to configure TinyAutomator services later.
Adjust the inbound port rules to allow incoming traffic for following ports: 22, 80, 443, 1883, 8883. You can do it via Networking settings of started VM instance on Azure portal site.
Login to the started instance using ssh:
ssh -i /path/to/the/ssh.pem clouduser@instance_public_ip
You should install docker and docker-compose. For docker installation follow steps described in https://docs.docker.com/engine/install/ubuntu/ Here the example steps:
sudo apt update
sudo apt-get remove docker docker-engine docker.io containerd runc
sudo apt-get install ca-certificates curl gnupg lsb-release
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
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
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
sudo usermod -aG docker $USER
newgrp docker
curl -SL https://github.com/docker/compose/releases/download/v2.15.1/docker-compose-linux-x86_64 -o docker-compose
chmod +x docker-compose
sudo mv docker-compose /usr/local/bin
{
"log-driver": "json-file",
"log-opts": {
"max-size": "50m",
"max-file": "10"
}
}
sudo systemctl restart docker
wget -O tinyautomator-x86.yml https://tinyurl.com/waylay-tinyautomator-alarms
sed -i 's/standalone.waylay.io/tinydemo.westeurope.cloudapp.azure.com/g' tinyautomator-x86.yml
docker-compose -f tinyautomator-x86.yml up -d
Low-code automation at the edge.
Retrofitting legacy assets for automation enablement.
Runs locally on any Docker-enabled devices, like a Raspberry Pi or laptop.
Install Docker on your device.
Follow the installation instructions on our website.
Implement your automation strategy or experiment freely!
TinyAutomator can be extended with external databases and dashboards such as InfluxDB or Grafana.
Couple it to a Waylay cloud offering to run ML models, manage alarms or offline analytics.