The open-source alternative to Notion, a French government initiative in collaboration with Germany, has become the number 1 topic of discussion on Hacker News over the last 24 hours. In this post, we explain how to deploy and configure Docs on Clever Cloud.

What is Docs?

Docs isn't just an alternative to Notion: it's also a collaborative project from the Direction Interministérielle du Numérique (DINUM) and its German equivalent, the Zentrum Digitale Souveränität (ZENDIS, or Center for Digital Sovereignty).

Docs is one of many initiatives aimed at ensuring the digital sovereignty of governments , not only in their use of digital tools, but also in their creation. At Clever Cloud, we've already had the opportunity to work with various ministries on a daily basis, and we're proud to be able to contribute to the diffusion of these tools.

As Docs currently runs on Kubernetes, we have explored the possibilities of deploying it using Clever Cloud rather than a kube cluster. Of course, you'll be able to deploy it using Kubernetes when our managed kube product becomes available.

How to deploy Docs on Clever Cloud

Docs consists of two main applications:

• A backend (a Django API Rest) in src/backend
• A frontend (mainly based on Next.js and yarn workspaces) in src/frontend

And integrates the following dependencies :

• PostgreSQL database
• Redis
• Keycloak (optional)

To deploy it on Clever Cloud, opt for a Python application for the backend, and a Node.js application for the frontend. There's no need to version each subfolder; you can push your code with Git from the repository root and specify which subfolder to deploy using the APP_FOLDER variable for each of your applications.

Backend deployment

To take the value from the environment variables injected at runtime on Clever Cloud, we've made a few minor modifications to the code, and also renamed the environment variables for the PostgreSQL database and S3 storage. This last modification allows you to modify the database or buckets, change add-ons and renew identifiers without having to manually modify the value of the variables injected into the application. For smooth deployment of Docs on Clever Cloud, clone the branch under development on our fork.

Then, on Clever Cloud:

• Create a Python application
• Add a PostrgreSQL database
• Create a Cellar add-on (or create the bucket directly, if you already have one) and connect it to the application.
• Create a Redis add-on and connect it to the application
• Add the minimum configuration environment variables to your application:

APP_FOLDER="/src/backend"
CC_PYTHON_MODULE="impress.wsgi:application"
CC_PYTHON_VERSION="3"
CC_TROUBLESHOOT="true"
CELLAR_STORAGE_BUCKET_NAME="your-bucket-name"
DJANGO_ALLOWED_HOSTS="frontend-url/*"
DJANGO_CONFIGURATION="Development" / "Production"
DJANGO_SECRET_KEY="YourNewlyGeneratedKeyHere"
DJANGO_SETTINGS_MODULE="impress.settings"
DJANGO_SUPERUSER_PASSWORD=""
OIDC_OP_AUTHORIZATION_ENDPOINT="<>"
OIDC_OP_JWKS_ENDPOINT="<>"
OIDC_OP_TOKEN_ENDPOINT="<>"
OIDC_OP_USER_ENDPOINT="<>"
OIDC_RP_CLIENT_SECRET=""
STATIC_URL="frontend url"

