Schnelle Website-Bereitstellung mit Django, Heroku & New Relic

German (Deutsch) translation by Federicco Ancie (you can also view the original English article)

Die schnelle Entwicklung und Bereitstellung von Anwendungen wird für viele alte und neue Projekte schnell zu einer Anforderung und einem Ziel. Glücklicherweise bieten sich Entwicklern eine Vielzahl von Optionen, die sie in Bezug auf Bereitstellungsressourcen und eine enge Integration in die Programmiersprache Ihrer Wahl nutzen können. Cloud-Bereitstellungen, bei denen Unternehmen eine große Menge an Hardware anbieten, die Sie an Ihre Anforderungen anpassen können, werden aufgrund ihrer Flexibilität und Kosteneffizienz bei der Befolgung einer Bezahlung bei der Verwendung des Modells immer beliebter.

Eine der aufregenderen Änderungen, die diese Umstellung auf Cloud-Plattformen mit sich gebracht hat, insbesondere bei kleineren Projekten, besteht darin, dass viele Clouds eine kostenlose Bereitstellungsmöglichkeit bieten, wenn auch mit minimaler Hardware-Nutzung. Dies ermöglicht das kostenlose Hosting von Prototypanwendungen, beispielsweise von Beta-Produkten, und bietet Ihnen eine live laufende Anwendungsinstanz, die Sie jedem, den Sie möchten, schnell zur Verfügung stellen können. In ähnlicher Weise funktioniert es perfekt für jede Website, die nur mäßig viel Verkehr hat, z. B. ein kleines lokales Unternehmen oder sogar eine Portfolio-Website, auf der Sie einen Teil Ihrer Arbeit präsentieren können.

Einführung

Dieser Artikel konzentriert sich auf meine Erfahrungen bei der schnellen Entwicklung einer Portfolio-Website in Python und des beliebten Django-Webframeworks unter Verwendung einiger Bootstrap-Vorlagen zum Gestalten der Website. Mit einer übersichtlichen Site, die in der Lage ist, die Arbeit zu präsentieren, zeige ich Ihnen, wie Sie sie einem von Django generierten Content Management System (CMS) hinzufügen und wie einfach es ist, sie für das Hosting Ihrer Site und auf Heroku bereitzustellen Überwachen Sie anschließend Datenverkehr, Fehler und Antwortzeiten mithilfe der in Heroku integrierten New Relic-Integration. Alles kostenlos, innerhalb weniger Stunden nach der Arbeit.

Erstellen Sie Ihre Website

Zunächst benötigen Sie ein Projekt, das Sie in der Cloud hosten möchten. Wie bereits erwähnt, bestand mein Projekt darin, schnell eine Portfolio-Website zu erstellen, auf der meine Artikel und andere Projekte zusammen mit meinen Lebenslauf- und Kontaktinformationen präsentiert werden können. Python und Django passten perfekt zu diesen Anforderungen, und Sie können schnell mit der Erstellung einer dynamischen Website mit Django und seinem ORM-Design beginnen, die eine einfache Integration zwischen Ihren Webvorlagen und den in einer Datenbank gespeicherten zugrunde liegenden Daten ermöglicht.

Bevor Sie Code schreiben, sollten Sie eine virtuelle Python-Umgebung für Ihr Projekt erstellen, um die Abhängigkeiten für dieses Projekt von allen anderen zu trennen. Unter der Haube kopiert virtualenv Ihre globale Python-Installation effektiv in den Ordner .virtualenvs unter einem benannten Verzeichnis für Ihre virtualenv. Anschließend wird dieser Speicherort an der Vorderseite Ihres Pfads hinzugefügt, sodass Ihr System diese Python-Installation für Ihr Projekt verwendet. Alle Abhängigkeiten werden dann hier anstatt global installiert. Sie können dies tun, indem Sie zuerst virtualenv und virtualenvwrapper mit Pythons Paketmanager "pip" installieren.

1	$ pip install virtualenv
2	$ pip install virtualenvwrapper

