All about installing and updating your UI Bakery self-hosted version.

This guide describes how to deploy a ui-bakery on-prem via install.sh script.

Follow the link or search for "UI Bakery" on the DigitalOcean marketplace to create a droplet with a pre-configured UI Bakery instance.

To update your UI Bakery license key, you need to change the corresponding variable:

UI_BAKERY_LICENSE_KEY=key_value

For the Docker Compose setup, the environment variables are located in ui-bakery-on-premise/.env file. To restart your instance, use the following command:

docker compose down
docker compose up -d

To deploy UI Bakery to an Azure virtual machine, follow these steps:

1. Open Azure Portal and in the search field at the top type in Virtual machines and select this item in the result search window.

2. Click on the + Create button in the top left corner and select Azure Virtual machine in the menu.

3. Select an image of Ubuntu 18.04 or higher.

4. For the instance size, select the minimum Standard_F2s_v2 - 2 vCPUs, 4 GiB memory.

5. In the Administrator account section in the Authentication type menu item, select SSH public key, and it will generate the keys after VM creation.

6. In Inbound port rules leave SSH(22) as by default.

7. In the Networking tab, select existing or create a new Virtual Network and Subnet used by this VM.

8. In NIC network security group select Advanced.

9. In Configure network security group click Create new.

10. Click + Add an inbound rule.

11. Add {BakeryPort} (use 3030 by default, you will need to select the same port during UI Bakery installation later) in the Destination port ranges.

12. In Protocol Choose TCP.

13. Click Add.

14. Check that SSH (TCP/22) is configured by default. If not, add it manually using the same algorithm as for {BakeryPort}.

15. Click Ok to finish creating a Network security group.

16. Click Review + create.

17. Click Create.

18. After creating and running the virtual machine, connect to it from outside using SSH protocol.

19. Run this command preferably from the /home Linux directory to download, install and launch UI Bakery:

20. Upon request, enter the previously received license code, hosting URL - Azure Virtual Machine IP address, and port ({BakeryPort} which you selected in the earlier steps 3030 by default).

21. After the installation is completed and launched, enter the bakery from a browser on your local machine at http://{Public IP address Azure VM}:{BakeryPort}.

UI Bakery installation is ready for production out of the box. However, there is a bunch of additional setup steps we recommend following:

• Put your instance behind HTTPS.

• Use a standalone database.

• Enable automatic backups for instance and database machines.

• Lock the UI Bakery version by setting a specific value for the UI_BAKERY_VERSION environment variable.

• Store your environment variables in a secure place like a secrets manager or a key vault. Make sure you override the following variables:

If you have used the install script, then your .env file already contains unique values for those vars. Otherwise, use .

Additional steps and information after installing the self-hosted version.

Requirements

Ensure your Kubernetes cluster meets the minimum requirements of 4 CPUs and 8 GiB of memory for this tutorial.

You either have to run a or make sure standard PersistentVolumeClaim exists in your cluster.

To deploy UI Bakery to an Azure container instance, follow these steps:

1. Login docker to Azure.

1. Create a docker context.

1. Use new context.

If you want to generate custom secrets values, you can do this right from your console using a simple command.

You can use the openssl command (commonly available on many Unix-based systems) combined with tr and head commands. Here's how you can do it for each of your requirements:

Alternatively, you can also use urandom to generate secrets:

UI Bakery supports running its self-hosted version on Windows OS.

In order to install it, follow the steps below:

1. Install .

are a crucial part of configuring your UI Bakery On-Premise installation. They can control various settings, including your , , and application behavior. Here's how you can modify them.

After the installation of UI Bakery On-Premise, a directory named ui-bakery-on-premise is created. Within this directory, you will find a file named .env. This file contains the for your instance.

To modify any variable, such as your license key or other settings:

1. Open the .env file using a text editor. You can do this through the command line or by navigating through the file explorer to ui-bakery-on-premise

