Delmar/docker_dev
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updates

Browse Source
This commit is contained in:
Julieñ
2025-11-17 18:45:35 +01:00
parent 0f58e3bdff
commit 14d6f9aa73
7607 changed files with 1969407 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
lowcoder/docs/setup-and-run/cloud-and-private-cloud.md Normal file
View File

@@ -0,0 +1,17 @@
# Cloud & Private Cloud
Lowcoder is available online. You can start directly to build Applications.
{% embed url="https://app.lowcoder.cloud" %}
shared cloud free of charge
{% endembed %}
We offer a hosted version of Lowcoder in this shared public cloud for free. We take care of updates, security, and scaling of the underlying infrastructure in a multi-docker deployment.
The public cloud has a central database for all users and applications. We suggest using the public cloud to get to know Lowcoder and make your first tests and Apps.
For companies and enterprises, it is suggested to work in an isolated environment with its own database and infrastructure. For this, we offer a private cloud subscription. Technically it is the same Lowcoder stack and Version - but with an individual and isolated configuration in a region you choose US, EU, or ASEAN.
For private cloud setups, we offer the possibility to connect your own domains.
We host Lowcoder in secure, ISO 9001, ISO 27001, ISAE 3402 & PCI-DSS certified SafeHost data centers, ensuring an exceptionally low risk of flooding, landslides, or earthquakes and the highest data security. Backups are organized every night for all infrastructure components and the Databases as Snapshots.

53
lowcoder/docs/setup-and-run/security.md Normal file
View File

