So stellen Sie Django mit Hetzner und Dokku kostengünstig bereit

Die Bereitstellung einer Django-Anwendung kann eine Herausforderung sein, insbesondere wenn es um die Auswahl der richtigen Infrastruktur geht.

Hetzner bietet in Kombination mit Dokku eine starke und flexible Lösung, die den Bereitstellungsprozess erleichtert.

Dokku, eine auf Docker basierende Platform-as-a-Service (PaaS), ermöglicht Ihnen die einfache Bereitstellung, Verwaltung und Skalierung von Anwendungen.

Diese Anleitung zeigt Ihnen, wie Sie mit Dokku eine Django-Anwendung für Hetzner bereitstellen.

---

Was sind Hetzner und Dokku?

Hetzner ist ein deutsches Unternehmen, das verschiedene Webhosting-Dienste anbietet, wie z. B. dedizierte Server, Cloud-Hosting, virtuelle private Server (VPS) und Colocation-Dienste.

Sie sind dafür bekannt, leistungsstarke Infrastruktur zu erschwinglichen Preisen bereitzustellen, was sie bei Entwicklern, Unternehmen und Technikbegeisterten beliebt macht.

Die Rechenzentren von Hetzner befinden sich hauptsächlich in Deutschland und Finnland (aber auch in den USA und jetzt in Singapur) und bieten hohe Sicherheit, Zuverlässigkeit und skalierbare Lösungen.

Sie werden besonders wegen ihrer kostengünstigen Cloud-Hosting-Optionen geschätzt, was sie zu einem starken Konkurrenten auf dem europäischen Hosting-Markt macht.

Dokku

Dokku ist ein Open-Source-Tool, das die Bereitstellung und Verwaltung von Webanwendungen vereinfacht.

Es verwendet Docker und ermöglicht die Bereitstellung von Apps mit Git, ähnlich wie Heroku. Dokku funktioniert mit vielen Programmiersprachen und Frameworks und kann Datenbanken, SSL-Zertifikate und mehr verarbeiten.

Es ist leicht und einfach auf einem Server einzurichten, was es zu einer beliebten Wahl für Entwickler macht, die eine selbst gehostete Lösung wie Heroku, aber mit mehr Kontrolle und Flexibilität, wünschen.

---

Sind Sie es leid, denselben alten Python-Code zu schreiben? Möchten Sie Ihre Programmierkenntnisse auf die nächste Stufe bringen? Suchen Sie nicht weiter! Dieses Buch ist die ultimative Ressource für Anfänger und erfahrene Python-Entwickler.

Holen Sie sich „Pythons magische Methoden – Jenseits von init und str“

Magische Methoden sind nicht nur syntaktischer Zucker, sie sind leistungsstarke Werkzeuge, die die Funktionalität und Leistung Ihres Codes erheblich verbessern können. Mit diesem Buch erfahren Sie, wie Sie diese Tools richtig nutzen und das volle Potenzial von Python ausschöpfen.

---

Voraussetzungen

Bevor wir mit dem Bereitstellungsprozess beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Eine Django-Anwendung: Ihre Django-App sollte für die Bereitstellung bereit sein. Es sollte eine requirements.txt Datei und eine Procfile enthalten.
• Ein Hetzner Cloud-Konto: Wenn Sie noch keins haben, können Sie sich bei Hetzner anmelden.
• Ein GitHub-Konto: Um Ihre Anwendung bereitstellen zu können.
• Grundlegende Befehlszeilenkenntnisse: Sie sollten mit dem Terminal vertraut sein.

---

Schritt 1 – Erstellen Sie einen VPS in Hetzner

Beginnen Sie mit der Erstellung eines VPS (Virtual Private Server) in der Hetzner Cloud. Wenn Sie noch kein Konto haben, können Sie sich hier anmelden.

Einmal auf der Cloud-Konsole:

