LogoLogo
Go to Syntho.AI
English
English
  • Welcome to Syntho
  • Overview
    • Get started
      • Syntho bootcamp
        • 1. What is Syntho?
        • 2. Introduction data anonymization
        • 3. Connectors & workspace creation
        • 4. PII scan
        • 5. Generators
          • Mockers
          • Maskers
          • AI synthesize
          • Calculated columns
          • Free text de-identification
        • 6. Referential integrity & foreign keys
        • 7. Workspace synchronization & validation
        • 8. Workspace & user management
        • 9. Large workloads​
        • 10. AI synthesis: Data pre-processing when using
      • Prerequisites
      • Sample datasets
      • Introduction to data generators
      • AI-generated synthetic data
    • Frequently asked questions
  • Setup Workspaces
    • View workspaces
    • Create a workspace
      • Connect to a database
        • PostgreSQL
        • MySQL / MariaDB
        • Oracle
        • Microsoft SQL Server
        • DB2
        • Databricks
          • Importing Data into Databricks
        • Hive
        • SAP Sybase
        • Azure Data Lake Storage (ADLS)
        • Amazon Simple Storage Service (S3)
      • Workspace modes
    • Edit a workspace
    • Duplicate a workspace
    • Transfer workspace ownership
    • Share a workspace
    • Delete a workspace
    • Workspace default settings
  • Configure a Data Generation Job
    • Configure table settings
    • Configure column settings
      • AI synthesize
        • Sequence model
          • Prepare your sequence data
        • QA report
        • Additional privacy controls
        • Cross-table relationships limitations
      • Mock
        • Text
          • Supported languages
        • Numeric (integer)
        • Numeric (decimal)
        • Datetime
        • Other
      • Mask
        • Text
        • Numeric (integer)
        • Numeric (decimal)
        • Datetime
        • UUID
      • Duplicate
      • Exclude
      • Consistent mapping
      • Calculated columns
      • Key generators
        • Differences between key generators
      • JSON de-identification
    • Manage personally identifiable information (PII)
      • Privacy dashboard
      • Discover and de-identify PII columns
        • Identify PII columns manually
        • Automatic PII discovery with PII scanner
      • Remove columns from PII list
      • Automatic PII discovery and de-identification in free text columns
      • Supported PII & PHI entities
    • Manage foreign keys
      • Foreign key inheritance
      • Add virtual foreign keys
        • Add virtual foreign keys
        • Use foreign key scanner
        • Import foreign keys via JSON
        • Export foreign keys via JSON
      • Delete foreign keys
    • Validate and synchronize workspace
    • View and adjust generation settings
  • Deploy Syntho
    • Introduction
      • Syntho architecture
      • Requirements
        • Requirements for Docker deployments
        • Requirements for Kubernetes deployments
      • Access Docker images
        • Online
        • Offline
    • Deploy Syntho using Docker
      • Preparations
      • Deploy using Docker Compose
      • Run the application
      • Manually saving logs
      • Updating the application
      • Backup
    • Deploy Syntho using Kubernetes
      • Preparations
      • Deploy Ray using Helm
        • Upgrading Ray CRDs
        • Troubleshooting
      • Deploy Syntho using Helm
      • Validate the deployment
      • Troubleshooting
      • Saving logs
      • Upgrading the applications
      • Backup
    • Manage users and access
      • Single Sign-On (SSO) in Azure
      • Manage admin users
      • Manage non-admin users
    • Logs and monitoring
      • Does Syntho collect any data?
      • Temporary data storage by application
  • Syntho API
    • Syntho REST API
Powered by GitBook
On this page
  • Introduction
  • Deployment steps
  • Additional information
  • TLS
  • Core API
  • Backend
  • Frontend

Was this helpful?

  1. Deploy Syntho
  2. Deploy Syntho using Docker

Deploy using Docker Compose

PreviousPreparationsNextRun the application

Last updated 1 month ago

Was this helpful?

Introduction

Currently, we support the use of Docker Compose to deploy the Syntho Application. We've included a Docker Compose file that will deploy all the containers necessary for the Syntho Application. The following page will outline the steps to undertake to deploy our application using Docker Compose.

Deployment steps

  • Download the latest Docker Compose files from our .

  • Use docker login to log into the Syntho Container Registry, or docker load to load images from files. See Syntho Documentation under

  • Copy over example.env to .env using for example the Linux command cp example.env .env

  • Adjust the following variables in .env for a minimal setup:

    • LICENSE_KEY: The license key is provided by Syntho.

    • ADMIN_USERNAME, ADMIN_EMAIL and ADMIN_PASSWORD: the credentials for the admin account that can be used once the application is set up. The email and password will be needed to log in.