Nach der Installation der virtualenv-Tools sollten Sie Ihrer .bashrc-Datei in Ihrem Home-Verzeichnis (Linux / Mac OS X) eine Quellzeile hinzufügen, die die virtualenvwrapper-Skripts in der Befehlszeile aktiviert und das einfache Erstellen, Aktivieren und Löschen virtueller Umgebungen ermöglicht. Sie können die virtualenv wie folgt erstellen.

1	$ mkvirtualenv portfolio

Mit Ihrer Umgebung können Sie dann Django installieren, mit dem Sie die Webanwendung definieren. Django kann durch Ausführen des folgenden Befehls installiert werden.

1	$ pip install django

Wenn die Abhängigkeiten vorhanden sind, besteht Ihr erster Schritt beim Erstellen Ihres Django-Projekts darin, ein Verzeichnis zu erstellen, in dem Ihre Dateien nach einer ziemlich standardmäßigen Struktur gespeichert werden (siehe unten). Glücklicherweise hilft Django, diesen Prozess mithilfe des Befehlszeilentools django-admin.py zu automatisieren. Führen Sie die folgenden Schritte aus, um Ihr Projekt- und Anwendungsverzeichnis zu erstellen.

1	$ django-admin.py startproject tuts

Das erzeugt die folgende Struktur.

    tuts/
        tuts/
            __init__.py
            settings.py
            urls.py
            wsgi.py

Weitere Informationen zum Einrichten von Django-Anwendungen finden Sie in der offiziellen Django-Dokumentation. Eine grundlegende Zusammenfassung dieser Dateien lautet so:

settings.py - Die Konfiguration für Ihre Django-Anwendung, z. B. Datenbankverbindungen und Apps (siehe unten).
urls.py - Die Routen, die auf die verschiedenen Teile Ihrer Websites verweisen.
wsgi.py - Eine Datei, mit der Ihre Anwendung von Webservern wie Apache gestartet werden kann.

Das bisher erstellte Projekt ist nur der äußere Container für Ihre eigentliche Webanwendung. Das Fleisch des Codes sollte in einer App enthalten sein, und Sie können erneut die Hilfsmethoden von Django verwenden, um die App-Struktur für Sie zu erstellen.

1	$ python manage.py startapp portfolio

Dies wird im Folgenden zu unserer gesamten Verzeichnisstruktur hinzugefügt.

    tuts/
        tuts/
            __init__.py
            settings.py
            urls.py
            wsgi.py
        portfolio/
            admin.py
            models.py
            tests.py
            views.py

Wenn Ihre App erstellt wurde, müssen Sie sie in Ihrem Django-Projekt registrieren. Öffnen Sie settings.py und fügen Sie dem INSTALLED_APPS-Tupel "Portfolio" hinzu:

    INSTALLED_APPS = (
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
        'portfolio'
    )

Um zu überprüfen, ob alles funktioniert, geben Sie den folgenden Befehl ein und besuchen Sie http://localhost:8000 in Ihrem Browser. Sie sollten eine Seite wie die im Bild unten gezeigte sehen.

Modell definieren

Nachdem Ihr Projektverzeichnis eingerichtet ist, können Sie den Code ausarbeiten. Da wir die Art der Daten kennen, die wir der Portfolio-Site hinzufügen möchten, können wir mit der Definition des Modells beginnen. Dies beschreibt unsere Daten in der Datenbank und ermöglicht es Django, die entsprechenden Felder und Tabellen in der Datenbank für uns zu erstellen. Auf unserer Website werden wir Einträge für Artikel, Bücher und Abschlussarbeiten veröffentlichen. Jedes dieser Modelle kann ein eigenes Modell haben, wenn Sie ihnen eindeutige Datenfelder zuweisen möchten, die für die anderen Eintragstypen nicht gelten. Für diese Website erhält jeder Eintrag jedoch einen Namen, ein Veröffentlichungsdatum, eine Beschreibung und eine URL. In der Datei models.py unter dem Portfolio-App-Verzeichnis können Sie diese Eintragsdaten wie folgt definieren:

    class Item(models.Model):
        publish_date = models.DateField(max_length=200)
        name = models.CharField(max_length=200)
        detail = models.CharField(max_length=1000)
        url = models.URLField()
        thumbnail = models.CharField(max_length=200)

