Retries und Timeouts für die Stabilität eines Skripts

1. Fehlerbehandlung in Skripten

Herausforderungen beim Web-Scraping

Stell dir vor: Dein Skript sitzt da, sieht schick aus, bereit für die Arbeit. Aber plötzlich rutscht es auf einer Bananenschale aus — Zack! Fehler und Abstürze. Wie können wir es widerstandsfähiger gegen die harten Bedingungen des Internets machen? Heute bringen wir ihm zwei wichtige Skills bei: Geduld und Wiederholungsversuche. Genau, wir konfigurieren Retries und Timeouts.

Web-Scraping kann Spaß machen, bis dein Skript plötzlich ausfällt aufgrund von:

• Verbindungsfehlern.
• Vorübergehender Unerreichbarkeit von Servern.
• Unvorhersehbaren Änderungen in der HTML-Struktur von Seiten.

Dein Skript sollte wie ein Jedi auf Unvorhergesehenes vorbereitet sein und damit umgehen können. Manchmal lassen sich Probleme lösen, indem man eine Minute wartet und es erneut versucht. Und hier kommen unsere Helden ins Spiel — Retries und Timeouts!

Einführung in die Mechanismen der Fehlerbehandlung

Lass uns zunächst die Grundlagen der Fehlerbehandlung in Python auffrischen. Wir verwenden try-except-Blöcke, um Fehler zu handhaben und sicherzustellen, dass sie die Arbeit unseres Skripts nicht ruinieren.

import requests

try:
    response = requests.get('https://example.com')
    response.raise_for_status()  # Überprüfung des Erfolgs der Anfrage
except requests.exceptions.RequestException as e:
    print(f'Ein Fehler ist aufgetreten: {e}')

2. Konfiguration von Retries

Warum Retries verwenden?

Ein Skript, das beim ersten Fehler aufgibt, ist wie eine Katze, die Angst vor einem Regenschauer hat. Du brauchst ein Skript, das ein paar Unannehmlichkeiten übersteht. Deshalb konfigurieren wir Retries — so wird dein Skript selbstbewusster.

Wie man Wiederholungsversuche einrichtet

Lass uns herausfinden, wie wir Wiederholungsversuche durchführen können. Eine der einfachsten Methoden ist die Verwendung der urllib3-Bibliothek, die eine Funktionalität für die automatische Wiederholung von Anfragen bei Fehlern bietet.

from urllib3.util.retry import Retry
from requests.adapters import HTTPAdapter
import requests

session = requests.Session()
retries = Retry(total=5, backoff_factor=1, status_forcelist=[500, 502, 503, 504])
session.mount('https://', HTTPAdapter(max_retries=retries))

try:
    response = session.get('https://example.com')
    response.raise_for_status()
    print(response.content)
except requests.exceptions.RequestException as e:
    print(f'Ein Fehler ist aufgetreten: {e}')

In diesem Beispiel haben wir eine session erstellt und darauf den Retry-Mechanismus (Retry) angewendet. Wir haben angegeben, dass bis zu 5 Versuche bei Fehlern mit den Codes 500, 502, 503 und 504 gemacht werden sollen. backoff_factor=1 bedeutet, dass das Zeitintervall zwischen den Versuchen exponentiell wächst (1, 2, 4, 8... Sekunden).

3. Timeouts: Hängenbleiben vermeiden

Schluss mit ungeduldigem Warten

Timeouts sind wie ein Wecker: Sie helfen deinem Skript, nicht in eine Endlosschleife des Wartens zu geraten. Mit einem Timeout sagst du deinem Skript: "Hör auf zu warten! Wenn der Server nicht innerhalb der angegebenen Zeit antwortet, mach weiter!"

try:
    response = requests.get('https://example.com', timeout=10)
    response.raise_for_status()
    print(response.content)
except requests.exceptions.Timeout:
    print('Die Anfrage hat das Zeitlimit überschritten')
except requests.exceptions.RequestException as e:
    print(f'Ein Fehler ist aufgetreten: {e}')

Warum ist das wichtig?

Hast du jemals darauf gewartet, dass dein Skript auf eine Antwort von einem Server wartet, der bereits "verbrannt" ist wie Toast? Timeouts verhindern unnötiges Warten und ermöglichen es deinem Code, sich schnell zu erholen und weiterzuarbeiten. Lasse dein Skript nicht "denken", dass es in dieser Zeit ein paar Mal eine Pause machen könnte!

4. Beispiele zur Konfiguration

Implementierung eines robusten Skripts mit Retries

Lass uns nun ein Skript erstellen, das so robust ist wie die Rüstung von Iron Man. Wir werden sowohl Timeouts als auch Wiederholungen verwenden.

from urllib3.util.retry import Retry
from requests.adapters import HTTPAdapter
import requests

def fetch_url(url):
    session = requests.Session()
    retries = Retry(total=5, backoff_factor=1, status_forcelist=[500, 502, 503, 504])
    session.mount('https://', HTTPAdapter(max_retries=retries))

    try:
        response = session.get(url, timeout=10)
        response.raise_for_status()
        return response.content
    except requests.exceptions.Timeout:
        print('Die Anfrage hat das Zeitlimit überschritten')
    except requests.exceptions.RequestException as e:
        print(f'Ein Fehler ist aufgetreten: {e}')
    return None

content = fetch_url('https://example.com')
if content:
    print('Daten erfolgreich heruntergeladen!')

Verwendung von Timeouts, um Skript-Hänger zu vermeiden

Wir haben bereits gezeigt, wie man Timeouts einrichtet. Lass uns nun sicherstellen, dass unser Skript nicht nur robust ist, sondern auch klug auf längeres Warten reagiert. Anstatt zu "hängen", erinnert es seinen Besitzer einfach daran: "Hey, der Server denkt zu lange nach, ich werde nicht warten!"

Ein solch einfacher und eleganter Ansatz macht deinen Code zuverlässig und bereit, sich mit allen unvorhersehbaren Situationen im Internet auseinanderzusetzen.

Praktische Anwendung

Wenn du reale Projekte zum Scraping entwickelst, musst du oft mit verschiedenen Einschränkungen seitens der Server umgehen. Retries und Timeouts sind deine besten Freunde, um das Risiko von Fehlern zu minimieren. Sie helfen dir, die nahtlose Funktionalität deines Codes sicherzustellen, insbesondere bei der automatisierten Datenverarbeitung und in Fällen, in denen es wichtig ist, rechtzeitig genaue Ergebnisse zu liefern. Diese Techniken können auch die Qualität deines Lebenslaufs und das Vertrauen von Kunden erhöhen, denen du Daten zur Verfügung stellst.