DEV Community: rburkhardt

Self-Hosting Fonts - No more excuses

rburkhardt — Thu, 29 Sep 2022 17:23:52 +0000

Google Fonts - Privacy & DSGVO

For some time now it is forbidden in germany to use the google-fonts-api for your website. The idea behind this is that the user has no chance to prevent google from loading the fonts when visiting the website. The whole thing has actually been known for a while, but I still see a lot of sites from the EU/GER using google-fonts. With this short blog post I try to draw some more attention to the problem and show you some tools that can solve the data-privacy dilemma quickly.

Self-Hosting Fonts - Tools

With the help of the @font-face (MDN) rule and a dedicated tool, the problem can be fixed in no time. Two of them I can recommend:

google-webfonts-helper (wep-app & rest-api)
webfont-kit-generator (linux)

I came across the tool "Webfont-Kit-Generator" for linux only recently.

With the helpful tool it is possible to generate woff/woff2 font formats from non-web fonts (otf & ttf). Additionally you get a css snippet which you can use for embedding.

What I like the most is that you can also download google-fonts and convert them automatically. Webfont-Kit-Generator uses fonttools (written in Python), that's pretty cool too.

In the settings you can then adjust and optimize the fonts a little more (unicode-range, font-display etc.).

The tool is also available via Flatpak and can be obtained from Flathub:

flatpak install flathub com.rafaelmardojai.WebfontKitGenerator

As an alternative there is the google-webfonts-helper. It can be used online and regardless of the operating system.

Bottom line

Actually, there is no reason to use google-fonts anymore (CDN). The average internet speed has become so fast that the performance hardly plays a role in self-hosting. The performance can even be improved when self hosting (adjustable charset, S3-CDN etc.). Also for privacy reasons I think it is important not to leave things like fonts to a data giant. Unfortunately, there are still a lot of sites that use google-fonts. Even medium-sized and large corporate sites from germany. I hope the trend goes here more in the direction of data privacy.

Interesting links on the topic:

Thanks for reading.

Originally published at rburkhardt.com
Feel free to subscribe to my RSS and connect on Twitter or Github

Django Deployment - Postgres DBaaS

rburkhardt — Mon, 26 Sep 2022 10:41:50 +0000

During my last attempt to get a Postgres server up and running, I realized again how time consuming it actually is. In addition to the installation of the Postgres server, the whole server has to be secured. This can take a lot of time. With a small vps with many users there is also the limited perfomrnace.

The alternative: DBaaS (Database-as-a-Service).

The advantages of a DBaaS are simple:

Time saving (server management and installation)
Security ( reduced risk and best practice)
Data-Security (automatic backups)
Scalability (fast and easy to scale down and up)

Providers I can recommend are:

The service from fly.io Postgres on Fly also looks very promising.

Preparations

Postgres

login: psql -U doadmin -h host -p port -d database
database creation: CREATE DATABASE djangodb;
switch to the new db: \c djangodb;

After that we can create the new user with a secure password:

CREATE USER djangouser WITH PASSWORD 'securepassword';

For everything to work smoothly django recommends the following paramenter (see django-docs):

ALTER ROLE djangouser SET client_encoding TO 'utf8';

ALTER ROLE djangouser SET default_transaction_isolation TO 'read committed';

ALTER ROLE djangouser SET timezone TO 'UTC';

Finally we can change the privileges for our new user:

GRANT ALL PRIVILEGES ON DATABASE djangodb TO djangouser;

Django

Here i decided to use django-environ's env.db() for the DATABASE_URL.


import os
from pathlib import Path
import environ

BASE_DIR = Path(__file__).resolve().parent.parent

env = environ.Env()
env_file = os.path.join(BASE_DIR, ".env")
if os.path.isfile(env_file):
    env.read_env(env_file)

DATABASE_URL = env.str("DATABASE_URL", default=False)

if DATABASE_URL:
    DATABASES = {"default": env.db()}
else:
    DATABASES = {
        "default": {
            "ENGINE": "django.db.backends.sqlite3",
            "NAME": BASE_DIR / "db.sqlite3",
        }
    }

Note about DigitalOcean's App Platform:

If we use DigitalOcean's App Platform, we can skip the dynamic variable ${dbname.DATABASE_URL} as DATABASE_URL. This has always led to an empty database for me with a redeploy. Even if I created a database via DO's GUI before, and changed the variable accordingly.

To ensure that our data is also available after a redeploy in the future, we can use the Postgres-String as variable (with encryption on).

Conclusion