Wenn das Modell definiert ist, können Sie es in der Datenbank mithilfe der in Django integrierten Befehlszeilentools generieren, die Ihnen nach der Installation zur Verfügung gestellt werden. Wenn Sie die Datei manage.py erneut verwenden, können Sie auch den Befehl syncdb verwenden, um das Datenbank-Setup für Sie durchzuführen. Wenn Sie den folgenden Befehl eingeben, werden Ihnen die verfügbaren Optionen angezeigt, die dieses Admin-Tool bietet.

    $ python manage.py syncdb
    Creating tables ...
    Creating table portfolio_item
    Installing custom SQL ...
    Installing indexes ...
    Installed 0 object(s) from 0 fixture(s)

Mit der syncdb-Methode kann Django das soeben erstellte Modell lesen und die richtige Struktur einrichten, um diese Daten in der Datenbank zu speichern. Da Sie diesen Befehl zum ersten Mal ausführen, werden Sie von Django auch aufgefordert, einige Fragen zu beantworten. Dazu gehören Elemente wie das Erstellen eines Superusers für die Datenbank (im Wesentlichen des Administrators), mit dem Sie Ihr Kennwort vor Aktualisierungen und Änderungen an der Datenbank schützen können. Dieser Benutzer ist auch der erste Benutzer, der sich beim CMS anmelden kann. Dieser wird für die Website generiert, sobald die Vorlagen eingerichtet sind.

Bei der Benutzerkonfiguration sollte der Befehl zurückgeben und anzeigen, dass SQL für die Datenbank ausgeführt wurde. Der nächste Schritt besteht darin, jetzt auf die gespeicherten Daten zugreifen zu können, um ein dynamisches Frontend zu erstellen, das Sie dem Benutzer anzeigen möchten. Um dies zu erreichen, müssen Sie den Ansichten Code hinzufügen, um auf die Daten zuzugreifen, die Sie in der Datenbank speichern. Mit den für die Ansichten verfügbaren Daten kann diese dann an Vorlagen weitergegeben werden, die als Informationen an den Endbenutzer interpretiert werden können. In diesem Fall erfolgt dies in Form von HTML-Seiten für einen Webbrowser. Es ist jedoch anzumerken, dass dieses Muster für andere Anwendungstypen verwendet werden kann, z. B. zum Erstellen von JSON oder XML, bei denen wiederum nur das Modell zum Definieren und Verschieben der Daten und der sie darstellenden Ansichten im richtigen JSON-Format verwendet wird / XML im Gegensatz zu HTML.

Unsere Ansichten

In den Ansichten verwenden Sie die Daten, die in der Datenbank gespeichert werden, um sie den Benutzern anzuzeigen. Dazu importieren wir die Item-Klasse, um auf dieses Modell zuzugreifen (wobei Django den Zugriff auf die darunter liegende Datenbank übernimmt) und stellen die Daten als Variablen für die "Vorlage" bereit, die Django rendern wird. Die Vorlage besteht hauptsächlich aus statischem HTML und bietet zusätzlich die Möglichkeit, einen eingeschränkten Satz von Python-Code auszuführen, um Ihre Daten zu verarbeiten und nach Bedarf anzuzeigen. Beispielsweise können Sie die gesamte Liste der Elementobjekte an die Vorlage übergeben, diese Liste dann jedoch in der Vorlage durchlaufen, um nur den Namen jedes Elements abzurufen und in einem H1-Tag anzuzeigen. Hoffentlich wird dies anhand der folgenden Beispiele klarer.

Öffnen Sie die zuvor für Sie erstellte Datei views.py und fügen Sie den folgenden Code hinzu, der beim Zugriff auf die Startseite (oder Indexseite) Ihrer Website ausgeführt wird.

1	def index(request):
2	items = Item.objects.order_by("-publish_date")
3	now = datetime.datetime.now()
4	return render(request, 'portfolio/index.html', {"items": items, "year": now.year})