Click on the Exposed configuration tab and add the variables to be shared with the frontend (the Cellar configuration and Keycloak, if you're adding one).

In your application, add the remote provided in the Python application dashboard (Information tab) and name it clever-backend, for example.

Once deployed, you'll be able to connect to the API administration interface on backend-url/admin.

Deploying the frontend

The Docs frontend requires far fewer dependencies, this one is configured to use yarn worspaces that facilitate both maintenance and the deployment of multiple applications on a single virtual machine on Clever Cloud.

On Clever Cloud:

• Create a Node.js application
• Add the following environment variables:

APP_FOLDER="./src/frontend"
CC_NODE_BUILD_TOOL="yarn"
CC_PRE_BUILD_HOOK="cd ./src/frontend && yarn install --frozen-lockfile && yarn app:build"
CC_RUN_COMMAND="cd ./src/frontend && yarn app:start"
CC_TROUBLESHOOT="true"
NEXT_PUBLIC_API_ORIGIN=""
NEXT_PUBLIC_SW_DEACTIVATED="true"
NODE_OPTIONS="--max-old-space-size=4096"

• Connect the application to the backend (Linked services tab), as well as to the database add-on.
• In your application, add the remote provided in the Node.js application dashboard (Information tab) and name it clever-frontend, for example.

Push the code, and you'll be able to connect using the authentication you've defined with Keycloak or the Django API.

Go further with Docs

This article presents an example of deployment on Clever Cloud, but Docs is a rich project with multiple functionalities that you can activate or customize. To work locally, you'll find instructions for starting the frontend here, and for starting the backend here. We welcome questions and contributions!

Superset is fast, lightweight, intuitive, and loaded with options that make it easy for users of all skill sets to explore and visualize their data.

How to deploy Superset

# Clone last superset release
git clone --depth 1 -b 0.38.1  https://github.com/apache/superset.git

# Move in superset repository
cd superset

# Create the python application
clever create --type python Superset

# Create the PostgreSQL instance                                
clever addon create postgresql-addon --plan m SupersetPG
    
# link the addon 
clever service link-addon SupersetPG

Superset environment

# Use gunicorn as python mode 
clever env set CC_PYTHON_BACKEND gunicorn

# Start the app using create_app() 
clever env set CC_PYTHON_MODULE superset.app:create_app()

# Python version to use
clever env set CC_PYTHON_VERSION 3.7

# Load all superset requirements
clever env set CC_PIP_REQUIREMENTS_FILE requirements/base.txt

# Application port
clever env set PORT 8080

# PYTHONPATH
clever env set PYTHONPATH /home/bas/YOUR_APP_ID/config/

# App secret key
clever env set SECRET_KEY A_SECRET_KEY

# Post build commands
clever env set CC_POST_BUILD_HOOK ./init.sh

# Superset admin password
clever env set ADMIN_PASSWORD AN_ADMIN_PASSWORD

Configure superset

import os
# Superset specific config
ROW_LIMIT = 5000

SUPERSET_WEBSERVER_PORT = os.getenv("PORT")
SUPERSET_WEBSERVER_ADDRESS = "0.0.0.0"

# Flask App Builder configuration
# Your App secret key
SECRET_KEY = os.getenv("SECRET_KEY")

# The SQLAlchemy connection string to your database backend
# This connection defines the path to the database that stores your
# superset metadata (slices, connections, tables, dashboards, ...).
# Note that the connection information to connect to the datasources
# you want to explore are managed directly in the web UI
SQLALCHEMY_DATABASE_URI = os.getenv("POSTGRESQL_ADDON_URI")

# Flask-WTF flag for CSRF
WTF_CSRF_ENABLED = True
# Add endpoints that need to be exempt from CSRF protection
WTF_CSRF_EXEMPT_LIST = []
# A CSRF token that expires in 1 year
WTF_CSRF_TIME_LIMIT = 60 * 60 * 24 * 365

# Set this API key to enable Mapbox visualizations
MAPBOX_API_KEY = ''

Superset build scipt

#!/bin/bash

# Load configuration file in PYTHONPATH
mkdir $APP_HOME/config
cp clever_config.py $APP_HOME/config/superset_config.py

# Create an admin user (you will be prompted to set username, first and last name before setting a password)
superset fab create-admin \
    --username admin \
    --firstname admin \
    --lastname admin \
    --email admin@admin.com \
    --password ${ADMIN_PASSWORD}

# Upgrade the database
superset db upgrade

# Loading examples data set (optional)
superset load_examples

# Create default roles and permissions
superset init

# Build frontend
cd superset-frontend 
npm install -f --no-optional
npm run build

Superset requirements

echo "psycopg2>=2.7 --no-binary psycopg2" >> requirements/base.txt

pip3 freeze > requirements.txt 

echo "psycopg2>=2.7 --no-binary psycopg2" >> requirements.txt

# gunicorn valid versions are located in setup.py file
echo "gunicorn>=20.0.2, <20.1" >> requirements.txt

Deploy

chmod u+x init.sh

# Add your files
git add .

# Create the first commit
git commit -m "clever init"

# Deploy the application
clever deploy

# Run the application
clever open

A couple years ago, I was a developer for a startup which has almost no test coverage. Super enthusiastic me from the past spent a few weeks coding tests, and factories… all that based on the gem FactoryGirl. Two days before I’m satisfied of what I’ve done, they announce that FactoryGirl needs to be upgraded to FactoryBot.

A few days ago, I’m like hey I want to talk about DRF on Clever Cloud, I’ll make a little API, who cares which python I’m using, let’s use 2.7! So I’m coding the project, making a nice readme and the python team finally decides to explicitly invite users to migrate to python 3….

Anyway ! the project is here all you have to do is to git clone the repo or have your own DRF repo locally.

If you use your own repo, make sure to have the following lines in your settings.py

PRODUCTION = True
if PRODUCTION:
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.postgresql_psycopg2',
            'NAME': os.environ.get('POSTGRESQL_ADDON_DB'),
            'USER': os.environ.get('POSTGRESQL_ADDON_USER'),
            'PASSWORD': os.environ.get('POSTGRESQL_ADDON_PASSWORD'),
            'HOST': os.environ.get('POSTGRESQL_ADDON_HOST'),
            'PORT': os.environ.get('POSTGRESQL_ADDON_PORT'),
        }
    }