• Erstellen Sie ein neues Projekt, nennen wir es Hetzner Dokku. Geben Sie das Projekt ein und fügen Sie Server hinzu.
• Als Standort wählen wir Helsinki (eu-central) aus.
• Als Bild wählen wir Ubuntu 22.04 (Dokku unterstützt 24.04 zum Zeitpunkt des Schreibens nicht)
• Für Typ wählen wir Shared CPU, x86 und CX22 (2vCPUS, 4GB RAM, 40GB SSD).
• Für Netzwerke lassen wir sowohl IPv4 als auch IPv6 aktiviert.
• Für SSH-Schlüssel sollten Sie Ihren SSH-Schlüssel hinzufügen. Wenn Sie noch keins haben, können Sie es mit ssh-keygen generieren.
• Die anderen Optionen können Sie vorerst weglassen. Später können Sie bei Bedarf eine Firewall aktivieren.
• Geben Sie ihm schließlich einen Namen, in diesem Fall nennen wir ihn dokku-server.

Dann klicken Sie auf „Jetzt erstellen & kaufen“. Nach ein paar Sekunden sollte Ihr VPS betriebsbereit und über SSH unter der angegebenen IP-Adresse erreichbar sein:

ssh root@<ip_address>

---

Schritt 2: Dokku installieren

Da der VPS nun konfiguriert ist und läuft, können Sie Dokku installieren. Vorher empfiehlt es sich, den VPS zu aktualisieren, was Sie wie folgt tun können:

apt update && apt upgrade -y

Gegebenenfalls starten Sie den VPS neu.

Dokku installieren

Sie können Dokku jetzt installieren:

wget -NP . https://dokku.com/install/v0.34.8/bootstrap.sh
sudo DOKKU_TAG=v0.34.8 bash bootstrap.sh

Zum Zeitpunkt des Schreibens war die neueste Version v0.34.8. Suchen Sie auf der Dokku-Website nach der neuesten Version.

Dies kann einige Minuten dauern, da auch einige Docker-Images abgerufen werden müssen, die den Bereitstellungsprozess unterstützen.

Sie sollten den Server nach der Installation neu starten, um sicherzustellen, dass alle Pakete aktiv sind und ausgeführt werden.

Richten Sie den SSH-Schlüssel und die Virtualhost-Einstellungen ein

Für den Zugriff auf Anwendungen ist es ratsam, einen Domainnamen zu haben. Sie können aber auch die IP-Adresse mit Subdomain-Unterstützung mit https://sslip.io/ verwenden.

Zuerst müssen Sie Ihren SSH-Schlüssel in den Dokku SSH-Administratorschlüssel kopieren:

cat ~/.ssh/authorized_keys | dokku ssh-keys:add admin

Dann können Sie Ihre Domain oder IP-Adresse festlegen:

dokku domains:set-global <ip_address>.sslip.io

In this case, it defines the IP address, but with support for sub-domains with sslip.io.

---

Step 3 - Creating the application in Dokku

With Dokku installed and configured, you can now create the application in Dokku that will receive your Django application:

dokku apps:create django-app

This command creates an app called django-app.

Django requires a database and normally there is two choices, either a SQLite or Postgres database.

On Dokku, databases are part of the plugin packages and need to be installed separately:

dokku plugin:install https://github.com/dokku/dokku-postgres.git

This command will install Postgres by downloading the supporting Docker images.

To actually create a database that you can use with the recently created application, you can use the command:

dokku postgres:create django-app-db

Once the the database is created, you will need to link it to the Dokku application:

dokku postgres:link django-app-db django-app

Linked the database to the application means that the database URL is added to the environment variables of the application definitions in Dokku.

You can check that with the command:

dokku config:show django-app

Which should give a similar response to this:

=====> django-app env vars
DATABASE_URL:  postgres://postgres:bca0d7f59caf98c78a74d58457111a1e@dokku-postgres-django-app-db:5432/django_app_db

---

Step 4 - Creating the Django application

With Dokku installed, configured and an application created, you are now ready to create the actual Django application.

There are several guides on the Internet on how to create a Django application from scratch, so the focus on this article is on deploying the application to Django.

For this tutorial, I created a Django application in PyCharm using the default settings called DjangoAppDokku.

To be able to deploy the application to Dokku, there is some preparation steps that are necessary.

Let's start with making sure there is a requirements file with the command:

pip freeze > requirements.txt

Then you can install some necessary packages to prepare for the Dokku deploying:

pip install python-decouple dj-database-url gunicorn whitenoise psycopg2-binary

This installs three useful packages:

• python-decouple for managing configuration settings.
• dj-database-url for simplifying database configuration in Django.
• gunicorn for serving Python web applications in production.
• whitenoise to manage access to static files.
• psycopg2-binary to allow access to Postgres databases.

Now you can create the environment variable file on a file called .env:

DATABASE_URL=sqlite:///db.sqlite3

This configures (for local use) a database URL using SQLite. When the application is deployed to Django it will use the URL defined in Dokku, as we have seen before.

For that to be possible, you need to make some changes in the settings.py file:

import dj_database_url
import os
from decouple import config
from django.conf.global_settings import DATABASES

...

ALLOWED_HOSTS = ['*']

...

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    "whitenoise.middleware.WhiteNoiseMiddleware",
    ... all others middleware ...
]

...

DATABASES['default'] = dj_database_url.parse(config('DATABASE_URL'), conn_max_age=600)

...

STATIC_URL = 'static/'
STATIC_ROOT = BASE_DIR / "static"
STATICFILES_DIRS = (
    os.path.join(BASE_DIR, 'staticfiles'),
)
STATICFILES_STORAGE = 'whitenoise.storage.CompressedStaticFilesStorage'

This code snippet configures various settings for a Django application:

• Database Configuration: Uses dj_database_url and decouple to parse the database URL from environment variables.
• Allowed Hosts: Allows the application to be served from any host (useful for development), but should not be used in Production.
• Middleware: Includes Django's security middleware and WhiteNoise middleware for serving static files.
• Static Files: Configures the URL, root directory, additional directories, and storage backend for static files using WhiteNoise.

For Dokku to know how to run the Django application and how to migrate the database, yo will need to create a Procfile:

web: gunicorn DjangoAppDokku.wsgi

release: python manage.py migrate

The Procfile defines two important processes for your Django application, which Dokku will execute:

• web: gunicorn DjangoAppDokku.wsgi: Starts the Gunicorn web server to handle incoming HTTP requests using the WSGI application defined in DjangoAppDokku.wsgi.
• release: python manage.py migrate: Runs Django's database migrations as part of the release process, ensuring that the database schema is up-to-date with the latest code changes.

The last set is to make sure that the requirements file is up to date:

pip freeze > requirements.txt

---

Step 5 - Deploying the Django application to Dokku

With the Django application and the Dokku application prepared, you can now deploy the application to Dokku.

First you will need create a new repository on GitHub then you can add the Django application to it.

So, on your Django project directory, open a terminal and execute these commands:

echo "# DjangoAppDokku" >> README.md
git init
git add .
git commit -m "First Commit"
git branch -M main
git remote add origin [Your GitHub repository URL]
git push -u origin main

Now you add a new git remote for the Dokku server:

git remote add dokku dokku@<your_server_ip>:<your_dokku_app_name>

And finally deploy the application with:

git push dokku

This will produce an output similar to this:

Enumerating objects: 23, done.
Counting objects: 100% (23/23), done.
Delta compression using up to 8 threads
Compressing objects: 100% (21/21), done.
Writing objects: 100% (23/23), 5.48 KiB | 160.00 KiB/s, done.
Total 23 (delta 8), reused 0 (delta 0), pack-reused 0
-----> Cleaning up...
-----> Building django-app from herokuish
-----> Adding BUILD_ENV to build environment...
       BUILD_ENV added successfully
-----> Python app detected
-----> No Python version was specified. Using the buildpack default: python-3.12.5
       To use a different version, see: https://devcenter.heroku.com/articles/python-runtimes