@@ -0,0 +1,53 @@
# Security
## Does Lowcoder store data from my data sources?
No, Lowcoder doesn't store any data returned from your APIs or database queries. Only the connection data of your created Datasources are stored and encrypted.
Lowcoder only serves as a proxy between the client side and your data sources. When you query your APIs or databases, the Lowcoder server connects to the data source with your credentials, forwards the request, and returns the result data to the browser. During the whole process, Lowcoder doesn't store any data from your requests or responses.
Lowcoder also provides a self-hosted version. You can deploy self-hosted Lowcoder images on your own device, on-premise deployment ensures you have total control over your resources and that your data is securely stored.
## Is it safe to log in to my databases on Lowcoder?
Yes, it is safe for the following reasons:
* All sensitive credentials, such as database passwords, are encrypted with [AES-256 encryption](https://en.wikipedia.org/wiki/Advanced\_Encryption\_Standard).
* Sensitive credentials will never be sent to the browser from the server. They are only used at the server side (in the API service) and are never exposed to the browser, the browser will display "Encrypted on the server side" as a placeholder for existing Datasources.
## Other security measures within Lowcoder
Lowcoder provides secure-by-default service.
* All connections on Lowcoder Cloud are encrypted with [TLS](https://en.wikipedia.org/wiki/Public\_key\_certificate).
* Sensitive credentials, such as database access credentials, are encrypted with AES-256.
* Self-hosted Lowcoder instances can be configured with unique encryption salt values.
* Lowcoder Cloud only connects to your databases or APIs through allowed IPs, ensuring that your data won't be exposed to unknown IPs while using our cloud service.
```
(US)
185.122.165.50
185.122.165.51
185.122.165.52
185.122.165.56
(GB)
185.85.242.35
185.85.242.36
185.85.242.37
(DE)
185.44.64.41
185.44.64.42
185.44.64.43
185.44.64.44
185.44.64.47
```
* Lowcoder Cloud service is deployed and hosted on German, UK, and US Data-Centers, which are certified with SOC 1 Type II,PCI-DSS,SOC 2 Type II,ISO 27001,HIPAA and NIST 800-53/FISMA.
* Lowcoder Cloud ensures data redundancy on all cloud instances, so you do not need to worry about a single point of failure or data loss.
* Internal access to Lowcoder Cloud is controlled through [two-factor authentication (2FA)](https://en.wikipedia.org/wiki/Help:Two-factor\_authentication) and audit logs.
## Feedback
Should you have any questions about data security in Lowcoder, please feel free to contact us. We welcome any feedback on our service from security experts and all users.

345
lowcoder/docs/setup-and-run/self-hosting/README.md Normal file
View File

@@ -0,0 +1,345 @@
# Self-hosting
In this article, you will be guided through how to host Lowcoder on your own server using Docker Compose or Docker.
There are multiple ways of installation. We directly support:
* [Single Docker Image](https://github.com/lowcoder-org/lowcoder/tree/main/deploy/docker) to run with a single line of command.
* Multi-Docker Image deployment for scaling scenarios with [Docker Compose](https://github.com/lowcoder-org/lowcoder/blob/main/deploy/docker/docker-compose-multi.yaml)
* Kubernetes-based deployment with [HELM Charts](https://github.com/lowcoder-org/lowcoder/tree/main/deploy/helm).
* [Heroku based deployment](heroku.md)
* [Google Cloud Platform](google-cloud-platform.md)
* [Raspberry Pi](raspberry-pi.md)
## 1) Start easy:
For easy setup and deployment, we provide an [all-in-one image](https://hub.docker.com/r/lowcoderorg/lowcoder-ce) that bundles frontend, backend, and data persistence services altogether in one single container.
{% embed url="https://lowcoder.cloud/images/Screenshot-2023-08-27-at-21.50.36.png" %}
### All-in-one image <a href="#all-in-one" id="all-in-one"></a>
#### Prerequisites
* [Docker](https://docs.docker.com/get-docker/) (version 20.10.7 or above)
* [Docker Compose](https://docs.docker.com/compose/install/) (version 1.29.2 or above)
{% hint style="info" %}
Recommended system spec: 1-core CPU and 2 GB RAM.
Windows users are recommended to use PowerShell for running the commands below.
{% endhint %}
In your working directory, run the following commands to make a directory named `Lowcoder` to store the data of Lowcoder:
```bash
mkdir lowcoder
cd lowcoder
```
#### Deploy
{% tabs %}
{% tab title="Docker Compose (Recommended)" %}
Follow the steps below:
1. Download the configuration file by clicking [docker-compose.yml](https://github.com/lowcoder-org/lowcoder/blob/main/deploy/docker/docker-compose.yaml) or running the curl command:
{% code overflow="wrap" %}
```
curl https://raw.githubusercontent.com/lowcoder-org/lowcoder/main/deploy/docker/docker-compose.yaml -o $PWD/docker-compose.yml
```
{% endcode %}
2. Start the Docker container by running this command:
```bash
docker compose up -d
```
\
The docker image, about 400 MB, is downloaded during the initial start-up.
After downloading, it usually takes less than 30 seconds to start the service.
3. Check the logs by running this command:
```bash
docker logs -f lowcoder
```
When you see `frontend`, `backend`, `redis`, and `mongo` `entered the RUNNING state`, the Lowcoder service has officially started:
4. Visit [**http://localhost:3000**](http://localhost:3000) and click **Sign up**. Lowcoder will automatically create a workspace for you, then you can start building your apps and invite members to your workspace.
{% endtab %}
{% tab title="Docker" %}
Run the command below:
{% code overflow="wrap" %}
```bash
docker run -d --name lowcoder -p 3000:3000 -v "$PWD/stacks:/lowcoder-stacks" lowcoderorg/lowcoder-ce
```
{% endcode %}
{% endtab %}
{% endtabs %}
#### Update to the latest version
{% tabs %}
{% tab title="Docker Compose" %}
Run the following commands to update to the latest Lowcoder image:
```bash
docker compose pull
docker compose rm -fsv lowcoder
docker compose up -d
```
{% endtab %}
{% tab title="Docker" %}
Run the following commands to update to the latest Lowcoder image:
{% code overflow="wrap" %}
```bash
docker pull lowcoderorg/lowcoder-ce
docker rm -fv Lowcoder
docker run -d --name Lowcoder -p 3000:3000 -v "$PWD/stacks:/Lowcoder-stacks" lowcoderorg/lowcoder-ce
```
{% endcode %}
{% endtab %}
{% endtabs %}
## 2) Scale
For bigger expected loads that need scaling in a cluster environment, we provide [separate images of backend and frontend services](https://hub.docker.com/u/lowcoderorg) with a customizable Dockerfile.
{% embed url="https://lowcoder.cloud/images/Screenshot-2023-08-27-at-21.56.51.png" %}
Multi-Image Installation to scale. API-Service & Node-Service can get scaled independently.
{% endembed %}
### Separate images: services in stateless containers <a href="#multi" id="multi"></a>
For bigger expected loads that need scaling in a cluster environment, we offer separate images for stateless containers of the backend and frontend service with a customizable Dockerfile. A well-functioning Lowcoder deployment consists of below services:
* **api-service**: Backend service.
* **node-service**: Backend service.
* **frontend**: Frontend service.
* **MongoDB**: Used for persisting data of users, apps, data sources, etc.
* **Redis**: Used for maintaining user sessions, rate-limiter, etc.
#### Prerequisites
* [Docker-Compose](https://docs.docker.com/compose/install/) (version 1.29.2 or above)
#### Deploy
1. In your working directory, run the following commands to make a directory named `lowcoder` to store the data of Lowcoder:
```bash
mkdir lowcoder
cd lowcoder
```
2. Download the configuration file by clicking [docker-compose-multi.yml](https://github.com/lowcoder-org/lowcoder/blob/main/deploy/docker/docker-compose-multi.yaml) or running the curl command:
<pre class="language-bash" data-overflow="wrap"><code class="lang-bash"><strong>curl https://raw.githubusercontent.com/lowcoder-org/lowcoder/main/deploy/docker/docker-compose-multi.yaml -o $PWD/docker-compose-multi.yml
</strong></code></pre>
3. Modify service configurations in the downloaded Dockerfile according to your needs:
* **mongodb**: Start a new MongoDB instance on your host. You can delete this part and modify the environment variable `MONGODB_URI` of the **api-service** to use your own MongoDB.
* **redis**: Start a new Redis instance on your host. You can delete this part and modify the environment variable `REDIS_URI` of the **api-service** to use your own Redis.
* **api-service**: Required.
* **node-service**: Required.
* **frontend**: Required. Can be optional if you deploy the frontend on CDN.
4. Start Docker containers by running this command:
```bash
docker-compose -f docker-compose-multi.yml up -d
```
5. Visit [**http://localhost:3000**](http://localhost:3000) and click **Sign up**. Lowcoder will automatically create a workspace for you, then you can start building your apps and invite members to your workspace.
## 3) Update to the latest version <a href="#update-multi" id="update-multi"></a>
Run the following commands to update services to the latest in a Docker Compose installation:
{% hint style="info" %}
Please also have a look at this [migration / update guide](lowcoder-version-update.md)
{% endhint %}
```bash
docker-compose -f docker-compose-multi.yml pull
docker-compose -f docker-compose-multi.yml up -d
```
## 4) Customize the deployment
This section shows how to customize deployment configurations by setting environment variables.
If you have already started Docker containers, you need to restart the containers for new configurations to take effect. For example, the way to **restart** your container running an all-in-one image is:
{% tabs %}
{% tab title="Docker-Compose (Recommend)" %}
One single command:
```bash
docker-compose down
docker-compose up -d
```
It picks up configuration changes by stopping containers already in service and recreating new ones.
{% endtab %}
{% tab title="Docker" %}
Run the following commands to stop, remove the container already in service, and start up a new one using the newly customized deployment command.
```bash
docker stop lowcoder
docker rm lowcoder
# run your new docker run command
```
{% endtab %}
{% endtabs %}
Below are examples of configuring the all-in-one image by setting environment variables in `docker-compose.yml`. If you are self-hosting with separate images, modify the `lowcoder-api-service` part of the `docker-compose-multi.yml` file instead.
{% hint style="info" %}
For more information about configurations and environment variables, see [Configuration](https://github.com/lowcoder-org/lowcoder/tree/main/deploy/docker).
{% endhint %}
### Use your own MongoDB and Redis
By default, Lowcoder uses the built-in MongoDB and Redis installed inside the container, and you can replace them with your own MongoDB and Redis clusters.
{% tabs %}
{% tab title="Docker-Compose" %}
Add environment variables `MONGODB_URI` and `REDIS_URI` in `docker-compose.yml` downloaded in your working directory.\
{% endtab %}
{% tab title="Docker" %}
Add environment variables `MONGODB_URI` and `REDIS_URI` to the deployment command, as shown below:
{% code overflow="wrap" %}
```bash
docker run -d --name lowcoder -e MONGODB_URI=YOUR_MONGODB_URI REDIS_URI=YOUR_REDIS_URI -p 3000:3000 -v "$PWD/stacks:/lowcoder-stacks lowcoderorg/lowcoder-ce
```
{% endcode %}
{% endtab %}
{% endtabs %}
### Run as non-root user
By default, the supervisor will run under the user `uid=9001`. You can specify the uid by adding a docker environment variable `LOCAL_USER_ID` and setting its value to a different **number**, such as `10010`.
{% tabs %}
{% tab title="Docker-Compose" %}
Add an environment variable `LOCAL_USER_ID` in `docker-compose.yml` downloaded in your working directory.\
{% endtab %}
{% tab title="Docker" %}
Add an environment variable `LOCAL_USER_ID` to the deployment command, as shown below:
{% code overflow="wrap" %}
```bash
docker run -d --name lowcoder -e LOCAL_USER_ID=10010 -p 3000:3000 -v "$PWD/stacks:/lowcoder-stacks" lowcoderorg/lowcoder-ce
```
{% endcode %}
{% endtab %}
{% endtabs %}
## 5) Secure your deployment
### Install SSL certificate
With an SSL certificate, you can securely visit self-hosted Lowcoder with HTTPS protocol. Here are the steps to install your SSL certificate before starting a container:
{% tabs %}
{% tab title="Docker-Compose" %}
1. Copy `fullchain.pem` and `privkey.pem` to the `$PWD/stacks/ssl` directory.
2. In `$PWD/docker-compose.yml`, change the value of `ports` to `"3443:3443"`.\
{% endtab %}
{% tab title="Docker" %}
1. Copy `fullchain.pem` and `privkey.pem` to the `$PWD/stacks/ssl` directory.
2. Change the `ports` in the deployment command to `3443:3443`, as shown below:
{% code overflow="wrap" %}
```bash
docker run -d --name lowcoder -p 3443:3443 -v "$PWD/stacks:/lowcoder-stacks" lowcoderorg/lowcoder-ce
```
{% endcode %}
{% endtab %}
{% endtabs %}
{% hint style="info" %}
In cases where you have certificates with names: `server.crt` and `server.key`, you need to rename them first as follows:\
`server.crt` => `fullchain.pem`\
`server.key` => `privkey.pem`
{% endhint %}
## 6) Configure the Environment
{% hint style="info" %}
ENV Variables for Helm, Docker Compose, and Docker installations are to find in the most current version on our Github Repository.
{% endhint %}
### ENV Variables for the all-in-one image
This image contains all services needed to run Lowcoder platform in one container.
<table><thead><tr><th width="355">Environment variable</th><th width="263">Description</th><th>Default-Value</th></tr></thead><tbody><tr><td><code>LOWCODER_REDIS_ENABLED</code></td><td>If <strong>true</strong> redis server is started in the container</td><td><code>true</code></td></tr><tr><td><code>LOWCODER_MONGODB_ENABLED</code></td><td>If <strong>true</strong> mongo database is started in the container</td><td><code>true</code></td></tr><tr><td><code>LOWCODER_MONGODB_EXPOSED</code></td><td>If <strong>true</strong> mongo database accept connections from outside the docker</td><td><code>false</code></td></tr><tr><td><code>LOWCODER_API_SERVICE_ENABLED</code></td><td>If <strong>true</strong> lowcoder api-service is started in the container</td><td><code>true</code></td></tr><tr><td><code>LOWCODER_NODE_SERVICE_ENABLED</code></td><td>If <strong>true</strong> lowcoder node-service is started in the container</td><td><code>true</code></td></tr><tr><td><code>LOWCODER_FRONTEND_ENABLED</code></td><td>If <strong>true</strong> lowcoder web frontend is started in the container</td><td><code>true</code></td></tr><tr><td><code>LOWCODER_PUID</code></td><td>ID of user running services. It will own all created logs and data.</td><td><code>9001</code></td></tr><tr><td><code>LOWCODER_PGID</code></td><td>ID of group of the user running services.</td><td><code>9001</code></td></tr><tr><td><code>LOWCODER_MONGODB_URL</code></td><td>Mongo database connection string</td><td><code>mongodb://localhost:27017/lowcoder?authSource=admin</code></td></tr><tr><td><code>LOWCODER_REDIS_URL</code></td><td>Redis server URL</td><td><code>redis://localhost:6379</code></td></tr><tr><td><code>LOWCODER_DB_ENCRYPTION_PASSWORD</code></td><td>Encryption password</td><td><code>lowcoder.org</code></td></tr><tr><td><code>LOWCODER_DB_ENCRYPTION_SALT</code></td><td>Salt used for encrypting password</td><td><code>lowcoder.org</code></td></tr><tr><td><code>LOWCODER_CORS_DOMAINS</code></td><td>CORS allowed domains</td><td><code>*</code></td></tr><tr><td><code>LOWCODER_MAX_REQUEST_SIZE</code></td><td>Lowcoder max request size</td><td><code>20m</code></td></tr><tr><td><code>LOWCODER_MAX_QUERY_TIMEOUT</code></td><td>Lowcoder max query timeout (in seconds)</td><td><code>120</code></td></tr><tr><td><code>LOWCODER_API_SERVICE_URL</code></td><td>Lowcoder API service URL</td><td><code>http://localhost:8080</code></td></tr><tr><td><code>LOWCODER_NODE_SERVICE_URL</code></td><td>Lowcoder Node service (js executor) URL</td><td><code>http://localhost:6060</code></td></tr><tr><td><code>LOWCODER_MAX_ORGS_PER_USER</code></td><td>Default maximum organizations per user</td><td><code>100</code></td></tr><tr><td><code>LOWCODER_MAX_MEMBERS_PER_ORG</code></td><td>Default maximum members per organization</td><td><code>1000</code></td></tr><tr><td><code>LOWCODER_MAX_GROUPS_PER_ORG</code></td><td>Default maximum groups per organization</td><td><code>100</code></td></tr><tr><td><code>LOWCODER_MAX_APPS_PER_ORG</code></td><td>Default maximum applications per organization</td><td><code>1000</code></td></tr><tr><td><code>LOWCODER_MAX_DEVELOPERS</code></td><td>Default maximum developers</td><td><code>100</code></td></tr><tr><td><code>LOWCODER_WORKSPACE_MODE</code></td><td>SAAS to activate, ENTERPRISE to switch off - Workspaces</td><td><code>SAAS</code></td></tr><tr><td><code>LOWCODER_EMAIL_SIGNUP_ENABLED</code></td><td>Control if users create their own Workspace automatic when Sign Up</td><td><code>true</code></td></tr><tr><td><code>LOWCODER_CREATE_WORKSPACE_ON_SIGNUP</code></td><td>IF LOWCODER_WORKSPACE_MODE = SAAS, controls if a own workspace is created for the user after sign up</td><td><code>true</code></td></tr><tr><td><code>LOWCODER_MARKETPLACE_PRIVATE_MODE</code></td><td>Control if not to show Apps on the local Marketplace to anonymous users</td><td><code>true</code></td></tr></tbody></table>
Also, you should set the API-KEY secret, whcih should be a string of at least 32 random characters On linux/mac, generate one eg. with: head /dev/urandom | head -c 30 | shasum -a 256
<table><thead><tr><th width="354">Environment variable</th><th width="263">Description</th><th>Default-Value</th></tr></thead><tbody><tr><td><code>LOWCODER_API_KEY_SECRET</code></td><td>String to encrypt/sign API Keys that users may create</td><td></td></tr></tbody></table>
### ENV Variables for the api-service image
<table><thead><tr><th width="352">Environment variable</th><th width="267">Description</th><th>Default-Value</th></tr></thead><tbody><tr><td><code>LOWCODER_PUID</code></td><td>ID of user running services. It will own all created logs and data.</td><td><code>9001</code></td></tr><tr><td><code>LOWCODER_PGID</code></td><td>ID of group of the user running services.</td><td><code>9001</code></td></tr><tr><td><code>LOWCODER_MONGODB_URL</code></td><td>Mongo database connection string</td><td><code>mongodb://localhost:27017/lowcoder?authSource=admin</code></td></tr><tr><td><code>LOWCODER_REDIS_URL</code></td><td>Redis server URL</td><td><code>redis://localhost:6379</code></td></tr><tr><td><code>LOWCODER_DB_ENCRYPTION_PASSWORD</code></td><td>Encryption password</td><td><code>lowcoder.org</code></td></tr><tr><td><code>LOWCODER_DB_ENCRYPTION_SALT</code></td><td>Salt used for encrypting password</td><td><code>lowcoder.org</code></td></tr><tr><td><code>LOWCODER_CORS_DOMAINS</code></td><td>CORS allowed domains</td><td><code>*</code></td></tr><tr><td><code>LOWCODER_MAX_ORGS_PER_USER</code></td><td>Default maximum organizations per user</td><td><code>100</code></td></tr><tr><td><code>LOWCODER_MAX_MEMBERS_PER_ORG</code></td><td>Default maximum members per organization</td><td><code>1000</code></td></tr><tr><td><code>LOWCODER_MAX_GROUPS_PER_ORG</code></td><td>Default maximum groups per organization</td><td><code>100</code></td></tr><tr><td><code>LOWCODER_MAX_APPS_PER_ORG</code></td><td>Default maximum applications per organization</td><td><code>1000</code></td></tr><tr><td><code>LOWCODER_MAX_DEVELOPERS</code></td><td>Default maximum developers</td><td><code>100</code></td></tr><tr><td><code>LOWCODER_MAX_QUERY_TIMEOUT</code></td><td>Lowcoder max query timeout (in seconds)</td><td><code>120</code></td></tr><tr><td><code>LOWCODER_MAX_REQUEST_SIZE</code></td><td>Lowcoder max request size</td><td><code>20m</code></td></tr><tr><td><code>LOWCODER_WORKSPACE_MODE</code></td><td>SAAS to activate, ENTERPRISE to switch off - Workspaces</td><td><code>SAAS</code></td></tr><tr><td><code>LOWCODER_EMAIL_SIGNUP_ENABLED</code></td><td>Control is users can create their own Workspace when Sign Up</td><td><code>true</code></td></tr></tbody></table>
### ENV Variables for the node-service image
<table><thead><tr><th width="358">Environment variable</th><th width="263">Description</th><th>Default-Value</th></tr></thead><tbody><tr><td><code>LOWCODER_PUID</code></td><td>ID of user running services. It will own all created logs and data.</td><td><code>9001</code></td></tr><tr><td><code>LOWCODER_PGID</code></td><td>ID of group of the user running services.</td><td><code>9001</code></td></tr><tr><td><code>LOWCODER_API_SERVICE_URL</code></td><td>Lowcoder API service URL</td><td><code>http://localhost:8080</code></td></tr></tbody></table>
### ENV Variables for the web frontend image
<table><thead><tr><th width="360">Environment variable</th><th width="263">Description</th><th>Default-Value</th></tr></thead><tbody><tr><td><code>LOWCODER_PUID</code></td><td>ID of user running services. It will own all created logs and data.</td><td><code>9001</code></td></tr><tr><td><code>LOWCODER_PGID</code></td><td>ID of group of the user running services.</td><td><code>9001</code></td></tr><tr><td><code>LOWCODER_MAX_QUERY_TIMEOUT</code></td><td>Lowcoder max query timeout (in seconds)</td><td><code>120</code></td></tr><tr><td><code>LOWCODER_MAX_REQUEST_SIZE</code></td><td>Lowcoder max request size</td><td><code>20m</code></td></tr><tr><td><code>LOWCODER_API_SERVICE_URL</code></td><td>Lowcoder API service URL</td><td><code>http://localhost:8080</code></td></tr><tr><td><code>LOWCODER_NODE_SERVICE_URL</code></td><td>Lowcoder Node service (js executor) URL</td><td><code>http://localhost:6060</code></td></tr></tbody></table>
## Health checks
The API Service has an included health check endpoint from v2.4.1 on.
You can check the health of the running API Service and it's connected MongoDB & Redis by the following HTTP Call:
````bash
```
GET /api/status/health HTTP/1.1
```
````
In response, you will get a 200 Status code if the service is up and running and a JSON like this:
```json
{
"status": "UP",
"components": {
"mongo": {
"status": "UP",
"components": {
"reactiveMongoSlaveTemplate": {
"status": "UP"
},
"reactiveMongoTemplate": {
"status": "UP"
}
}
},
"ping": {
"status": "UP"
},
"redis": {
"status": "UP"
}
}
}
```

48
lowcoder/docs/setup-and-run/self-hosting/access-local-database-or-api.md Normal file
View File

@@ -0,0 +1,48 @@
# Access local database or API
By default, docker-hosted instances use a [bridge network](https://docs.docker.com/network/bridge/), which does not support access to services on the docker-host via `127.0.0.1` or `localhost` from inside of the docker.&#x20;
Here we take PostgreSQL as an example and show you how to access local API or database in different operating systems (OS) for docker-hosted Lowcoder.
## Preparation
Assume that a Postgres service is ready on your local host with port `5432`.&#x20;
On Linux, you can check if Postgres runs locally with the command\
`pgrep -u postgres -fa -- -D`
## How to access a local database or API from Lowcoder which runs inside the Docker
{% tabs %}
{% tab title="Linux" %}
1. Enter `ifconfig docker0` in the terminal, and verify the IP configuration of Docker's virtual bridge (VB).
Having set up Docker, the OS would automatically create `docker0` using the IP address `172.17.0.1` (by default), through which the Docker service communicates with the host.
2. Enter the same IP address into Lowcoder to configure the Postgres data source (`172.17.0.1` in this example, but use the actual IP address displayed on your terminal in the real case).
{% hint style="warning" %}
On some OS (such as Ubuntu), port access might be blocked by the firewall. To solve that, configure in the following steps:
1. Stop the firewall from blocking access from <mark style="background-color:yellow;">`docker0`</mark> by typing in the terminal:\ <mark style="background-color:yellow;">`iptables -A INPUT -p tcp -i docker0 --dport YOUR_DB_PORT -j ACCEPT`</mark>\
`Note: In this case`Here we use Postgres port <mark style="background-color:yellow;">`5432`</mark> for <mark style="background-color:yellow;">`YOUR_DB_PORT`</mark>, and you should replace it with your own.
2. Save the firewall configuration by typing in the terminal:\
<mark style="background-color:yellow;">`iptables-save > /etc/iptables.up.rules`</mark>
{% endhint %}
{% endtab %}
{% tab title="Windows & Mac" %}
On Windows and macOS, Docker does not create the virtual bridge `docker0`. Then the following host name is helpful to resolve the host IP:
```
host.docker.internal
```
{% endtab %}
{% endtabs %}
On Windows and Mac:
<figure><img src="../../.gitbook/assets/Local Database via Docker Network.png" alt=""><figcaption><p>Access a Database on your local network from Lowcoder which runs in Docker</p></figcaption></figure>
<figure><img src="../../.gitbook/assets/Local API via Docker Network.png" alt=""><figcaption><p>Access an API on your local network from Lowcoder which runs in Docker</p></figcaption></figure>

240
lowcoder/docs/setup-and-run/self-hosting/google-cloud-platform.md Normal file
View File

@@ -0,0 +1,240 @@
---
description: How to Setup Seperate Images on Google Cloud Platform
---
# Google Cloud Platform
## Google Cloud Console Lowcoder Setup
### Creating a VPC Network
1. In the Google Cloud Console, in VPC Network, click on VPC Networks
* Enable Compute Engine API
2. Create a VPC Network
* Name the VPC Network
* Disable IPv6
* Create a custom subnet
* Name the subnet
* Choose the region best for your
* Choose an IP Range
* Private Google Access: On
* Flow Logs: Off
* In the subnet, setting turn on Private Google Access (it is necessary to enable this setting otherwise the cloud-run services will not be able to communicate with one another)
* This will be in the Edit subnet section using a custom subnet creation mode
* If the subnet creation mode is automatic, you will have to go to the region of your VPC network and enable the Private Google Access setting from there once the VPC is created.
<figure><img src="../../.gitbook/assets/VPC Network Setup.JPG" alt=""><figcaption></figcaption></figure>
### Creating a Serverless VPC Access Connector
1. In the VPC Network, create a Connector
* Enable serverless VPC access API
2. Create a Serverless VPC Connector
* Name the Serverless VPC Connector
* Choose the same region as the VPC Network
* Network: Select the VPC Network that was previously created
* Subnet:
* Custom IP range
* IP range (cannot be the same subnet that was created before)
<figure><img src="../../.gitbook/assets/Serverless VPC Access Connector Setup.JPG" alt=""><figcaption></figcaption></figure>
### Creating a Cloud NAT
* Creating a Cloud NAT is necessary because when connecting the lowcoder services to MongoDB, you must whitelist an IP address that can access the MongoDB cluster.
* Google Cloud services will use different IP addresses each time to communicate with the internet unless a Cloud NAT is set up on the VPC
1. Within the “Network Services” in the Google Cloud Console click on “Cloud NAT” and then “Create Cloud NAT gateway”
2. Name the Cloud NAT gateway
3. Set the NAT type to public
4. Select a Cloud Router
* Connect it to the VPC Network created previously
* Select the region for your Router (the one VPC are running on)
* Create a New Router
* Name the router
5. Cloud NAT mapping
* Source: Primary and secondary ranges for all subnets
* Cloud NAT IP Addresses: Manual
* IP Addresses:
* Premium Network Service Tier
* IP address:
* Create and Name an IP address and then click on “Reserve”
* IP draining: Off (default)
6. Click on Create Cloud NAT
7. After creating a Cloud NAT IP address, whitelist this IP address on your MongoDB cluster
<figure><img src="../../.gitbook/assets/Cloud NAT Setup.JPG" alt=""><figcaption></figcaption></figure>
### Creating a Redis Instance
1. Within Google Cloud Console in Memorystore, on the Redis page, create a Redis instance
2. Enable Google Cloud Memorystore for Redis API
3. Create a Redis Instance:
* Name Redis instance in the Instance ID
* Basic Tier
* 1 GB of capacity is more than sufficient in our environment however if you face trouble then you can always adjust the capacity as necessary
* Choose the same region as the VPC Network
* Set up Connection: connect your Redis instance to the VPC network created previously
<figure><img src="../../.gitbook/assets/Redis Instance Setup.JPG" alt=""><figcaption></figcaption></figure>
### Setting up the Node Service
1. In the Google Console go to Cloud Run
2. Create a Service
3. In the Container Image URL input: lowcoderorg/lowcoder-ce-node-service
* This is from the lowcoder docker hub (https://hub.docker.com/r/lowcoderorg/lowcoder-ce-node-service)
4. Select the Region, same as the region for the VPC Network
5. CPU allocation and pricing: CPU is only allocated during request processing
6. Ingress Control is set to Internal (this is necessary to not expose the Node Service to the rest of the internet)
7. Authentication: Allow unauthenticated access invocations
<figure><img src="../../.gitbook/assets/Node Service Settings.JPG" alt=""><figcaption></figcaption></figure>
#### Container Settings
1. Container port: 6060
2. CPU allocation:
* Only allocated during the request processing
3. Capacity (allocate as necessary)
* Memory: 1 GiB
* CPU: 1
4. Execution environment: Default
<figure><img src="../../.gitbook/assets/Node Service Container Settings.JPG" alt=""><figcaption></figcaption></figure>
5. Environment Variable:
* Name 1: LOWCODER\_API\_SERVICE\_URL
* Value 1: Paste the API Service URL (Once the API Service is created after the next step
<figure><img src="../../.gitbook/assets/Node Service Environment Variables.JPG" alt=""><figcaption></figcaption></figure>
#### Networking Settings
* Connect to a VPC for outbound traffic
* Use Serverless VPC Access Connectors
* Network: Select the VPC network that was created
* Traffic routing:
* Route only requests to private IPs to the VPC (this is necessary to not expose the Node Service to the rest of the internet)
<figure><img src="../../.gitbook/assets/Node Service Networking Settings.JPG" alt=""><figcaption></figcaption></figure>
### Setting up the API Service
1. In the Google Console go to Cloud Run
2. Create a Service
3. In the Container Image URL input: lowcoderorg/lowcoder-ce-api-service
* This is from the lowcoder docker hub (https://hub.docker.com/r/lowcoderorg/lowcoder-ce-api-service)
4. Select the Region, same as the region for the VPC Network
5. CPU allocation and pricing: CPU is only allocated during request processing
6. Ingress Control is set to Internal (this is necessary to not expose the API Service to the rest of the internet)
7. Authentication: Allow unauthenticated access invocations
<figure><img src="../../.gitbook/assets/API Service Settings.JPG" alt=""><figcaption></figcaption></figure>
#### Container Settings
1. Container port: 8080
2. Capacity (allocate as necessary)
* Memory: 1 GiB
* CPU: 1
3. Execution environment: Second generation
<figure><img src="../../.gitbook/assets/API Service Container Settings.JPG" alt=""><figcaption></figcaption></figure>
4. Environment Variable: add any other environment variable as per your requirement (list of environment variables https://raw.githubusercontent.com/lowcoder-org/lowcoder/main/deploy/docker/docker-compose-multi.yaml)
* Variable 1:
* Name 1: REDIS\_URL
* Value 1: use: redis://10.0.0.0:6379?db=databasename and replace 10.0.0.0 with your Redis instance IP address and database name with the name of your database
* Variable 2:
* Name 2: MONGODB\_URL
* Value 2: Paste the MongoDB URL
* Variable 3:
* Name 3: LOWCODER\_NODE\_SERVICE\_URL
* Value 3: Paste the Node Service URL
* Variable 4:
* Name 4: ENABLE\_USER\_SIGN\_UP
* Value 4: TRUE&#x20;
* If it is a new setup then set it to true; if it will be used for an existing setup then set it to FALSE
* Variable 5:
* Name 5: ENCRYPTION\_PASSWORD
* Value 5: lowcoder.org
* Variable 6:
* Name 6: ENCRYPTION\_SALT
* Value 6: lowcoder.org
* Variable 7:
* Name 7: CORS\_ALLOWED\_DOMAINS
* Value 7: \*
<figure><img src="../../.gitbook/assets/API Service Envirnoment Variables.JPG" alt=""><figcaption></figcaption></figure>
#### Networking Settings
* Connect to a VPC for outbound traffic
* Use Serverless VPC Access Connectors
* Network: Select the VPC network that was created
* Traffic routing:
* Route all traffic to the VPC
<figure><img src="../../.gitbook/assets/API Service Networking Settings.JPG" alt=""><figcaption></figcaption></figure>
### Setting up the Front-End Service
1. In the Google Console go to Cloud Run
2. Create a Service
3. In the Container Image URL input: lowcoderorg/lowcoder-ce-frontend
* This is from the lowcoder docker hub (https://hub.docker.com/r/lowcoderorg/lowcoder-ce-frontend)
4. Select the Region, same as the region for the VPC Network
5. CPU allocation and pricing: CPU is only allocated during request processing
6. Ingress Control is set to all (the front-end should be exposed to the internet)
7. Authentication: Allow unauthenticated access invocations
<figure><img src="../../.gitbook/assets/Frontend Service Settings.JPG" alt=""><figcaption></figcaption></figure>
#### Container Settings
1. Container port: 3000
2. Capacity (allocate as necessary)
* Memory: 512 MiB
* CPU: 1
3. Execution environment: Default
<figure><img src="../../.gitbook/assets/Frontend Service Container Settings.JPG" alt=""><figcaption></figcaption></figure>
4. Environment Variable: add any other environment variable as per your requirement (list of environment variables https://raw.githubusercontent.com/lowcoder-org/lowcoder/main/deploy/docker/docker-compose-multi.yaml)
* Variable 1:
* Name 1: LOWCODER\_API\_SERVICE\_URL
* Value 1: Paste the API Service URL
* Variable 2:
* Name 2: LOWCODER\_NODE\_SERVICE\_URL
* Value 2: Paste the Node Service URL
<figure><img src="../../.gitbook/assets/Frontend Service Environment Variables.JPG" alt=""><figcaption></figcaption></figure>
#### Networking Settings
* Connect to a VPC for outbound traffic
* Use Serverless VPC Access Connectors
* Network: Select the VPC network that was created
* Traffic routing:
* Route all traffic to the VPC
<figure><img src="../../.gitbook/assets/Frontend Service Networking Settings.JPG" alt=""><figcaption></figcaption></figure>
#### Post Deployment Settings
* Can set up a DNS for the front URL through Google Domains
Author: Eshaan V Saxena, (10/10/2023)

97
lowcoder/docs/setup-and-run/self-hosting/heroku.md Normal file
View File

@@ -0,0 +1,97 @@
# Heroku
## Deploy
1. [Sign up](https://signup.heroku.com/) for a new Heroku account, or [log in](https://id.heroku.com/login) to get started.
2. Click to start Heroku [one-click deployment](https://heroku.com/deploy?template=https://github.com/lowcoder-org/lowcoder).
3. Set the **App name** which will be part of the app URL later, and choose a region.
4. (Not required) Fill in the **Config Vars** according to the descriptions. These are all optional variables used for environment-specific configuration. You can skip this step and manage environment variables later.
5. Click the **Deploy app** button.
It usually takes around three minutes to start the app.
Click the **View** button to open the new app, which should be available at **https://your\_app\_name.herokuapp.com/**.
On the welcome page, Click **Sign up** to get started. Lowcoder will automatically create a workspace for you. Then you can start building your apps and invite members to your workspace.
## Configure app settings
On the [Heroku Dashboard](https://dashboard.heroku.com/apps), go to the **Settings** tab at the top to configure app settings.
### Manage environment variables
You can manage the environment variables of your app in the **Config Vars** section.
{% hint style="info" %}
For more help, see [Managing config vars](https://devcenter.heroku.com/articles/config-vars#managing-config-vars) in the Heroku documentation.
{% endhint %}
### Install SSL Certificates
You can configure the SSL Certificates of your app in the **SSL Certificates** section. Heroku provides [Automated Certificate Management (ACM)](https://devcenter.heroku.com/articles/automated-certificate-management) and [Manual Certificate](https://devcenter.heroku.com/articles/ssl#manually-uploading-certificates-and-intermediaries) options.
Choose **Manual Certificate**, and you can install your SSL Certificates. A public certificate file usually ends in `.pem` or `.crt`.\
### Customize domain names
1. Click the **Add Domain** button in the **Domains** section.
2. Fill in your **Domain name** and click **Next**.\
3. Copy and paste the **DNS Target** provided by Heroku to complete the domain setup.
{% hint style="info" %}
For more help, see [Custom Domain Names for Apps](https://devcenter.heroku.com/articles/custom-domains) in the Heroku documentation.
{% endhint %}
## Update using Heroku CLI
You can use the [Heroku CLI](https://devcenter.heroku.com/categories/command-line) to update your Docker image to the latest version. The basic logic behind the following steps is to pull the newest code from the GitHub repository, build an image locally using the Docker engine, and deploy the updated image using the Heroku CLI. Before you start, make sure you have [Heroku CLI](https://devcenter.heroku.com/categories/command-line) and [Docker](https://www.docker.com/) installations locally (required).
1\. Get the latest code by cloning the [`Lowcoder-org/Lowcoder`](https://github.com/lowcoder-org/lowcoder) repository from GitHub.
```bash
git clone https://github.com/lowcoder-org/lowcoder.git
```
2\. Move to the `heroku` folder.
```bash
cd Lowcoder/deploy/heroku
```
3\. Log in to Heroku CLI.
```bash
heroku login
```
4\. Make sure you have a Docker engine running locally. Then log in to Container Registry.
```bash
heroku container:login
```
5\. Get the app name of your Heroku account.
```bash
heroku apps
```
6\. Build the image and push it to Container Registry.
```bash
heroku container:push web -a your_app_name
```
7\. Release the image to your app.
```bash
heroku container:release web -a your_app_name
```
It might take a few minutes to build the new image and push it to Heroku. Then you can open the app in your browser to check if it is running.
```bash
heroku open -a your_app_name
```

154
lowcoder/docs/setup-and-run/self-hosting/lowcoder-version-update.md Normal file
View File

@@ -0,0 +1,154 @@
# Lowcoder Version Update
## Lowcoder Versioning Scheme
We try to respect as good as possible the Semantic Versioning for Lowcoder Versions
v2.4.1 for example, means:
* Major Version **"2"**. It changes when there are truly big updates that might break old features or add significant new ones. It comes when we introduce fundamentally new concepts inti the Software
* Minor Version **"4"**. It changes when new features are added in a way that doesn’t break existing ones. It should be possible to update the version and expect a working continuation of existing apps.
* Patch Version **"1"**. It changes when we do bug-fixes or improvements, that don't affect overall functionality.
We work with initiatives to add new functionality. This comes normally with the increase of the minor version. When we have a new bigger feature set ready, we introduce it as 2.4.0 for example. The Patch Version is "0". This updates should work in general, but we never can fully exclude not having introduced bugs or unexpected behaviour. Naturally we increase every day the tests and production quality and invest a lot of development time to keep also new features backward compatible.
{% hint style="warning" %}
It is suggested to test a new Minor Version with a Patch Version "0" separately as a Test-Installation. We do not suggest to update this simply on the existing older version.
{% endhint %}
After a new Minor Version we deliver typically the next patch version quite fast, considering all bugs, that we found or that was reported. The first and second Patch Versions we can count in typical cases as Stabe Versions.
{% hint style="info" %}
The patch versions > 0 are typically seen as Stable Version. It should be ok to install these directly as update.
{% endhint %}
### Lowcoder SDK
The SDK has an independent versioning - yet still following the Semantic Versioning Scheme.
Since Lowcoder v2.4.0 we follow the principle, that the SDK will have the same Major and Minor Version as the Main Lowcoder Version - but it can have an independent Patch-Version.
### External Component Plugins
Also external Component Plugins follow the Sematic Versioning Scheme with Major, Minor, and Patch versions. However, they are independent from the Lowcoder or Lowcoder SDK Versions.
### Docker Images
The provided Docker Images from Lowcoder-Org follow the Sematic Versioning of Lowcoder. For every Release of the Codebase with a new Version, we also offer the pre-built Docker Containers for the All-in-one and Multi-Docker installation.
{% embed url="https://hub.docker.com/r/lowcoderorg/lowcoder-ce/tags" %}
Lowcoder pre-built Docker Images on Docker Hub
{% endembed %}
Next to the released Version Tags of Lowcoder there are 2 more tags with relevance:
* /latest - These images contain typically a state of development which is somewhat stable - but not yet a released Patch Version. Critical Bugs, that we solved are fastest to get in the /latest tag. The /latest tag always based on the previous last published Patch Version.
* /dev - these images can be seen like Nightly Builds. They contain evetually the latest stage of our development and are only for testing purposes.
{% hint style="danger" %}
Do not use a /dev tag image in production. These images are only to use in test installations aside.
{% endhint %}
{% hint style="info" %}
We suggest only a Multi-Docker Image installation for Production use. The all-in-one image "lowcoderorg/lowcoder-ce" is suitable to test and introduce Lowcoder in an easy way.
{% endhint %}
## Version Update
To **update** from an older to a newer version or Lowcoder, please follow this guide:
{% hint style="warning" %}
Please always make a Backup / Copy of your /lowcoder-stacks folder.
{% endhint %}
The magic behind an easy update is to make use of the /lowcoder-stacks mounted folder in the docker installations. That enables you to change the Versions of Lowcoder but not touch the Application Data. In the mounted /lowcoder-stacks folder, all MongoDB application data as also Logs and Assets are stored.&#x20;
In other words, if you not use an external MongoDB Service, the Lowcoder MongoDB stores the Application Data of all your workspaces and Apps there, enabling you to exchange the docker without needing further backup and restore actions.
Based on the lowcoder-stacks folder, the data of a Lowcoder Installation can be transitioned without losses when you update to a new version of Lowcoder.&#x20;
<figure><img src="../../.gitbook/assets/Deployment Docker lowcoder-stacks.png" alt="" width="563"><figcaption><p>Mount local folder - f.e. in Docker Desktop</p></figcaption></figure>
### 1) Stop your Lowcoder Docker Containers:
With Docker Compose
{% tabs %}
{% tab title="All-in-one Docker image" %}
`docker compose down`
{% endtab %}
{% tab title="Multi-Image Deployment" %}
`docker compose -f docker-compose-multi.yaml down`
{% endtab %}
{% endtabs %}
With pure Docker
<pre class="language-bash"><code class="lang-bash"><strong>docker stop [container-id]
</strong></code></pre>
Or in Docker Desktop
<figure><img src="../../.gitbook/assets/Screenshot 2024-03-23 at 14.18.08.png" alt=""><figcaption><p>This deletes the current Conatiner Instance - not the Docker Image itself.</p></figcaption></figure>
Stop and delete the "Container" you did run based on the old version.&#x20;
{% hint style="info" %}
If you did follow the /lowcoder-stacks folder mounting, no data would be lost.
{% endhint %}
### 2) Create a backup copy of the **lowcoder-stacks** Folder
Even if it should be never a problem, still we ask you kindly always to make a copy of the whole folder. Sometimes we have no other channce than to introduce breaking changes and we want to make sure you will never loss any data.
### 3) Download the latest Lowcoder Docker images.
#### With Docker Compose
download [docker-compose.yaml](https://raw.githubusercontent.com/lowcoder-org/lowcoder/main/deploy/docker/docker-compose.yaml) or [docker-compose-multi.yaml](https://raw.githubusercontent.com/lowcoder-org/lowcoder/main/deploy/docker/docker-compose-multi.yaml) file depending on which installation you prefer (all-in-one or multi-images)
#### With pure Docker
If you use Docker Desktop, you can pull the /latest tag or a specific version tag.
<figure><img src="../../.gitbook/assets/Screenshot 2024-03-23 at 14.06.42.png" alt=""><figcaption></figcaption></figure>
### 4) Adapt standard values to your Installation
{% hint style="warning" %}
For every Major Version, we likely introduce new ENV Variables. This is the reason to download the latest docker compose file. Naturally, you also can update your local copy with the new ENV Variables and other new config structures.
{% endhint %}
Edit the docker-compose file to your needs, but make sure to update only the settings. The following values must match your previous version to keep the Lowcoder MongoDB accessible for your stored Data Source Secrets.
* LOWCODER\_DB\_ENCRYPTION\_PASSWORD
* LOWCODER\_DB\_ENCRYPTION\_SALT
{% hint style="info" %}
If you lose or change the Encryption Password & Salt, the Lowcoder Database on MongoDB will work as expected - only the existing stored Credentials to Data Sources are "lost" / not accessible.
{% endhint %}
### 5) Run the new Lowcoder Docker-Image
After the image is pulled, you can run the image (create a new container) and configure directly the Ports as well as the ENV Variables.&#x20;
{% hint style="warning" %}
Mind to re-connect (mount) the /lowcoder-stacks folder
{% endhint %}
#### With Docker Compose
{% tabs %}
{% tab title="All-in-one Docker image" %}
`docker compose up -d`
{% endtab %}
{% tab title="Multi-Image Deployment" %}
`docker compose -f docker-compose-multi.yaml up -d`
{% endtab %}
{% endtabs %}
## Multi Image Docker Version handling
Technically, the Docker Versions and releases go "Hand in Hand". That means that you should always operate the same backend version of API-Service-Image & Node-Service-Image as the Frontend-Image. However, in special situations, the separation of these concerns into different images gives you a degree of freedom to update only one of the images and check the compatibility.

58
lowcoder/docs/setup-and-run/self-hosting/migration-from-openblocks.md Normal file
View File

@@ -0,0 +1,58 @@
# Migration from Openblocks
With **Lowcoder v1.1.8** we created a drop-in replacement for **Openblocks** **v1.1.8**. \
To run it, no changes were required.
However, to **migrate** from Openblocks or Lowcoder 1.1.8 to **Lowcoder 2.0,0**, some changes are required and these are the steps to be followed:
### Migrating from Openblocks (or Lowcoder v1.1.8) to **Lowcoder v2.0.0**
{% hint style="info" %}
if not using Lowcoder v1.1.8 or the latest Openblocks released version (v1.1.8), please upgrade first to Openblocks v1.1.8
{% endhint %}
### 1) stop your Openblocks/Lowcoder:
{% tabs %}
{% tab title="All-in-one Docker image" %}
`docker compose down`
{% endtab %}
{% tab title="Multi-Image Deployment" %}
`docker compose -f docker-compose-multi.yaml down`
{% endtab %}
{% endtabs %}
### 2) create a backup copy of the **openblocks-stacks** folder
### 3) rename the **openblocks-stacks** folder to **lowcoder-stacks**
\
`mv openblocks-stacks lowcoder-stacks`
### 4) Download the latest docker-compose file.
download [docker-compose.yaml](https://raw.githubusercontent.com/lowcoder-org/lowcoder/main/deploy/docker/docker-compose.yaml) or [docker-compose-multi.yaml](https://raw.githubusercontent.com/lowcoder-org/lowcoder/main/deploy/docker/docker-compose-multi.yaml) file depending on which installation you prefer (all-in-one or multi-images)\
### 5) Adapt standard values to your Installation
Edit the docker-compose file and make sure to update these settings - values have to match exactly what you had in your Openblocks version:
```
ENCRYPTION_PASSWORD:
ENCRYPTION_SALT:
MONGODB_URL:
```
### 6) start your Lowcoder&#x20;
{% tabs %}
{% tab title="All-in-one Docker image" %}
`docker compose up -d`
{% endtab %}
{% tab title="Multi-Image Deployment" %}
`docker compose -f docker-compose-multi.yaml up -d`
{% endtab %}
{% endtabs %}

78
lowcoder/docs/setup-and-run/self-hosting/raspberry-pi.md Normal file
View File

@@ -0,0 +1,78 @@
# Raspberry Pi
It is possible to install and run Lowcoder on Raspberry Pi.&#x20;
* install a 64bit OS eg. using [RPi Imager](https://www.raspberrypi.com/software/)
<figure><img src="../../.gitbook/assets/01_rpi_create_image.png" alt="" width="375"><figcaption><p>Select Raspberry Pi OS (Other) -> Raspberry Pi OS Lite (64-bit)</p></figcaption></figure>
* while writing it to the SD card or USB stick, hit settings, enable SSH and change the user to `lowcoder`
<figure><img src="../../.gitbook/assets/rpi_imager_settings.png" alt="" width="375"><figcaption><p>Enable SSH and set username to "lowcoder"</p></figcaption></figure>
Once done, boot up the device and do the following steps:
## Login via SSH to RPi
_(replace IP\_ADDRESS with the IP address of you RPi)_
`ssh lowcoder@IP_ADDRESS`
## Update installed system
```bash
sudo apt update
sudo apt full-upgrade
```
## Install docker
```bash
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
"deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
"$(. /etc/os-release && echo "$VERSION_CODENAME")" 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-buildx-plugin docker-compose-plugin
```
## Add lowcoder user to docker group
```bash
sudo usermod lowcoder -a -G docker
```
## Close connection to RPi and login again to apply the added group
```bash
exit
ssh lowcoder@IP_ADDRESS
```
## Create lowcoder application folders
```bash
mkdir -p lowcoder/lowcoder-stacks
cd lowcoder/
```
## Download lowcoder docker-compose file
```bash
wget 'https://raw.githubusercontent.com/lowcoder-org/lowcoder/main/deploy/docker/docker-compose.yaml'
```
## Update image name in downloaded docker-compose file
```bash
sed -i 's@image: lowcoderorg/lowcoder-ce:latest@image: ludomikula/lowcoder-ce:dev@' docker-compose.yaml
```
## Start lowcoder
```bash
docker compose up -d
```

5
lowcoder/docs/setup-and-run/self-hosting/smtp-server.md Normal file
View File

@@ -0,0 +1,5 @@
# SMTP Server
To enable a secure Password Reset Flow and a future eMail check on Sign-up, you need your own SMTP Server ready. To configure the SMTP Server, you can use the following ENV Variables at the **API-Server Image**.
<table><thead><tr><th width="426">Environment Variable</th><th width="223">Description</th><th>Default Value</th></tr></thead><tbody><tr><td><code>LOWCODER_ADMIN_SMTP_HOST</code></td><td>SMTP Hostname of your Mail Relay Server</td><td></td></tr><tr><td><code>LOWCODER_ADMIN_SMTP_PORT</code></td><td>Port number for the SMTP service</td><td><code>587</code></td></tr><tr><td><code>LOWCODER_ADMIN_SMTP_USERNAME</code></td><td>Username for SMTP authentication</td><td></td></tr><tr><td><code>LOWCODER_ADMIN_SMTP_PASSWORD</code></td><td>Password for SMTP authentication</td><td></td></tr><tr><td><code>LOWCODER_ADMIN_SMTP_AUTH</code></td><td>Enable SMTP authentication</td><td><code>true</code></td></tr><tr><td><code>LOWCODER_ADMIN_SMTP_SSL_ENABLED</code></td><td>Enable SSL encryption</td><td><code>false</code></td></tr><tr><td><code>LOWCODER_ADMIN_SMTP_STARTTLS_ENABLED</code></td><td>Enable STARTTLS encryption</td><td><code>true</code></td></tr><tr><td><code>LOWCODER_ADMIN_SMTP_STARTTLS_REQUIRED</code></td><td>Require STARTTLS encryption</td><td><code>true</code></td></tr></tbody></table>

57
lowcoder/docs/setup-and-run/self-hosting/traefik-loadbalancer.md Normal file
View File

@@ -0,0 +1,57 @@
# Traefik loadbalancer
Thanks to the amazing contribution of [https://github.com/timconsidine](https://github.com/timconsidine) Lowcoder can work smoothly with the Traefik as Loadbalancer.
This is a docker-compose.yaml file, which shows the necessary settings.
```yaml
version: "3"
services:
## Start Lowcoder (all-in-one)
lowcoder-api-service:
image: lowcoderorg/lowcoder-ce:latest
container_name: lowcoder
environment:
REDIS_ENABLED: "true"
MONGODB_ENABLED: "true"
API_SERVICE_ENABLED: "true"
NODE_SERVICE_ENABLED: "true"
FRONTEND_ENABLED: "true"
PUID: "1000"
PGID: "1000"
DEFAULT_ORGS_PER_USER: 100
DEFAULT_ORG_MEMBER_COUNT: 1000
DEFAULT_ORG_GROUP_COUNT: 100
DEFAULT_ORG_APP_COUNT: 1000
DEFAULT_DEVELOPER_COUNT: 50
MONGODB_URL: "mongodb://localhost:27017/lowcoder?authSource=admin"
REDIS_URL: "redis://localhost:6379"
ENABLE_USER_SIGN_UP: "false"
ENCRYPTION_PASSWORD: "somethingveryunique"
ENCRYPTION_SALT: "somethingalsounique"
CORS_ALLOWED_DOMAINS: "*"
LOWCODER_API_KEY_SECRET: "b37717ee6de1003921c4445a3088af17ee316a6fad270737282a8ce2acf29832"
LOWCODER_API_SERVICE_URL: "http://localhost:8080"
LOWCODER_NODE_SERVICE_URL: "http://localhost:6060"
LOWCODER_MAX_REQUEST_SIZE: 20m
LOWCODER_MAX_QUERY_TIMEOUT: 120
volumes:
- ./lowcoder-stacks:/lowcoder-stacks
restart: unless-stopped
labels:
- traefik.docker.network=traefik
- traefik.port=3000
- traefik.port=3443
- "traefik.enable=true"
- "traefik.http.routers.lowcoder.rule=Host(`lowcoder.domain.tld`)"
- "traefik.http.routers.lowcoder.entrypoints=websecure"
- "traefik.http.routers.lowcoder.tls.certresolver=letsencrypt"
- "traefik.http.services.lowcoder.loadbalancer.server.port=3000"
networks:
- traefik
networks:
traefik:
external: true
```

89
lowcoder/docs/setup-and-run/self-hosting/update-mongodb-versions.md Normal file
View File

@@ -0,0 +1,89 @@
# Update MongoDB Versions
## Version Update of MongoDB
MongoDB stopped the support for versions < 5 already and will stop the support for version < 6 soon. It is suggested to update the MongoDB Server / Infrastructure.
The lowcoder application continues to operate smoothly on MongoDB version 4.4. However, to ensure compatibility with official MongoDB releases, an update is necessary. This update is specifically required for the all-in-one deployment of lowcoder, which includes MongoDB.
It is important to note that MongoDB version 5.0 and above requires the AVX (Advanced Vector Extensions) feature of the processor. While this feature is standard in all newer processors, it may not be supported by older hardware. Therefore, users with older systems might encounter issues running MongoDB 5.0+.
An incremental update procedure is possible without losing data. However, the major versions of MongoDB cannot be overjumped. You cannot jump to v 6 from v 4; you would first need to adapt to v 5.
Suppose you currently run v4 and want to update to v7- these are the necessary steps for the all-in-one docker image. If you operate a multi-image installation, adap the paths to your data location for your MongoDB and the database must be stopped before the process is started.
### 1) Stop Lowcoder
Stop your Lowcoder instance and wait for it to completely stop the service.
```bash
docker compose down
```
### 2) Create a Backup Copy of the **lowcoder-stacks** folder
```bash
cp -rp lowcoder-stacks lowcoder-stacks.backup
```
### 3) Run upgrade-mongo-4x-to-5x docker compose file
{% file src="../../.gitbook/assets/upgrade-mongo-4x-to-5x.yaml" %}
Update MongoDB from v4 to v5
{% endfile %}
```bash
docker compose -f upgrade-mongo-4x-to-5x.yaml up -d && sleep 30
```
### 4) Set MongoDB Compatibility-Version to 5
```bash
docker exec mongodb-5 /usr/bin/mongosh --eval 'use admin' --eval 'db.adminCommand( { setFeatureCompatibilityVersion: "5.0" } )'
```
### 5) Stop and remove MongoDB 5 Update-Container
```bash
docker compose -f upgrade-mongo-4x-to-5x.yaml down
```
### 6) Run upgrade-mongo-5x-to-6x docker compose file
{% file src="../../.gitbook/assets/upgrade-mongo-5x-to-6x.yaml" %}
Update MongoDB from v5 to v6
{% endfile %}
```bash
docker compose -f upgrade-mongo-5x-to-6x.yaml up -d && sleep 30
```
### 7) Set MongoDB Compatibility-Version to 6
```bash
docker exec mongodb-6 /usr/bin/mongosh --eval 'use admin' --eval 'db.adminCommand( { setFeatureCompatibilityVersion: "6.0" } )'
```
### 8) Stop and remove MongoDB 6 Update-Container&#x20;
```bash
docker compose -f upgrade-mongo-5x-to-6x.yaml down
```
### 9) Run upgrade-mongo-6x-to-7x docker compose file
{% file src="../../.gitbook/assets/upgrade-mongo-6x-to-7x.yaml" %}
Update MongoDB from v6 to v7
{% endfile %}
```bash
docker compose -f upgrade-mongo-6x-to-7x.yaml up -d && sleep 30
```
### 10) Stop and remove MongoDB 7 Update-Container
```bash
docker compose -f upgrade-mongo-6x-to-7x.yaml down
```
As result your MongoDB is now updated to Version 7 without Data loss.