Dadurch werden alle in der Datenbank gespeicherten Elemente erfasst, nach dem Veröffentlichungsdatum sortiert, Sie können die neuesten zuerst anzeigen und diese dann an die Vorlage übergeben, die Sie in Kürze erstellen werden. Das an die Rendermethode übergebene Wörterbuch wird als Kontext bezeichnet. Sie können problemlos auf dieses Kontextobjekt in der Vorlage zugreifen, um die Daten nach Bedarf anzuzeigen.

Vorlagen

Django verwendet die Jinja2-Vorlagenbibliothek, um die Verarbeitung seiner Vorlagen zu handhaben, und ist sehr benutzerfreundlich, da seine Syntax unkompliziert und seine Fähigkeiten leistungsfähig genug sind, um das zu produzieren, was Sie benötigen. Es ist jedoch erwähnenswert, dass eine Falle, in die die meisten Entwickler geraten, wenn sie mit Jinja2 arbeiten, zu viel Logik in der Vorlage darstellt. Während Jinja2 Ihnen eine große Anzahl von Standard-Python-Operationen zur Verfügung stellt, ist es für eine einfache Verarbeitung vorgesehen, um die Daten in dem Format für die Anzeige zu erhalten. Die Logik zum Abrufen und Strukturieren der Daten sollte alle in der Steuerung und / oder Ansicht ausgeführt worden sein. Sie werden wissen, wann Sie in diese Falle geraten sind, wenn Sie viel in den Vorlagen codieren und frustriert sind, wenn Jinja2 Fehler ausgibt oder Ihre angezeigten Daten einfach nicht so erscheinen, wie Sie es möchten. An dieser Stelle lohnt es sich, die Ansicht erneut zu überprüfen, um festzustellen, ob Sie im Voraus mehr Verarbeitung durchführen können, bevor Sie sie an die Vorlage weitergeben.

Bei unserer index-Methode für den Zugriff auf Daten müssen Sie lediglich die Vorlage für die Anzeige unserer Artikel definieren. Wie von der index-Methode vorgeschlagen, müssen Sie in der Portfolio-App eine index.html-Datei hinzufügen, damit sie gerendert werden kann. Fügen Sie diese Datei mit dem folgenden Code hinzu.

<!DOCTYPE html>

<html>

<head lang="en">

    <meta charset="UTF-8">

    <title>Tuts+ Django Example</title>

</head>

<body>

<h1>Welcome to your Django Site.</h1>

<h3>Here are your objects:</h3>

<p>

    <ul>

    {% for item in items %}

    <li>

        {{ item.name }}

    </li>

    {% endfor %}

    </ul>

</p>



</body>

</html>

Das ist eine einfache HTML-Seite, die eine Schleife erstellt und eine Aufzählungspunktliste der Elementnamen erstellt. Sie können dies natürlich so gestalten, wie Sie möchten, und ich empfehle die Verwendung einer Bootstrap-Vorlage, wenn Sie schnell etwas Professionelles zum Laufen bringen möchten. Weitere Informationen finden Sie auf der Bootstrap-Website.

URLs

Das letzte Stück, um zu sehen, ob alles funktioniert, besteht darin, die Stamm-URL hinzuzufügen, um auf diese zu rendernde Vorlage zu verweisen. Öffnen Sie im App-Verzeichnis "tuts" die Datei urls.py und fügen Sie den automatisch generierten Beispielen und der Administrator-URL die folgende URL-Direktive hinzu.

    urlpatterns = patterns('',
    # Examples:
    # url(r'^$', 'tuts.views.home', name='home'),
    # url(r'^blog/', include('blog.urls')),

    url(r'^admin/', include(admin.site.urls)),
    url(r'^$', views.index, name='index'),
)

Öffnen Sie abschließend admin.py, um die Item-Klasse für das Admin-CMS verfügbar zu machen und die Daten einzugeben, die auf der Homepage angezeigt werden sollen.

1	from portfolio.models import Item
2
3
4	admin.site.register(Item)

Sie sollten dann in der Lage sein, Ihre Site zu starten (unter run server wie zuvor) und die folgenden Aufgaben auszuführen.

