Die Integration von Stripe-Zahlungen in Django

Was ist eine Stripe-Zahlung?

Beginnen wir mit den grundlegendsten Fragen: Was ist Stripe? Was ist eine Stripe-Zahlung?

Stripe ist eine Plattform für die Abwicklung von Online-Zahlungen. Es unterstützt auch Kreditkarten.

Er ist einfach ein Vermittler zwischen dem Kunden (z. B. eines Online-Shops) und dem Verkäufer, zwischen der Bank des Käufers und der des Verkäufers.

Handelt es sich um ein weiteres Einfallstor, wie so viele, auf dem US-Markt? Nicht unbedingt, aber wir werden gleich auf die Einzelheiten eingehen.

Stripe bietet einen Service, der beiden Parteien eine schnelle, einfache und vor allem sichere Transaktion garantiert.

Als Zahlungsdienstleister bietet Stripe mehrere Zahlungsmethoden an — einschließlich aufgeschobener Zahlungen oder wiederkehrender Rechnungen.

Der Abschluss einer bestimmten Transaktion ist natürlich mit einer Zahlung verbunden.

Die Reichweite von Stripe hebt das Unternehmen vom Rest der Konkurrenz ab.

Die in den USA ansässige Marke bietet Unterstützung für mehr als 130 Währungen und ist damit eine optimale Lösung für Unternehmen, die ihre Produkte auf internationalen Märkten verkaufen.

Stripe ist ideal für Unternehmen, für die das Anbieten von Zahlungen in Fremdwährungen ein wichtiger Bestandteil des Wettbewerbs ist. Für diejenigen, für die der Währungsumtausch eine tägliche Praxis, eine Notwendigkeit und eine tägliche Sorge um die Kosten des Währungsumtauschs ist.

Was die Kosten für die Währungsumrechnung betrifft, so gilt Stripe als sehr wettbewerbsfähige und attraktive Lösung.

Stripe bietet Zahlungsabwicklung in verschiedenen Geschäftsmodellen, einschließlich:

• E-Commerce (B2C)
• Plattform B2B
• Virtuelle Brieftasche
• Spendensammler
• Unterstützung von Non-Profit-Organisationen
• Software as a Service (SaaS)

Darüber hinaus unterstützt die API für Zahlungen von Stripe die meisten universellen Zahlungssysteme, nämlich:

• Alipay
• Apple Pay
• Google Pay
• WeChat Pay

Warum sollten wir Stripe verwenden?

Ein Maß für die Qualität der von Stripe angebotenen Dienstleistungen, Produkte, Programme und Lösungen ist die Qualität:

• Schneller und einfacher Integrationsprozess — der Registrierungs- und Verifizierungsprozess ist ziemlich schnell und erfordert nicht die Erfüllung sehr restriktiver Kriterien.
• Das integrierte System, in dem verschiedene Formen der Zahlungsabwicklung möglich sind.
• Flexibilität und Anpassungsfähigkeit der Stripe-APIs an individuelle Bedürfnisse.
• Umfangreiche Bibliotheken, die Entwicklern Funktionalitäten zusammen mit der Dokumentation zur Verfügung stellen.
• Erweiterte Berichtswerkzeuge.

Abonnements (wiederkehrende Zahlungen) in Stripe

Neben einzelnen Transaktionen bietet Stripe auch wiederkehrende Zahlungen an, die vor allem für SaaS- und PaaS-Dienste genutzt werden.

Mit Stripe können wir in unserer Anwendung ganz einfach ein auf Abonnementgebühren basierendes Geschäftsmodell implementieren.

Dies geschieht ohne die Notwendigkeit einer komplexen Schnittstelle und Logik, die für den Benutzer notwendig ist, um wiederkehrende Zahlungen bequem zu handhaben.

Anhand dieses Beispiels für die Unterstützung von Abonnements möchten wir zeigen, wie Sie Ihr Abenteuer mit Stripe in Anwendungen, die auf dem Django-Framework basieren, einfach und angenehm beginnen können.

Zahlungsintegration in Django