go to Clever Cloud console and select create a new application. Select brand new app.

Click next and select python, then name you application.

The Clever Cloud console will ask you if you want to link an add on. Select postgreSQL and name your add-on

Just wait for the Clever console to set up your add on and application.

When your application is ready, you're invited to add environment variables.

If you use my project click on the expert mode button

and paste the following :

CC_PYTHON_MODULE=personal_website_backend.wsgi:application
CUSTOM_SECRET_KEY=your_custom_secret_key
PORT=8080
PRODUCTION=True

You can generate a secret key 50 chars long (DRF requirement) here.

If you use your own repo, add the env vars you need, but make sure to have at least CC_PYTHON_MODULE=<your_module_name>.wsgi:application

Then click next, a new screen will display with a git command to add a new remote to your repo and do your first deploy

Copy these lines and paste them directly in your console while being in your repo

git remote add clever git+ssh:\/\/git@push-par-clevercloud-customers.services.clever-cloud.com/<your_app_id>.git
git push -u clever master

Go back to Clever Cloud console and just look at the deployment logs of your app. It will tell you when your app is up, so just go to the overview page and click on the link symbol to visit your app.

If you want to see the full procedure live, have a look here.

What is Django?

Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design. Built by experienced developers, it takes care of much of the hassle of Web development, so you can focus on writing your app without needing to reinvent the wheel. It’s free and open source.

Setup

• Clone the project: git clone https://gitHub.com/taigaio/taiga-back.git
• Get in the project: cd taiga-back
• Create our Postgres add-on: clever addon create postgresql-addon --plan dev --region eu taigaPG
• Create our FS Bucket add-on: clever addon create fs-bucket --plan s --region eu taigaFS
• Create our application: clever create --type python taiga --region par
• Link our Postgres add-on: clever service link-addon taigaPG
• Link our FS Bucket add-on: clever service link-addon taigaFS
• Define the python version to use: clever env set PYTHON_VERSION 3
• Define where to mount our FS Bucket: clever env set CC_FS_BUCKET /data:`clever env | awk -F = '/BUCKET_HOST/ { print $2}'`
• Define the secret used by the app: clever env set SECRET theveryultratopsecretkey
• Define the frontend domain name: clever env set FRONT_DOMAIN taigald.cleverapps.io"
• Define the HTTP schema: clever env set HTTP_SCHEMA https"
• Define where to store media: clever env set STORAGE_MEDIA /data/media"
• Define where to store static files: clever env set STORAGE_STATIC /data/static"