(in connection with DO's Postgres DBaaS)

I am very happy with the performance so far. If I need connection pooling (via PgBouncer) later, I can add it quickly and easily via DO's GUI. The price is a bit expensive for a single and smaller project, but quickly pays off when another project is added. With DigitalOcean the fun starts at 15€ and 3 databases (1GB Memory, 1 vCPU, 15GB Disk).

Thanks for reading.

Originally published at rburkhardt.com
Feel free to subscribe to my RSS and connect on Twitter or Github

Django deployment with App Platform & S3 Space

rburkhardt — Wed, 14 Sep 2022 18:27:48 +0000

Preface

Recently i had to decide which hosting solution i want to use for my private blog. The blog was developed with the help of Dev-Case and is based on Django.

Since i have read a lot of good things about PaaS in connection with Django lately, the decision was made quickly.

The providers to choose from were:

DigitalOcean
Railway
Render

In the end, i decided to go with DigitalOcean because i have already had good experiences here (VPS, Space). Another plus for DO was that i didn't need another provider for the S3-Storage.

Preparation

To be able to host my Django project with the App-Platform, i have made the following preparations:

Environment variables

For this i use django-environ.
Here are a few basic settings:

import os
from pathlib import Path
from django.core.management.utils import get_random_secret_key
import environ

BASE_DIR = Path(__file__).resolve().parent.parent

env = environ.Env()
env_file = os.path.join(BASE_DIR, ".env")
if os.path.isfile(env_file):
    env.read_env(env_file)

SECRET_KEY = env.str("SECRET_KEY", default=get_random_secret_key())

DEBUG = env.bool("DEBUG", default=False)

ALLOWED_HOSTS = env.list(
    "ALLOWED_HOSTS",
    default=[
        "127.0.0.1",
    ],
)

Database

Here i decided to use Postgres.

Thanks to django-environ i can use a DATABASE_URL here.
A possibility to use SQLite should still exist but is a matter of personal taste.

DATABASE_URL = env.str("DATABASE_URL", default=False)

if DATABASE_URL:
    DATABASES = {"default": env.db()}
else:
    DATABASES = {
        "default": {
            "ENGINE": "django.db.backends.sqlite3",
            "NAME": BASE_DIR / "db.sqlite3",
        }
    }

S3 Storage

To be able to use the S3 compatible storage later on (DO Space):

USE_S3_STORAGE = env.bool("USE_S3_STORAGE", default=False)
AWS_ACCESS_KEY_ID = env.str("AWS_ACCESS_KEY_ID", default="")
AWS_SECRET_ACCESS_KEY = env.str("AWS_SECRET_ACCESS_KEY", default="")
AWS_STORAGE_BUCKET_NAME = env.str("AWS_STORAGE_BUCKET_NAME", default="")
AWS_S3_REGION_NAME = env.str("AWS_S3_REGION_NAME", default="")
AWS_S3_ENDPOINT_URL = env.str("AWS_S3_ENDPOINT_URL", default="")
AWS_S3_CUSTOM_DOMAIN = env.str("AWS_S3_CUSTOM_DOMAIN", default="")
AWS_LOCATION = env.str("AWS_LOCATION", default="")
AWS_IS_GZIPPED = env.bool("AWS_IS_GZIPPED", default=False)
AWS_S3_FILE_OVERWRITE = env.bool("AWS_S3_FILE_OVERWRITE", default=True)
AWS_DEFAULT_ACL = env.str("AWS_DEFAULT_ACL", default="public-read")

STATICFILES_DIRS = (str(BASE_DIR.joinpath("static")),)
STATIC_ROOT = str(BASE_DIR.joinpath("staticfiles"))
MEDIA_ROOT = str(BASE_DIR.joinpath("media"))

if USE_S3_STORAGE:
    DEFAULT_FILE_STORAGE = "storages.backends.s3boto3.S3Boto3Storage"
    STATICFILES_STORAGE = "storages.backends.s3boto3.S3Boto3Storage"

    STATIC_URL = f"https://{AWS_S3_ENDPOINT_URL}/{STATIC_ROOT}/"
    MEDIA_URL = f"https://{AWS_S3_ENDPOINT_URL}/{MEDIA_ROOT}/"

else:
    STATICFILES_STORAGE = "django.contrib.staticfiles.storage.StaticFilesStorage"
    STATIC_URL = "static/"
    MEDIA_URL = "/media/"

SSL

A valid SSL certificate is supplied automatically:

SECURE_SSL_REDIRECT = env.bool("SECURE_SSL_REDIRECT", default=False)
SECURE_HSTS_SECONDS = env.int("SECURE_HSTS_SECONDS", default=0)
SECURE_HSTS_INCLUDE_SUBDOMAINS = env.bool(
    "SECURE_HSTS_INCLUDE_SUBDOMAINS", default=False
)
SECURE_HSTS_PRELOAD = env.bool("SECURE_HSTS_PRELOAD", default=False)

SESSION_COOKIE_SECURE = env.bool("SESSION_COOKIE_SECURE", default=False)
CSRF_COOKIE_SECURE = env.bool("CSRF_COOKIE_SECURE", default=False)

PIP requirements

The following packages are required:

django
gunicorn
django-environ
psycopg2-binary
boto3
django-storages

With the help of the requirements.txt file, the buildtool later also recognizes that this is a python project.

App Platform

Now that everything is ready, you can start creating the Django project on DO. A detailed instruction i save me at this point, because the docs and further post about it on the internet are very good.

Important settings are (example Dev-Case):

run_command: gunicorn dev_case.wsgi:application --bind 0.0.0.0:8080 --worker-tmp-dir /dev/shm
http_port: 8080

Depending on the project structure:

routes:
  - path: /
source_dir: /

With a "dev" database a dynamic variable can be used as environment variable. Example: ${db.DATABASE_URL}. In this case the name of the database would be db.

When using a managed-databases from DO, you should create the database manually and not via the GUI. Otherwise, errors may occur with a redeploy. I will link a post about it here soon.

edited (2022-09-26): link to the post mentioned above.

After the build process completes:

Access your app’s console through the console tab and run the following commands:

python3 manage.py migrate for the initial database migrations
python3 manage.py createsuperuser to create an administrative user

S3 and CORS

To prevent later errors with CORS, make the following adjustment in your Space setting:

Your Space -> Settings -> CORS Configurations (Add):

Add your domain (with wildcard) in "Origin", examples:
- *ondigitalocean.app
- *example.com
Allow/Check:
- GET, HEAD

This should solve the problems with fonts, scripts etc. (missing header, Access-Control-Allow-Origin).

Conclusion

I am very satisfied with DO's APP-Platform so far. The performance is good and i feel safe. Soon i will test the log forwarding. If there is something to write about it, i will link it here.

Thanks for reading.

Originally published at rburkhardt.com
Feel free to subscribe to my RSS and connect on Twitter or Github