Wiederkehrende Zahlungen sind per definitionem komplizierter als einmalige Transaktionen. Sie sind von Natur aus asynchron, und was asynchron ist, erfordert normalerweise mehr Arbeit und ist schwieriger zu testen und später zu warten.

Im weiteren Verlauf dieses Artikels zeigen wir, wie man ein Abonnementmodell in einer Django-basierten Anwendung implementiert, und erläutern die Grundlagen des Stripe-Workflows.

Wir werden hier nicht die Grundlagen von Django behandeln, wie z.B. die Erstellung von Views, Routing oder Konfiguration. Wir gehen davon aus, dass Sie ein Python-Entwickler sind und mehr als eine Anwendung in Django erstellt haben. Konzentrieren wir uns also auf die interessante Sache — Stripe.

Haftungsausschluss:

Der unten gezeigte Code darf nicht in der Produktionsversion einer Anwendung verwendet werden.

In diesem Codeschnipsel sind keine Fehler- und Ausnahmebehandlung enthalten, und wir passen die Sicherheitsanforderungen nicht an, die oft individuell sind.

Wir haben auch viele Szenarien und Anwendungsfälle von geringerer Bedeutung ausgelassen. Die Aufgabe, die wir uns bei der Vorbereitung des folgenden Codes gestellt haben, besteht darin, die allgemeinen Prinzipien der Integration von Stripe in eine Django-Anwendung zu zeigen.

Unser Team würde einen solchen Code niemals in der Produktionsversion einer Anwendung verwenden.

Vorbereitung

Wir können an einer bestehenden Django-Anwendung arbeiten oder ein neues Projekt erstellen — für die Integration müssen wir keine komplizierten Änderungen an der Architektur vornehmen oder Abhängigkeiten installieren, die die Anwendung beeinträchtigen würden.

Das Einzige, was wir zu unserer virtuellen Umgebung hinzufügen müssen, ist die offizielle `stripe`-Bibliothek für Python:

pip install stripe

Der nächste Schritt besteht darin, ein Stripe-Konto zu erstellen. Der Registrierungsprozess selbst ist unkompliziert und erfordert keine zusätzlichen Kommentare, zumal wir kein Produktionskonto einrichten und eine zusätzliche Unternehmensüberprüfung nicht erforderlich ist.

Stattdessen müssen wir nach der Registrierung folgende Schritte durchführen, um mit der Stripe-API arbeiten zu können (in der offiziellen Dokumentation finden Sie dazu keine Informationen, und wir möchten Ihnen die Zeit ersparen, nach den Fehlerursachen zu suchen):

• Geben Sie dem Unternehmen einen Namen, indem Sie auf die obere linke Ecke neben der Schaltfläche Konto aktivieren klicken.
• Füllen Sie die Links zu den Nutzungsbedingungen und der Datenschutzerklärung in unseren Kontoeinstellungen aus (Einstellungen > Abrechnung > Kundenportal).

Für weitere Tests benötigen wir auch das Stripe CLI-Tool, das die Arbeit in einer lokalen Umgebung sehr viel angenehmer macht. Wie? Das können Sie in diesem Artikel herausfinden: https://stripe.com/docs/stripe-cli

Als nächstes müssen wir den Einstellungen unserer Django-Anwendung zwei Parameter hinzufügen, die für die Kommunikation mit der Stripe-API erforderlich sind. Die Benennung der Einstelltasten ist nicht zwingend erforderlich und sollte als Anregung betrachtet werden:

STRIPE_API_KEY = ********
STRIPE_HOOKS_SECRET = ********

Wir können den Wert für "STRIPE_API_KEY" erhalten, indem wir im Stripe-Dashboard zu Developers > API keys gehen und den Wert des geheimen Schlüssels kopieren. Wir werden `STRIPE_HOOKS_SECRET` später ausfüllen, und in diesem Stadium können wir es auf eine leere Zeichenkette setzen.

Der letzte Schritt besteht darin, Testdaten in unserem Stripe-Konto zu erstellen. Dazu können Sie einen einfachen Django CLI-Befehl verwenden, der ein Produkt und drei Abonnementpakete erstellt:

import stripe
from django.conf import settings
from django.core.management import BaseCommand