from .common import *
import os

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.getenv("POSTGRESQL_ADDON_DB"),
        'USER': os.getenv("POSTGRESQL_ADDON_USER"),
        'PASSWORD': os.getenv("POSTGRESQL_ADDON_PASSWORD"),
        'HOST': os.getenv("POSTGRESQL_ADDON_HOST"),
        'PORT': os.getenv("POSTGRESQL_ADDON_PORT"),
    }
}

MEDIA_ROOT = os.path.join(BASE_DIR, os.getenv("STORAGE_MEDIA"))
STATIC_ROOT = os.path.join(BASE_DIR, os.getenv("STORAGE_STATIC"))
MEDIA_URL = ""https://" +  os.getenv("FRONT_DOMAIN") + os.getenv("STORAGE_MEDIA")
STATIC_URL = "https://" +  os.getenv("FRONT_DOMAIN") + os.getenv("STORAGE_STATIC")
SITES["front"]["scheme"] = os.getenv("HTTP_SCHEMA")
SITES["front"]["domain"] = os.getenv("FRONT_DOMAIN")

SECRET_KEY = os.getenv("SECRET")

DEBUG = False
PUBLIC_REGISTER_ENABLED = True

• Create the hook script: mkdir clevercloud; touch clevercloud/buildDirectories.sh && chmod +x ./clevercloud/buildDirectories.sh
• Use the following code for the shell script:

  [ -d $STORAGE_STATIC ] || mkdir -p $STORAGE_STATIC
  [ -d $STORAGE_MEDIA ] || mkdir -p $STORAGE_MEDIA
  

• Define the hook: clever env set CC_PRE_BUILD_HOOK ./clevercloud/buildDirectories.sh

• Clone the project: git clone https://gitHub.com/taigaio/taiga-front-dist.git
• Get in the project: cd taiga-back
• Get the latest stable version: git checkout stable
• Copy the default configuration file: cp dist/conf.example.json dist/conf.json
• Change the backend URL: sed -i 's,http://localhost:8000/api/v1/,http://taigabackld.cleverapps.io/api/v1/,g' dist/conf.json
• Create the static website: clever create --type static-apache taiga-front
• Link this website to our FS Bucket addon: clever service link-addon taigaFS
• Setup its mount point: clever env set CC_FS_BUCKET /dist/data:`clever env | awk -F = '/BUCKET_HOST/ { print $2}'`
• Add a domain name: clever domain add taigald.cleverapps.io

{
  "deploy": {
    "webroot": "/dist"
  }
}

Deploy

• Define the Python module we want to start: clever env set CC_PYTHON_MODULE taiga.wsgi
• Define the Python backend to use: clever env set PYTHON_BACKEND gunicorn
• Deploy the app: clever deploy

python manage.py migrate --noinput
python manage.py loaddata initial_user
python manage.py loaddata initial_project_templates
python manage.py compilemessages
python manage.py collectstatic --noinput
python manage.py sample_data

Up to now Python was in free beta. We are glad to notify you that it comes to an end and that Python is now charged. The smallest Scaler (1 VCPU, 512 Mo RAM) costs 27 EUR/month.

You can have a look at our pricing simulator if you need more ressources or customisation.

Feel free to contact us if you have any other question!

French version

Jusqu’à maintenant, Python était encore en béta et gratuit. Ce service sera dorénavant facturé. Le plus petit scaler (1 VCPU, 512 Mo RAM) coute 27EUR/mois.

Vous pouvez consulter notre simulateur de prix pour des besoins plus fins.

N’hésitez pas à nous contacter si vous avez des questions !

Python is a programming language that lets you work more quickly and integrate your systems more effectively.

Django (aka The Web framework for perfectionists with deadlines) is a high-level Python Web framework that encourages rapid development and clean, pragmatic design.

Still in beta, this feature will be available this month, for everyone.

If you want to be part of the beta-users, please contact us to mailto:support@clever-cloud.com