-----> Requirements file has been changed, clearing cached dependencies
-----> Installing python-3.12.5
-----> Installing pip 24.0, setuptools 70.3.0 and wheel 0.43.0
-----> Installing SQLite3
-----> Installing requirements with pip
       Collecting asgiref==3.8.1 (from -r requirements.txt (line 1))
       Downloading asgiref-3.8.1-py3-none-any.whl.metadata (9.3 kB)
       Collecting dj-database-url==2.2.0 (from -r requirements.txt (line 2))
       Downloading dj_database_url-2.2.0-py3-none-any.whl.metadata (12 kB)
       Collecting Django==5.1 (from -r requirements.txt (line 3))
       Downloading Django-5.1-py3-none-any.whl.metadata (4.2 kB)
       Collecting psycopg2-binary==2.9.9 (from -r requirements.txt (line 4))
       Downloading psycopg2_binary-2.9.9-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (4.4 kB)
       Collecting python-decouple==3.8 (from -r requirements.txt (line 5))
       Downloading python_decouple-3.8-py3-none-any.whl.metadata (14 kB)
       Collecting sqlparse==0.5.1 (from -r requirements.txt (line 6))
       Downloading sqlparse-0.5.1-py3-none-any.whl.metadata (3.9 kB)
       Collecting typing_extensions==4.12.2 (from -r requirements.txt (line 7))
       Downloading typing_extensions-4.12.2-py3-none-any.whl.metadata (3.0 kB)
       Collecting tzdata==2024.1 (from -r requirements.txt (line 8))
       Downloading tzdata-2024.1-py2.py3-none-any.whl.metadata (1.4 kB)
       Collecting whitenoise==6.7.0 (from -r requirements.txt (line 9))
       Downloading whitenoise-6.7.0-py3-none-any.whl.metadata (3.7 kB)
       Downloading asgiref-3.8.1-py3-none-any.whl (23 kB)
       Downloading dj_database_url-2.2.0-py3-none-any.whl (7.8 kB)
       Downloading Django-5.1-py3-none-any.whl (8.2 MB)
       Downloading psycopg2_binary-2.9.9-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.0 MB)
       Downloading python_decouple-3.8-py3-none-any.whl (9.9 kB)
       Downloading sqlparse-0.5.1-py3-none-any.whl (44 kB)
       Downloading typing_extensions-4.12.2-py3-none-any.whl (37 kB)
       Downloading tzdata-2024.1-py2.py3-none-any.whl (345 kB)
       Downloading whitenoise-6.7.0-py3-none-any.whl (19 kB)
       Installing collected packages: python-decouple, whitenoise, tzdata, typing_extensions, sqlparse, psycopg2-binary, asgiref, Django, dj-database-url
       Successfully installed Django-5.1 asgiref-3.8.1 dj-database-url-2.2.0 psycopg2-binary-2.9.9 python-decouple-3.8 sqlparse-0.5.1 typing_extensions-4.12.2 tzdata-2024.1 whitenoise-6.7.0
-----> $ python manage.py collectstatic --noinput
       System check identified some issues:
       WARNINGS:
       ?: (staticfiles.W004) The directory '/tmp/build/staticfiles' in the STATICFILES_DIRS setting does not exist.
       127 static files copied to '/tmp/build/static'.

-----> Discovering process types
       Procfile declares types -> release, web
-----> Releasing django-app...
-----> Checking for predeploy task
       No predeploy task found, skipping
-----> Checking for release task
       Executing release task from Procfile in ephemeral container: python manage.py migrate
=====> Start of django-app release task (ae9dc2b83) output
remote:  !     System check identified some issues:
remote:  !     WARNINGS:
remote:  !     ?: (staticfiles.W004) The directory '/app/staticfiles' in the STATICFILES_DIRS setting does not exist.
       Operations to perform:
         Apply all migrations: admin, auth, contenttypes, sessions
       Running migrations:
         Applying contenttypes.0001_initial... OK
         Applying auth.0001_initial... OK
         Applying admin.0001_initial... OK
         Applying admin.0002_logentry_remove_auto_add... OK
         Applying admin.0003_logentry_add_action_flag_choices... OK
         Applying contenttypes.0002_remove_content_type_name... OK
         Applying auth.0002_alter_permission_name_max_length... OK
         Applying auth.0003_alter_user_email_max_length... OK
         Applying auth.0004_alter_user_username_opts... OK
         Applying auth.0005_alter_user_last_login_null... OK
         Applying auth.0006_require_contenttypes_0002... OK
         Applying auth.0007_alter_validators_add_error_messages... OK
         Applying auth.0008_alter_user_username_max_length... OK
         Applying auth.0009_alter_user_last_name_max_length... OK
         Applying auth.0010_alter_group_name_max_length... OK
         Applying auth.0011_update_proxy_permissions... OK
         Applying auth.0012_alter_user_first_name_max_length... OK
         Applying sessions.0001_initial... OK