class Command(BaseCommand):
    def handle(self, *args, **options):
        stripe.api_key = settings.STRIPE_API_KEY
        product = stripe.Product.create(name='Awesome Service')
        for i in range(1, 4):
            stripe.Price.create(
                product=product['id'],
                currency='usd',
                unit_amount=i * 1000,
                recurring={'interval': 'month'},
                lookup_key=f'service_{i}',
                nickname=f'Service level {i}',
            )

Sie können Testdaten auch über das Stripe-Verwaltungspanel erstellen. Leider können wir im Panel keinen `lookup_key`-Wert für einzelne Preispakete angeben, was zu einigen Implementierungsproblemen führt, da die Identifizierung in Abfragen auf der price package ID basieren muss, was Stripe nicht empfiehlt.

Wir haben die Umgebung vorbereitet und können nun mit der eigentlichen Integration beginnen.

Ansicht der Paketauswahl

Zunächst erstellen wir eine einfache Ansicht, die es dem Benutzer ermöglicht, das Preispaket für unser Abonnement auszuwählen und den Zahlungsvorgang zu starten.

In der Ansicht laden wir alle Preisoptionen für das erste aktive Produkt in unserem Stripe-Konto herunter:

def index(request):
    active_products = stripe.Product.list(active=True)
    prices = stripe.Price.list(product=active_products['data'][0]['id'])
    return render(request, 'subscriptions/index.html', {
        'prices': prices['data'],
    })
Die Ansichtsvorlage ist ebenfalls sehr einfach — wir zeigen ein Optionsfeld an, mit dem der Benutzer ein Abonnementpaket auswählen kann:
{% extends 'base.html' %}
{% block body %}
  <h1>Checkout page</h1>
  <form action="{% url 'create-checkout-session' %}" method="post">
    {% csrf_token %}
    {% for obj in prices %}
      {% widthratio obj.unit_amount 100 1 as price %}
      <label>
        <input type="radio" name="lookup_key" value="{{ obj.lookup_key }}" {% if forloop.first %}checked{% endif %}>
        {{ obj.nickname }} for {{ price|floatformat:2 }} {{ obj.currency|upper }} per {{ obj.recurring.interval }}
      </label><br>
    {% endfor %}
    <p>
      <button>Checkout</button>
    </p>
  </form>
{% endblock %}

Das Formular zur Paketauswahl wird an die Ansicht `create-checkout-session` gesendet, die im nächsten Schritt vorgestellt wird. Wir werden die Ansicht auf der Grundlage der Daten des Preispakets direkt von der Stripe-API anzeigen, wobei der Preis in Cent angegeben wird, sodass wir eine einfache Umrechnung vornehmen müssen.

Django-Templates bieten keine Möglichkeit, Divisionen in Templates durchzuführen. Um zu vermeiden, dass wir ein eigenes Tag schreiben, verwenden wir das eingebaute Tag `{% withration %}`, das der Division der Anzahl der Cents durch 100 entspricht.

Wenn wir die Adresse der Ansicht in den Browser eingeben, sollten wir das folgende Ergebnis erhalten:

Ansicht der Transaktionseinleitung

Das ausgewählte price package (genauer gesagt, der `lookup_key` des ausgewählten Pakets) wird per POST an diese Ansicht übergeben.

Wir rufen die Paket-ID ab, öffnen dann eine Stripe-Kassensitzung und leiten den Benutzer an die daraus resultierende URL weiter, wo der Benutzer auf eine von Stripe gehostete Zahlungsseite weitergeleitet wird und eine Zahlung außerhalb unseres Systems vornimmt.

def create_checkout_session(request):
    prices = stripe.Price.list(
        lookup_keys=[request.POST['lookup_key']],
        expand=['data.product']
    )
    success_url = request.build_absolute_uri(reverse('success')) + '?session_id={CHECKOUT_SESSION_ID}'
    cancel_url = request.build_absolute_uri(reverse('cancel'))
    checkout_session = stripe.checkout.Session.create(
        payment_method_types=['card'],
        line_items=[{'price': prices.data[0].id, 'quantity': 1}],
        mode='subscription',
        success_url=success_url,
        cancel_url=cancel_url,
    )
    return redirect(checkout_session.url)