Öffnen Sie die Homepage und stellen Sie sicher, dass keine Elemente angezeigt werden.
Öffnen Sie http://localhost:8000/admin und geben Sie die zuvor mit syncdb erstellten Anmeldeinformationen ein.
Öffnen Sie Elemente und fügen Sie ein neues Element hinzu, das die Felder ausfüllt.
Besuchen Sie die Hommage und Sie sollten den Artikelnamen als Aufzählungszeichen sehen.

Versuchen Sie, auf andere Aspekte der Artikeldaten in der Vorlage zuzugreifen. Ändern Sie beispielsweise den Code innerhalb des Aufzählungspunkts, um auch das Veröffentlichungsdatum hinzuzufügen. Beispielsweise:

1	{{ item.publish_date }} - {{ item.name }}

Sie haben jetzt eine Arbeitswebsite, die lediglich etwas Stil und mehr Inhalt benötigt, um als funktionierende Portfolio-Website fungieren zu können.

Bereitstellung in Heroku

Heroku ist eine großartige Cloud-Plattform, die allen Entwicklern und Unternehmen als Hosting-Service der Enterprise-Klasse zur Verfügung gestellt wird und auf alle Hosting-Anforderungen zugeschnitten ist. Von Hobby-Websites bis hin zu stark frequentierten, kritischen Business-Websites kann Heroku alles bewältigen. Das Beste ist, dass ihre Preisstruktur eine kostenlose Stufe umfasst, die mehr als in der Lage ist, eine kleine Website wie die von uns erstellte Portfolio-Website zu betreiben.

Heroku nutzt das beliebte Git-Quellcode-Management-Tool als Mechanismus zur Steuerung der Bereitstellung auf der Plattform. Alles, was Sie brauchen, um loszulegen, ist ein Projekt, ein installiertes git und ein Heroku-Konto, das Sie auf der Anmeldeseite erhalten.

Sobald Sie sich angemeldet haben, gehen Sie in Ihr Heroku-Konto und erstellen Sie eine App mit einem "Web-Dyno". Heroku stellt einen Dyne kostenlos zur Verfügung, mit dem eine einzelne Anwendungsinstanz ausgeführt und der Datenverkehr zu dieser Instanz moderiert werden kann. Geben Sie Ihrer App einen Namen oder lassen Sie Heroku einen für Sie zuweisen. Da wir für unsere Anwendung eine Datenbank verwenden müssen, gehen Sie zu Add-Ons und hängen Sie die kostenlose PostgreSQL-Instanz an Ihre App an.

Befolgen Sie bei der Erstellung Ihrer App einfach die folgenden Schritte, um Ihr git-Repository einzurichten und zu Heroku zu wechseln.

Installieren Sie den Django Toolbelt, den Sie im Entwicklerbereich der Heroku-Website finden.

Initialisieren Sie das Git-Repo in Ihrem Projektverzeichnis, indem Sie die folgenden Befehle eingeben:

1	$ git init .
2	$ git add .
3	$ git commit -m "Initial project commit."

Fügen Sie bei vorhandenem Git-Repository die Heroku-Anwendungsfernbedienung hinzu, damit Sie den Code an heroku senden können.

1	$ heroku git:remote -a YOUR_APP_NAME

Heroku muss den Befehl genau kennen, um Ihre Anwendung zu starten. Dazu müssen Sie ein "Procfile" hinzufügen. Fügen Sie die Datei mit dem Namen "Procfile" mit dem folgenden Inhalt in das Stammverzeichnis Ihres Projektverzeichnisses ein.

1	web: gunicorn tuts.wsgi

Damit die Heroku-App eine Verbindung zu der an Ihre Anwendung in der Cloud angeschlossenen Datenbankinstanz herstellen kann, müssen Sie die folgende Zeile zu settings.py hinzufügen. Dies bedeutet, dass Sie keine Konfiguration fest codieren müssen und Heroku die Verbindungen für Sie übernimmt.