=====> End of django-app release task (ae9dc2b83) output
-----> Checking for first deploy postdeploy task
       No first deploy postdeploy task found, skipping
=====> Processing deployment checks
remote:  !     No healthchecks found in app.json for web process type
       No web healthchecks found in app.json. Simple container checks will be performed.
       For more efficient zero downtime deployments, add healthchecks to your app.json. See https://dokku.com/docs/deployment/zero-downtime-deploys/ for examples
-----> Deploying django-app via the docker-local scheduler...
-----> Deploying web (count=1)
       Attempting pre-flight checks (web.1)
-----> Executing 2 healthchecks
       Running healthcheck name='default' type='uptime' uptime=10
       Running healthcheck name='port listening check' attempts=3 port=8000 retries=2 timeout=5 type='listening' wait=5
       Healthcheck succeeded name='port listening check'
       Healthcheck succeeded name='default'
       All checks successful (web.1)
=====> Start of django-app container output (8d55f0f3b481 web.1)
       Python buildpack: Couldn't determine available memory. Skipping automatic configuration of WEB_CONCURRENCY.
       [2024-08-29 08:32:56 +0000] [14] [INFO] Starting gunicorn 23.0.0
       [2024-08-29 08:32:56 +0000] [14] [INFO] Listening at: http://0.0.0.0:8000 (14)
       [2024-08-29 08:32:56 +0000] [14] [INFO] Using worker: sync
       [2024-08-29 08:32:56 +0000] [153] [INFO] Booting worker with pid: 153
=====> End of django-app container output (8d55f0f3b481 web.1)
=====> Triggering early nginx proxy rebuild
-----> Ensuring network configuration is in sync for django-app
-----> Configuring django-app.<ip_address>.sslip.io...(using built-in template)
-----> Creating http nginx.conf
       Reloading nginx
-----> Running post-deploy
-----> Ensuring network configuration is in sync for django-app
-----> Configuring django-app.<ip_address>.sslip.io...(using built-in template)
-----> Creating http nginx.conf
       Reloading nginx

-----> Checking for postdeploy task
       No postdeploy task found, skipping
=====> Application deployed:
       http://django-app.<ip_address>.sslip.io

To <ip_address>:django-app
 * [new branch]      master -> master

Dokku has performed the following actions to deploy the application:

• Die neueste Python-Version installiert.
• Die Anforderungen wurden aus Ihrer Datei „requirements.txt“ installiert.
• Statische Daten mit Python manage.py Collectstatic --noinput gesammelt.
• Migrierte die Datenbank mit python manage.py migrate (definiert in der Procfile).
• Der Gunicorn-Server wurde gestartet.

Wenn Sie nun zur angegebenen URL gehen, sollte die bekannte Django-Standardseite angezeigt werden:

Und das ist es. Das ist alles, was Sie brauchen, um eine Django-Anwendung auf Dokku bereitzustellen.

Diese Einstellungen eignen sich gut, um eine Anwendung zu testen und Beta-Benutzern Zugriff zu gewähren. Für den Produktionsgebrauch sollten Sie Ihrer Anwendung jedoch einen Domänennamen hinzufügen und SSL aktivieren. Weitere Informationen finden Sie in der Dokku-Dokumentation.

---

Abschluss

Sie haben Ihre Django-Anwendung mit Dokku erfolgreich bei Hetzner bereitgestellt.

Dieses Setup erleichtert dank der einfachen, aber leistungsstarken Funktionen von Dokku die Skalierung und Verwaltung Ihrer Anwendung.

Jetzt, da Ihre Anwendung bereitgestellt ist, können Sie sich auf die Verbesserung und Erweiterung konzentrieren, da Sie wissen, dass sie auf einer zuverlässigen Infrastruktur läuft.

Das obige ist der detaillierte Inhalt vonSo stellen Sie Django mit Hetzner und Dokku kostengünstig bereit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!