[::]:3030 failed (97: Address family not supported by protocol...

When installing or starting the server, you might encounter an error related to Nginx, as shown below:

This error indicates a problem with Nginx attempting to open a socket on an IPv6 address, which might not be supported in your network configuration.

UI Bakery consists of that may need to be scaled using different approaches. The default resource specifications outline the minimum requirements for each service, but you might want to adjust these based on your specific solution and usage needs.

All services are stateless (except databases) and can be scaled using either HorizontalPodAutoscaler or by setting replicas in the deployment specification. However, scaling every service may not be necessary.

The bakery-gateway, bakery-front, and workbench-front services are simple NGINX applications that provide static resource delivery and request routing. These services are resource-efficient and typically do not require scaling.

The automation, datasource and python-runtime services may need scaling if your solution involves lots of automation runs, datasource requests or Python code executions. Since it is a Node.js app, assigning more than one CPU is not necessary. However, such features heavily rely on memory when handling large datasets. For the bakery-back service, running multiple small replicas might be less efficient than a single instance with more resources. We recommend increasing container CPU and memory resources based on your load.

UI Bakery self-hosted version is a set of services, some of which are optional. The same core principles apply whether you deploy it using Docker Compose or Kubernetes.

Below is a diagram illustrating UI Bakery containers and the relationships between them. Arrows indicate the direction of requests between containers/services.

All UI Bakery containers are stateless. Certain containers are optional and can be safely removed if their functionality is not required. Check out what these containers stand for:

• bakery-gateway acts as an NGINX-based gateway and reverse proxy. Routes incoming client requests to the appropriate internal services.

• Install docker 20.10.11 version or higher, and docker compose 1.29.2 version or higher.

• Start docker daemon.

• Get on-premise configuration files:

• Get the license key from the UI Bakery team.

• Run ./setup.sh:

  • Enter the license key;

  • Enter the port (leave empty for local installation, 3030 port will be used);

  • Enter the server URL (leave empty for local installation).

• Run docker compose up -d to start the containers;

• Wait until all containers are up and running;

• Open port 3030 or UI_BAKERY_PORT (if it was modified in .env file or entered in ./setup.sh) to access UI Bakery instance, then you can create a new account.

To deploy UI Bakery to a Google cloud compute engine virtual machine, follow these steps:

1. Open Google Cloud Console. On your project page, select Navigation Menu - Compute Engine - VM instances.

2. Select Create an instance - New Vm instance.

3. Input bakery in Name. Select region and zone.

4. Select E2 in Series field and e2-medium in Machine Type field in the block Machine configuration - Machine family - General-purpose.

5. Press Change button in block Boot Disk.

6. Select Ubuntu in the Operation System, Ubuntu 18.04 LTS or higher in the Version and input 20 in Size (GB). Click Select button.

7. Click Create button at the bottom of the page.

8. On your project page, select Navigation Menu - VPC Network - Firewall and press Create a firewall rule button.

9. Input bakery in Name and select All instances in the network in Targets.

10. Input 0.0.0.0/0 in Source IPv4 ranges.

11. Go to the block Protocols and ports. Select Specified protocols and ports and TCP, input {BakeryPort} (use 3030 by default, you will need to select the same port during UI Bakery installation later) in the Port.

12. Click Create button at the bottom of the page.

13. On your project page, select Navigation Menu - Compute Engine - VM instances.

14. Select VM instance Bakery and press SSH - Open in Browser Window. This will open the SSH-in-browser window.

15. Run this command preferably to download, install and launch UI Bakery:

16. Upon request, enter the previously received license code, hosting URL - External IP address VM Instance, and port ({BakeryPort} which you selected in the earlier steps 3030 by default).

17. After the installation is completed and launched, enter the UI Bakery from a browser on your local machine at http://{External IP address Vm Instance}:{BakeryPort}.

This guide shows how to deploy UI Bakery on AWS EKS using Fargate. It is assumed that you have an active AWS account and have copied the repository containing the necessary configuration files for the deployment process.

1. Create cluster with eksctl:

   • Install eksctl if it's not already installed.

   • Run eksctl create cluster -f ./templates/eksctl-fargate.yaml. If necessary, you can modify the region and cluster name specified in the file to match your desired configurations.

   • Once the command execution is finished, you will have successfully created your AWS EKS cluster.

2. Set up the MySQL database required for UI Bakery on AWS RDS.

   • Create a new RDS instance in your AWS account. It should have MySQL 8+ engine and be accessible by the cluster. Configure the remaining database settings according to your requirements.

   • Create database and user with the following permissions: GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, REFERENCES, INDEX, ALTER, LOCK TABLES, EXECUTE, CREATE ROUTINE, ALTER ROUTINE

3. Configure the Elastic Load Balancer (ELB) for your UI Bakery deployment

   • Verify that all the cluster subnets have the required tags:

     • Each subnet should have the tag kubernetes.io/cluster/ui-bakery=shared.

4. Deploy UI Bakery with the following command kubectl apply -f ./kubernetes

The standard UI Bakery configuration includes a database running in Docker. For production environments, we recommend using a standalone database.

Step 1. Install MySQL

UI Bakery requires MySQL 8+ version.

Step 2. Create database and user

Use the following script to create database and user:

Ensure you have updated the password and host details. If the database should be accessible from external networks, you need to modify the bind-address setting in the MySQL configuration file.

Step 3. Update UI Bakery to use a new database

the following environment variables and restart UI Bakery:

To stop running the embedded database, remove the db service from the docker-compose.yml file.

How to migrate data from the default db to a standalone

If you need to move data from an embedded database to a standalone one, follow these steps:

Step 0. Reduce the database size (Optional)

If you have been using UI Bakery for an extended period, you might notice that your database requires a significant amount of space.

To clear old audit logs and apps model backups connect to db container:

Then run the following script:

Step 1. Create the database dump

Step 2. Apply the dump to the standalone database

Ensure you first create an empty database, then proceed to run the script.

Resource usage

To run a UI Bakery instance, it's recommended to have at least 2 CPUs and 4 GiB of memory. For handling hundreds or thousands of simultaneous user sessions, or gigabytes of data in automation, you may need to increase these resources. It's challenging to specify the exact resource requirements, so we recommend monitoring resource usage and adjusting based on demand.

When you deploy UI Bakery using Docker Compose, each UI Bakery service will consume resources on demand. You may want to adjust resource limits for various UI Bakery services based on your specific needs. If you expect that users might trigger heavy queries leading to overuse of resources, set hard limits in the docker-compose.yml file, for example:

The configuration above limits the datasource service to consuming more than 1 CPU and 1 GiB of memory.

We recommend setting resource limits for the datasource, automation, and python-runtime services if you experience unpredictable loads on these services. The memory limit should be at least twice the size of the processed data.

Replicating UI Bakery services

Not all UI Bakery services are designed to be replicated.

• Replicating is advisable for these services: datasource, automation, and python-runtime. These services execute data requests or run user code. The heavier the datasource requests or the more complex the automation or python code execution, the more resources they may require. However, in most scenarios, these services do not need more than 1 GB of RAM and 1 CPU. If you have a large number of concurrent requests, the better strategy is to scale them horizontally.

• The bakery-back service is designed to be scaled vertically. If you observe high resource consumption on the bakery-back service, we recommend increasing the amount of RAM and CPU allocated to the service instance.

Scaling with docker compose

To accommodate numerous concurrent data sources or automation requests, you may choose to scale some of UI Bakery's services by adjusting the docker-compose.yml file with the replicas config:

Scaling with kubernates

To configure Kubernetes for auto-scaling, add these lines to ui-bakery-datasource.yaml. This will start with 2 instances of the datasource service, allowing scaling up to 4 instances if the CPU load increases.

Please note that the on-premise version differs from the cloud version and is not updated automatically.

On-premise version release notes

You can follow the updates here with the ON-PREMISE RELEASE tag.

Update to the latest version

To update your UI Bakery on-premise version to the latest one, follow the steps below:

1. Take a full backup of the UI Bakery instance.

2. Go to your ui-bakery-on-premise folder:

1. Run ./update.sh that will download new images and restart your instance:

1. If you use Git to manage your apps in UI Bakery, follow to properly migrate the application model.

Update to the specific version

To update your UI Bakery on-premise version to the specific version, follow the steps below:

1. Take a full backup of the UI Bakery instance.

2. Go to your ui-bakery-on-premise folder:

1. Set the UI_BAKERY_VERSION environment variable to the desired version in the .env file.

2. Then restart the system.

1. Optionally delete old images.

1. If you use Git to manage your apps in UI Bakery, follow to properly migrate the application model.

Updating from version 2.25.0 and lower to the new version

If you are on a 2.25.0 UI Bakery version or lower, please follow the guide below to update to a newer version.

1. Create a backup of ui-bakery-on-premise folder:

2. Go to ui-bakery-on-premise folder and run:

3. Comment UI_BAKERY_WORKBENCH_PATH variable by adding # at the beginning of the line in .env file:

• Press control + O to save.

• Press control + X to exit.

4. Run the next command to rerun containers:

5. Check your UI Bakery instance.

Prerequisites

• Install 20.10.11 version or higher

• Create a directory for on-premise configuration files and download setup script:

• Run the setup.sh script to create .env file with required environmental variables: ./setup.sh

Installation

Pulling container images

First of all, pull all the docker images from UI Bakery's Docker container repository.

Note, that you might not need Mysql image in case you are using an external database.

Creating a Docker network for images

This network will be later used by containers to communicate with each other.

Starting containers one by one

In order to start the UI Bakery containers and run them one by one, use the following commands.

db (Internal UI Bakery database)

Used for storing user accounts and project metadata (not needed if an external database is used):

bakery-back

Bakery backend which is responsible for storing user accounts, project metadata, etc.

workbench-front

UI Bakery end-user frontend:

bakery-front

UI Bakery developer and workspace frontend:

datasource

UI Bakery data source connection middleware:

python-runtime

UI Bakery python backend code middleware:

automation

UI Bakery module for creating scheduled jobs and webhooks:

gateway

An entry point for all UI Bakery client requests:

bakery-db

Built-in , available as in UI Bakery:

Updating to the newer version

Pull the new container versions using. You can also pull a specific version by changing the :latest tag to the version that you need.

Stop running containers:

Remove the containers:

Restart all the containers except MySQL (db) and PostgreSQL (bakery-db) as defined in the .

To deploy UI Bakery to an AWS EC2 instance, follow these steps:

1. Open AWS Management Console and select Services - EC2 (Virtual Servers in the Cloud).

2. Select Network & Security - Security Groups. Click Create security group button in the top right corner.

3. Input Bakery in Security group name and Bakery security group in Description.

4. In block Inbound rules, click Add rule button. Select Custom TCP in the Type, input {BakeryPort} (use 3030 by default, you will need to select the same port during UI Bakery installation later) in the Port range and select Anywhere-IPv4 in the Source.

5. In block Inbound rules click Add rule button. Select SSH in the Type and select Anywhere-IPv4 in the Source.

6. Click Create security group.

7. Select Network & Security - Key Pairs. Click Create key pairs button in the top right corner.

8. Input Bakery in Name. Select RCA in Key pair type. Select .pem in Private key file format, if you will be connecting to the VM using OpenSSH, or select .ppk in Private key file format, if you will be connecting to the VM using Putty.

9. Save the key file to the disk of the local machine.

10. Select Instances - Instance Types. Select t2.medium in the Instance types list. Click Action - Launch instance button in the top right corner.

11. Input 'Bakery' in Name.

12. Select an image of Ubuntu Server 18.04 or higher in the Application and OS Images (Amazon Machine Image).

13. Select 'Bakery' in Key pair (login) - Key pair name - required.

14. Select 'Bakery' in Network settings - Select existing security group - Common security groups.

15. Input 20 GiB in Configure storage - 1x.

16. Click Launch instance button in the bottom right corner.

17. After creating and running the virtual machine, connect to it from outside (OpenSSH or Putty) using SSH protocol (use the previously saved key file).

18. Run this command preferably from the /home Linux directory to download, install and launch UI Bakery:

19. Upon request, enter the previously received license code, hosting URL - Public IPv4 address AWS EC2 Instance, and port ({BakeryPort} which you selected in the earlier steps 3030 by default).

20. After the installation is completed and launched, enter the bakery from a browser on your local machine at http://{Public IPv4 address AWS EC2 Instance}:{BakeryPort}.