1	if not os.environ.get("HOME") == ‘/PATH/TO/YOUR/HOME‘:
2	# Parse database configuration from $DATABASE_URL
3	import dj_database_url
4	DATABASES['default'] = dj_database_url.config()

Durch Umschließen der Einstellung dieser Datenbankverbindung in die if-Anweisung kann die Konfiguration wie auf Ihrem lokalen Computer ausgeführt werden, die Datenbank wird jedoch unter Heroku korrekt eingerichtet.

Sie müssen auch eine requirements.txt hinzufügen, die Ihre Python-Abhängigkeiten für die Anwendung angibt, damit Heroku sie in der erstellten Umgebung installieren kann. Fügen Sie die Datei requirements.txt auf derselben Ebene wie das Procfile mit den folgenden Inhalten hinzu:

    Django==1.6.2
    dj-database-url==0.3.0
    dj-static==0.0.5
    django-toolbelt==0.0.1
    gunicorn==18.0
    newrelic==2.16.0.12
    psycopg2==2.5.2
    wsgiref==0.1.2

Wenn diese Dateien erstellt wurden, fügen Sie sie zu Git hinzu und drücken Sie sie dann auf die Heroku-Fernbedienung, wo sie empfangen und gestartet werden.

1	$ git add .
2	$ git commit -m "Added procfile and requirements.txt"
3	$ git push heroku master

Sie sollten eine Ausgabe sehen, wenn diese an Heroku gesendet wird und mit der folgenden Meldung endet: "http://APP_NAME.herokuapp.com/ für Heroku bereitgestellt"

Wenn Sie jetzt auf die URL klicken, wird eine Fehlermeldung angezeigt. Wenn Sie sich auf Ihrem lokalen Computer erinnern, müssen Sie syncdb ausführen, um die Tabellen in der Datenbank zu erstellen, die von der Anwendung verwendet werden sollen. Sie müssen dieses Verhalten auf unserer Heroku-Instanz reproduzieren. Glücklicherweise bot Heroku eine einfache Möglichkeit, diese Befehle für Ihre Anwendungsinstanz in dem zuvor installierten Werkzeuggürtel auszuführen.

1	$ heroku run python manage.py syncdb

Sie sollten dann in der Lage sein, Ihren Link zu besuchen und die auf Heroku laufende Website kostenlos zu sehen. Versuchen Sie, einige Elemente auf dieselbe Weise wie lokal zu Ihrer Datenbank hinzuzufügen, um sicherzustellen, dass die Datenbank ordnungsgemäß eingerichtet ist.

Neues Relikt hinzufügen

Nachdem Ihre Anwendung erfolgreich auf der Heroku-Plattform bereitgestellt wurde, können Sie sich nun die vielen bereitgestellten Add-Ons ansehen. Heroku bietet eine große Auswahl an Add-Ons, darunter Datenbanken, Überwachungstools, erweiterte Protokolltools, Analysen, E-Mail-Anbieter und vieles mehr. Die Add-Ons sind einer der großen Aspekte beim Hosten Ihrer Anwendung auf Heroku, da sie schnell und einfach Ihrer Anwendung zugewiesen und innerhalb von Minuten konfiguriert und funktionsfähig gemacht werden können. Heroku hat den Prozess zum Hinzufügen dieser Tools optimiert und nimmt Ihnen viel Arbeit ab, sodass Sie sich auf die Lieferung Ihres Produkts konzentrieren können.

Eines der Add-Ons, auf die sich dieser Artikel konzentrieren wird, ist das Anhängen des großartigen Überwachungs- und Analysetools New Relic. New Relic bietet zahlreiche Funktionen zum Eingraben in Ihre Anwendung und zum Bereitstellen von Statistiken und Daten zu Elementen wie Anforderungen pro Minute, Fehlern, Antwortzeiten und mehr. Das Beste von allem ist, dass Heroku erneut eine kostenlose Stufe zum Hinzufügen zu Ihrer Website bereitstellt, die mit dem kostenlosen Hosting, das wir derzeit haben, einhergeht.