Die Methode `stripe.checkout.Session.create` sollte in unserem Fall die folgenden Parameter erhalten:

• `payment_method_types` — Liste der dem Benutzer zur Verfügung stehenden Zahlungsmittel
• `line_items` — eine Sammlung von Preislistenpositionen, die in der Zahlung enthalten sein werden
• `mode` — Zahlungsart, wir sind an wiederkehrenden Zahlungen interessiert
• `success_url`— eine URL, an die der Benutzer nach erfolgreicher Zahlung weitergeleitet wird, achten Sie darauf, den Platzhalter `{CHECKOUT_SESSION_ID}` einzuschließen, der auf der Stripe-Seite durch den Sitzungsschlüssel ersetzt wird, der für den Erhalt von Transaktions- und Benutzerdaten benötigt wird.
• `cancel_url` — URL, zu der der Benutzer umgeleitet wird, wenn die Zahlung fehlschlägt; aus irgendeinem Grund kann sie die gleiche sein wie `success_url`.

Nach erfolgreicher Zahlung in Stripe wird der Benutzer über die in der `success_url` angegebene Adresse zu unserer Anwendung zurückgeleitet. Die unter dieser Adresse verfügbare Ansicht werden wir im nächsten Schritt untersuchen.

Die Ansicht der erfolgreichen Zahlung

Die Ansicht "Erfolgreiche Zahlung" ist eine Erfolgsseite, die der Benutzer nach einer erfolgreichen Zahlung sieht, wenn er den Parameter `session_id` im Query-String erhält (entsprechend der Vorlage, die wir im vorherigen Schritt übergeben haben).

Dies ist genau der Punkt, an dem wir die `customer ID` von Stripe mit unserem Benutzer in Django verknüpfen können — sie wird benötigt, um die Abonnement-Ereignisse des Benutzers und die Generierung der `portal session` zu empfangen, worüber wir als nächstes sprechen werden.

Um die Dinge zu vereinfachen, speichern wir die `customer ID` nicht, sondern übergeben sie an die Vorlage, wo wir dem Benutzer erlauben, mit der Abonnementverwaltung in Stripe fortzufahren.

def success(request):
    checkout_session = stripe.checkout.Session.retrieve(request.GET['session_id'])
    return render(request, 'subscriptions/success.html', {
        'customer': checkout_session.customer,
    })

Und hier ist der Code der Vorlage:

{% extends 'base.html' %}
{% block body %}
  <h1>Success!</h1>
  <form action="{% url 'create-portal-session' %}" method="post">
    {% csrf_token %}
    <input type="hidden" name="customer" value="{{ customer }}">
    <button>Manage your subscription</button>
  </form>
{% endblock %}

Der Übergang zur Abonnementverwaltung (Kundenportal) erfolgt durch Senden der `customer ID` an die Ansicht `create-portal-session`, die für die Weiterleitung des Benutzers zum Abonnementprofil in Stripe verantwortlich ist.

Ansicht der Einleitung des Übergangs zum Benutzerportal

Stripe bietet eine schnelle und bequeme Möglichkeit, Zahlungen zu empfangen, und ermöglicht es uns, ohne viel Arbeit, dem Benutzer eine bequeme und sehr leistungsfähige Benutzeroberfläche für die Verwaltung seines Abonnements, d.h. ein `customer portal`, zur Verfügung zu stellen.

Das Kundenportal ist eine völlig unabhängige und sichere Schnittstelle, die von Stripe gehostet wird. Um den Benutzer zum Portal umzuleiten, müssen wir eine URL mit der `customer ID` generieren, wofür auch die folgende Ansicht zuständig ist.

def create_portal_session(request):
    portal_session = stripe.billing_portal.Session.create(
        customer=request.POST['customer'],
        return_url=request.build_absolute_uri(reverse('subscriptions'))
    )
    return redirect(portal_session.url)

Asynchronität, auch bekannt als Webhooks

Der gesamte Code, den wir bisher geschrieben haben, ist nur für das erste Abonnement gedacht und behandelt nur die erste Belastung der Kundenkarte.

