Wie wäre es mit Grüßen an alle, dies ist mein erster Artikel in <» FromLinux (von mehreren, die ich in meinen Entwürfen habe xD), ich hoffe, er ist für Sie nützlich
Nun, in meinem neuen und aktuellen Job wird gerade die Migration mehrerer Systeme nach Django durchgeführt (wie seltsam eh ?? xD), und eine meiner Aufgaben, abgesehen von der Entwicklung, ist die Produktion dieser Systeme, dann als Guter Lehrling, da ich zum ersten Mal eine Anwendung auf einem echten Server in Produktion gebracht habe: $ Ich begann, das offizielle Dokument aller erforderlichen Pakete des Stapels (vor allem Gunicorn und Supervisord) zu lesen und sah, dass die Tutorials Auf Spanisch waren sie mir in einigen Aspekten nicht sehr klar. Ich beschloss, einen Mini-Leitfaden mit den Schritten zu erstellen, die ich befolgte, um die Anwendung in Produktion zu bringen, basierend auf den Stapeln Django, Gunicorn, Supervisord, Nginx und Postgresql.
In dem Fall, in dem ich arbeite, wird auf den Servern immer noch Debian Squeeze ausgeführt, aber die Anleitung sollte für andere Distributionen vollständig gültig sein. Kommen wir also gleich zum Punkt und beginnen:
Ich werde als Superuser arbeiten. Zunächst sind folgende Pakete erforderlich:
PIP -> Tool zum Installieren und Verwalten von Paketen für Python
aptitude install python-pip
Nginx -> Webserver (wir werden ihn als Reverse-Proxy verwenden und die statischen Dateien 'img, js, css' zwischenspeichern) Wir installieren ihn mit:
aptitude install nginx
Supervisor -> Anwendung zum Verwalten und Überwachen unserer Anwendung, obwohl sie für viel mehr verwendet wird. Wir installieren es mit:
aptitude install supervisor
virtuelle Umgebung -> Es hilft uns, eine angepasste virtuelle Ausführungsumgebung für unsere Anwendung zu erstellen. Wir installieren es mit:
aptitude install python-virtualenv
Gunicorn -> Webserver für Python (wir werden diesen noch nicht installieren)
Ich gehe davon aus, dass postgresql bereits installiert und konfiguriert sein sollte
psycopg2 -> PostgreSQL-Connector für Python (wir werden ihn auch noch nicht installieren)
Erstellen Sie eine virtuelle Umgebung mit virtualenv:
Zuerst werden wir in das Arbeitsverzeichnis wechseln, das wir für die Produktion verwenden werden:
cd /var/www/
Dann erstellen wir in diesem Verzeichnis die virtuelle Umgebung:
virtualenv ENV-nombreApp
Wir wechseln in das Verzeichnis, das ich gerade virtualenv erstellt habe
cd ENV-nombreAPP
Wir kopieren die Anwendung in dieses Verzeichnis und aktivieren nun die Umgebung mit:
source bin/activate
Die Eingabeaufforderung sollte nun so aussehen (ENV)usuario@host:
Dadurch wird sichergestellt, dass alles, was wir tun, nun im Verzeichnis /var/www/ENV-appname/ gespeichert wird, ohne Systempakete zu beeinträchtigen.
Nun wechseln wir in das Anwendungsverzeichnis:
cd nombreApp
Wir fahren mit der Installation der Liste der Anwendungsabhängigkeiten (falls erforderlich) fort, in der sie in der Datei angegeben sind requirements.txt:
pip install -r requirements.txt
Wir können Pakete auch einzeln installieren, um beispielsweise den Connector von zu installieren postgresql:
pip install psycopg2
Installation und Konfiguration von GUnicorn:
Um es zu installieren, machen wir es auf die gleiche Weise:
pip install gunicorn
Nun konfigurieren wir es. Dazu erstellen wir im Stammverzeichnis unserer Anwendung eine Datei namens gunicorn-deploy.py (der Name kann jedoch beliebig gewählt werden) mit folgendem Inhalt:
bind = "127.0.0.1:8001" # dirección a donde accederá Nginx
logfile = "/var/www/logs/nombreApp/gunicorn.log" # dirección donde estarán los logs de la aplicación
workers = 1 # dependerá en medida de la carga de trabajo que tenga la aplicación, también depende del hardware con que se cuente
loglevel = 'info' # tipo de logging
Supervisord-Konfiguration:
Nun konfigurieren wir supervisord ; dazu generieren wir die Konfigurationsdatei mit
echo_supervisord_conf > /etc/supervisord.conf
Jetzt bearbeiten wir die Konfigurationsdatei:
vim /etc/supervisord.conf
Und wir kommentieren die folgenden Zeilen aus, indem wir die entfernen; (Semikolon):
[unix_http_server] file = / tmp / Supervisor.sock [Supervisord] Logfile = / var / log / Supervisord.log Logfile_maxbytes = 50 MB Logfile_backups = 10 loglevel = Debug pidfile = / var / run / Supervisord.pid nodaemon = false minfds = 1024 min = 200 [rpcinterface: Supervisor] Supervisor.rpcinterface_factory = Supervisor.rpcinterface: make_main_rpcinterface [Supervisorctl] serverurl = Unix: [Programm: Anwendungsname] Befehl = / var / www / ENV-Anwendungsname / bin / django_unicorn -c / var / www / ENV -Appname / appname / gunicorn-deploy.py directory = / var / www / ENV-appname / appname / autostart = true autorestart = true user = Benutzername redirect_stderr = true stdout_logfile = / var / www / logs / appname / Supervisord.log
Jetzt erstellen wir das Skript für Supervisorord, um mit dem System zu beginnen. Dazu erstellen wir die Datei:
vim /etc/init.d/supervisord
Und wir fügen folgenden Inhalt hinzu:
# Supervisord Autostart # # Beschreibung: Startet Supervisord # Prozessname: Supervisord # PID-Datei: /var/run/supervisord.pid SUPERVISORD = / usr / local / bin / Supervisord SUPERVISORCTL = / usr / local / bin / Supervisorctl case $ 1 in start) echo -n "Supervisord wird gestartet:" $ SUPERVISORD echo ;; stop) echo -n "Supervisor stoppen:" $ SUPERVISORCTL Shutdown Echo ;; Neustart) echo -n "Supervisor stoppen:" $ SUPERVISORCTL Shutdown Echo Echo -n "Supervisord starten:" $ SUPERVISORD echo ;; dieses C
Und jetzt erteilen wir der Datei Ausführungsberechtigungen, damit sie mit dem System beginnen kann:
sudo chmod +x /etc/init.d/supervisord
Wir aktualisieren die Links, um den Dienst zu starten:
sudo update-rc.d supervisord defaults
Wir starten den Service:
sudo /etc/init.d/supervisord start
Nginx einrichten:
Dieser Schritt ist ebenfalls recht einfach; wir erstellen die folgende nginx -Konfigurationsdatei für unsere Anwendung:
vim /etc/nginx/sites-enabled/nombreApp
Und wir werden Ihnen den folgenden Inhalt hinzufügen
Server {Listen 9001; # Port, an dem Nginx den Servernamen abhören soll www.domain.com; # oder 192.168.0.100, Adresse, auf die wir zugreifen werden access_log /var/log/nginx/Appname.access.log; # wo wir den Speicherort des Anwendungsprotokolls haben / {# wo nginx beim Zugriff auf www.dominio.com/proxy_pass http://127.0.0.1:8001 anruft; proxy_set_header Host $ http_host; } location / static / {#, auf den nginx zugreifen wird, wenn wir www.domain.com/static/ alias / var / www / ENV-appname / appname / staticfiles / eingeben; }}
Und wir starten nginx neu:
service nginx restart
Django einrichten:
Lassen Sie uns die Django-Konfigurationsdatei ändern:
vim nombreApp/settings.py
Wir suchen die Zeile mit DEBUG = True und ändern ihren Wert auf DEBUG = False.
Wir fügen die DB-Parameter hinzu:
DATABASES = {'default': {'ENGINE': 'django.db.backends.postgresql_psycopg2', # oder mysql oder was auch immer sie verwenden 'NAME': 'DBName', 'USER': 'DBUser', 'PASSWORD' : 'Passwort DB', 'HOST': 'localhost', # oder das, das sie benötigen 'PORT': '', # oder das, das sie verwenden}}
Wir suchen die Zeile ALLOWED_HOSTS=[] und fügen die Domain oder Adresse hinzu, über die wir darauf zugreifen werden, sodass das Ergebnis etwa so aussieht: ALLOWED_HOSTS=['www.domain.com'].
Wir konfigurieren das Verzeichnis für die statischen Dateien und suchen nach der Zeile mit der Aufschrift STATIC_ROOT = ' ' und wir ändern den Wert und platzieren den absoluten Pfad dort, wo unsere statischen Dateien sein sollen. In meinem Fall habe ich ihn mehr oder weniger so belassen STATIC_ROOT='/var/www/ENV-nombreApp/nombreApp/statics/'
Fast fertig führen wir den folgenden Befehl aus:
./manage.py collectstatic
Dadurch wird im Pfad, den wir in settings.py angegeben haben , ein Ordner namens ' statics' erstellt, in dem sich alle unsere statischen Dateien befinden werden.
Und schließlich starten wir den Supervisor neu, um die neuen Änderungen zu übernehmen:
supervisorctl restart nombreApp
Und das wäre es dann, am Ende war es doch doch keine so große Sache, oder? Mir kam es einfach vor
Ich hoffe, es ist nützlich für Sie, Grüße