Das Hinzufügen eines neuen Relikts zu Ihrer Heroku-Anwendung ist einfach und erfordert, dass Sie sich einfach auf Ihrer Heroku-Kontoverwaltungsseite anmelden. Klicken Sie dort in die Anwendung, zu der Sie sie hinzufügen möchten, und wählen Sie "+ Add-Ons abrufen". Anschließend erhalten Sie eine Vielzahl von Add-Ons, die Heroku bereitstellt. Suchen Sie nach "New Relic" und klicken Sie darauf. Eine Seite mit der Beschreibung und den Preisen wird angezeigt und eine Aufschlüsselung der Funktionen, die auf jeder Preisstufe aktiviert sind. Für die kostenlose Stufe erhalten Sie im Wesentlichen Zugriff auf fast alle Funktionen, sind jedoch nur an Daten der letzten sieben Tage gebunden. Auf der Add-On-Seite New Relic können Sie den Code einfach kopieren und einfügen, um New Relic an Ihre Anwendung anzuhängen und in der Befehlszeile auszuführen.

1	$ heroku addons:add newrelic:stark

Wenn dies hinzugefügt wurde, können Sie Ihre App-Seite in Ihrem Heroku-Konto erneut aufrufen. Jetzt sollte New Relic unter Ihrer Datenbank aufgeführt sein. Klicken Sie darauf, um die Einrichtung in Ihrem New Relic-Konto zu starten. Hier müssen Sie die Allgemeinen Geschäftsbedingungen akzeptieren und dann den Anweisungen zum Installieren von New Relic in Ihrer Django-Anwendung folgen. Diese sind wie folgt:

Fügen Sie Ihrer requrements.txt "newrelic" hinzu und führen Sie dann Folgendes aus: $ pip install -r requirements.txt
Führen Sie diesen Befehl aus, indem Sie den Ihnen angezeigten Lizenzschlüssel ersetzen: $ newrelic-admin generate-config YOUR_LICENCE_KEY newrelic.ini
Öffnen Sie die neu generierte Datei newrelic.ini und ändern Sie den "app_name" in etwas, das für Sie von Bedeutung ist, z. B. "Django Tuts+" oder "Django Portfolio".
Bearbeiten Sie die Procfile, um den Start des New Relic-Agenten auf dem Server einzuschließen:NEW_RELIC_CONFIG_FILE=newrelic.ini newrelic-admin run-program gunicorn tuts.wsgi
Übernehmen Sie diese Änderungen und übertragen Sie sie an Heroku. In Kürze sollten Anwendungsdaten an New Relic gemeldet werden.$ git add .$ git commit -m "Added New Relic config."$ git push heroku master
Nachdem Sie in New Relic auf die Schaltfläche "Connect App" geklickt und einige Anforderungen an die Anwendung gesendet haben, sollte New Relic anzeigen, dass die Anwendung eine Verbindung hergestellt hat, und Sie können zu Ihrem Dashboard durchklicken, um die Daten anzuzeigen.

Einpacken

Das ist alles dazu! Innerhalb von ca. 15 Minuten können Sie Ihrer Anwendung erneut kostenlos eine vollständige Überwachung der New Relic-Anwendung hinzufügen.

Tuts+ hat kürzlich einige großartige Artikel veröffentlicht, in denen New Relic vorgestellt und einige fortgeschrittenere Techniken und Verwendungen für das Überwachungstool gezeigt werden. Sie finden die gesamte Artikelpalette oder alternativ können Sie direkt zu meinem anderen Artikel über Leistungstests mit New Relic und JMeter übergehen.

Hoffentlich haben Sie dieses Tutorial als informativ empfunden und etwas, in das Sie direkt eintauchen und es in ein oder zwei freien Stunden selbst ausprobieren können. Mit ein wenig Styling und einigen Inhalten, die über die von Django erstellte Administrationsseite eingegeben wurden, können Sie schnell eine professionelle Website entwickeln, die kostenlos gehostet und überwacht wird.

Kasse meiner Website in meinem Autorenprofil, das in Django geschrieben, von Heroku gehostet und von New Relic überwacht wurde, was das Schreiben dieses Artikels inspirierte.