Stattdessen möchten wir den Benutzer auf einer wiederkehrenden Basis und ohne seine Beteiligung belasten — schließlich geht es bei Abonnementmodellen genau darum.

An dieser Stelle kommt Webhooks, das Ereignissystem, das Stripe Entwicklern zur Verfügung stellt, zur Hilfe.

Stripe generiert eine Vielzahl von Ereignissen im Zusammenhang mit der Zahlungsabwicklung, dem Abonnement, der Dokumentenerstellung und vielem mehr. Die Verteilung der Ereignisse erfolgt über das Webhook-Konzept.

Kurz gesagt: Wenn ein Ereignis eintritt, löst Stripe die in der Administrationsoberfläche angegebene URL aus, an die alle Ereignisdaten weitergeleitet werden.

Die Vorlage ist einfach und ermöglicht es uns, den asynchronen Fluss zu handhaben, der ein natürlicher Weg ist, um Abonnements und aufgeschobene Zahlungen zu verwalten.

Lassen Sie uns eine Ansicht erstellen, die Ereignisse von Stripe empfängt, d.h. unseren Webhook-Handler:

@csrf_exempt
def webhooks(request):
    event = stripe.Webhook.construct_event(
        payload=request.body,
        sig_header=request.headers['stripe-signature'],
        secret=settings.STRIPE_HOOKS_SECRET
    )
    data = event['data']
    event_type = event['type']
    data_object = data['object']
    if event_type == 'invoice.paid':
        print(f'Renew customer: {data_object["customer"]}')
    elif event_type == 'customer.subscription.deleted':
        print(f'Cancel subscription: {data_object["customer"]}')
    return JsonResponse({'status': 'success'})

Zunächst müssen wir den Wert des Schlüssels `STRIPE_HOOKS_SECRET` in der Konfiguration unserer Django-Anwendung eintragen, den wir zunächst auf eine leere Zeichenkette setzen.

Wir können den Wert dieses Schlüssels über das Stripe-Bedienfeld abrufen, aber dazu müssten wir den Zugang zur Anwendung für die Welt öffnen, was nicht immer bequem oder sicher ist.

Wie eingangs erwähnt, besteht die größte Herausforderung bei der Implementierung asynchroner Arbeitsabläufe im Testen in einer lokalen Umgebung. Stripe positioniert sich als entwicklerfreundliche Lösung mit einem hohen DX-Niveau.

Im Arsenal der von Stripe bereitgestellten Bibliotheken und Werkzeuge finden wir alles, was unser tägliches Leben viel einfacher und die Arbeit vor Ort effizienter und angenehmer macht. Ein solches Werkzeug ist Stripe CLI, das wir bereits installiert haben sollten.

Zunächst müssen wir uns mit der Stripe-CLI anmelden, indem wir den Befehl `stripe login` ausführen. Nach der Anmeldung führen wir den folgenden Befehl aus, der alle Hook-Aufrufe an unsere lokale Anwendung weiterleitet, ohne dass wir unsere Umgebung für die Welt öffnen müssen:

stripe listen --forward-to <HOOKS_URL>

Nach der Ausführung des Befehls wird in der Konsole der Schlüssel angezeigt, den wir in unsere Konfiguration als `STRIPE_HOOKS_SECRET` eingeben müssen.

Von nun an werden alle Stripe-Ereignisse direkt in unserer Ansicht angezeigt.

Es gibt viele ausgelöste Ereignisse, aber um das allgemeine Prinzip der Integration im Beispielcode zu zeigen, unterstützen wir nur zwei Arten von Ereignissen:

• `invoice.paid` — tritt zum Zeitpunkt der Abonnementverlängerung auf und enthält eine `customer ID`, damit wir die Gültigkeit des Benutzerkontos verlängern können.
• `customer.subscription.deleted` —  tritt ein, wenn ein Benutzer ein Abonnement kündigt; die Daten eines solchen Ereignisses enthalten auch die `customer ID`.

Das ist die Quintessenz des Ganzen. Mit den vorgestellten Lösungen können wir problemlos einen vollständigen Abonnementdienst mit praktisch beliebiger Logik aufbauen.