The .env file contains the latest image tag for all images, which is a rolling tag. Please adjust the following image tags with the tags provided by the Syntho Team to pin them to a certain version:

  • RAY_IMAGE

  • CORE_IMAGE

  • BACKEND_IMAGE

  • FRONTEND_IMAGE

To access the Backend API correctly, the domain should be set. If the application is being accessed on the same machine that deploys it, localhost should be fine for this domain. If you're using a different machine on your network, the IP address or hostname should be used for the following variables:

  • FRONTEND_HOST: this should include the port as well. If port 3000 is used for the frontend, and it can be accessed on the same machine, the value would be localhost:3000. If another machine on the same network needs to access the frontend, the value will be <IP-of-deployed-machine>:3000. If you're using a reverse proxy (NGINX, Apache, HAProxy) with either port 80 or 443, the host value should be without the port. For example: syntho.company.com might be the correct value instead of syntho.company.com:3000 .

  • FRONTEND_DOMAIN: will be either localhost or the IP of the machine running the Syntho Application. Do not add the port on which the application is running if that's relevant.

After the adjustment of these variables, the docker compose file should be ready for deployment. The documentation will continue to describe particular sections to adjust in particular cases, but at this point the Docker Compose file should be ready to deploy.

Additional information

Setting up multiple nodes requires a more detailed configuration. This setup is recommended for scalable production environments. Steps and configurations may vary depending on the specific requirements of the network and the number of nodes involved.

TLS

If an SSL certificate needs to be provided, the following environment variables need to be adjusted:

# If TLS is used, set protocol to https and secured_cookies to True
FRONTEND_PROTOCOL=https
SECURED_COOKIES="True"

By default, these values are respectively set to http and False. Supplying a TLS certificate will need to be done via a separate application (like a reverse proxy such as NGINX, or cert-manager).

Core API

Database

The credentials for the database that the Core API & Worker (core and core_worker and in the docker-compose file) use to connect are described in the following environment variables:

CORE_DATABASE_HOST=<database-host>
CORE_DATABASE_USER=<database-user>
CORE_DATABASE_PASSWORD=<database-password>
CORE_DATABASE_NAME=<database-name>

By default, these values are set to the value for the Postgres instance that is being deployed as part of the docker-compose file. If another database needs to be used, the credentials can be adjusted here. Only Postgres databases are supported for this.

Redis

The information that is being used to connect to the Redis instance is saved in the following environment variables:

CORE_CELERY_BROKER_URL=redis://<redis-host>:6379/0
CORE_CELERY_RESULT_BACKEND=redis://<redis-host>:6379/0
CORE_REDIS_HOST=redis
CORE_REDIS_PORT=6379

Additional environment variables

Important other variables are CORE_SECRET_KEY, which is used as an encryption key. This key can be generated using the following command using python:

# If cryptography is not installed, install it with `pip install cryptography`.
python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"

If issues with the port of the application arise, the default port can be changed using the CORE_PORT variable in the .env file.

CORE_PORT=8000

Backend

Database

Just as the Core API, the backend will need to connect to the Postgres database. This database is used for storing application data. By default, this will connect

BACKEND_DB_HOST=<host>
BACKEND_DB_NAME=<database-name>
BACKEND_DB_USER=<datbase-user>
BACKEND_DB_PASSWORD=<database-password>
BACKEND_DB_PORT=<database-port>

Redis

For the Redis instance used for the backend, we can set the following variables. The Redis instance is included in the docker-compose file, but if a separate Redis instance is used, the credentials need to be set in the .env file.

BACKEND_REDIS_HOST=redis # Redis hostname to connect to
BACKEND_REDIS_PORT=6379 # Redis port to connect to
BACKEND_REDIS_DB_INDEX=1 # Redis database index to use

Admin user

As described earlier in the documentation, the username, email-address and password of the admin user can be adjusted. The following environment variables can be used for that:

ADMIN_USERNAME=admin
ADMIN_PASSWORD=somepassword
ADMIN_EMAIL=admin@company.com

Additional environment variables

For the backend, some additional environment variables can be set. We can change the port which is exposed for the backend if any issues arise with port mappings. To change the port, we can change the value in BACKEND_PORT:

BACKEND_PORT=8000

We then have the secret key that the backend uses for encryption purposes. We can set this key to any value, as long as it is a rather long string. Example:

BACKEND_SECRET_KEY="66n6ldql(b2g0jmop(gr)@x0tz!*^7(d1_$2#y&$t&3r$=cr%#"

Frontend

The frontend is responsible for the user interface. The frontend will need to connect to the Backend for this. The most important variable that is left for the frontend is the following:

FRONTEND_PORT=3000

This variable sets the port for the frontend, which will need to be exposed for the user to be able to access the application.

Github repository
Deploy Syntho -> Introduction -> Access Docker images