Für moderne Agenturen ist ein hochwertiges, konsistentes Berichtswesen unerlässlich, um das Vertrauen ihrer Kunden zu erhalten und eine langfristige Loyalität aufzubauen. Mit übersichtlichen, informativen Berichten kannst du Verkaufstrends überwachen, die Wirksamkeit von Kampagnen nachweisen, den Return on Investment (ROI) berechnen und vieles mehr.
Für eine Agentur, die Dutzende oder sogar Hunderte von Websites verwaltet, kann die Erstellung dieser regelmäßigen Berichte jedoch zu einem großen Engpass werden, der die Skalierbarkeit deines Betriebs beeinträchtigt.
Deshalb ist es wichtig, die Datenabfrage zu optimieren und zu automatisieren. Dadurch wird die Effizienz wiederhergestellt und dein Team kann sich auf wichtige Aufgaben konzentrieren – wie die Entwicklung neuer Projekte.
In diesem Artikel erfährst du, wie du die Kinsta-API nutzen kannst, um deine Hosting-Daten automatisch abzurufen und strategische Berichte mit der Kraft der KI zu erstellen.
Bist du bereit, dein Berichtssystem zu skalieren? Lies weiter.
Zugriff auf Kinsta Analytics über MyKinsta und Kinsta API
Kinsta-Kunden haben über das MyKinsta-Hosting-Dashboard Zugang zu einer Vielzahl von Daten. Du kannst auf die Daten deines Plans im Bereich Analytics in deinem Dashboard zugreifen.
Die Analytics-Seite ist in mehrere Registerkarten unterteilt, die sich jeweils auf einen bestimmten Aspekt der Aktivitäten auf deiner Website konzentrieren:
- Planauslastung: Zeigt den Ressourcenverbrauch deines Plans an, sowohl kumuliert als auch aufgeschlüsselt nach einzelnen Websites.
- Top-Anfragen: Ermöglicht es dir, die wichtigsten Anfragen an deine Website zu identifizieren, aufgeschlüsselt nach Bandbreite und Ansichten.
- Cache: Hier findest du eine Aufschlüsselung der Cache-Nutzung, einschließlich der Cache-Aufschlüsselung, der Server-Cache-Komponenten und der Server-Cache-Umgehungen.
- CDN & Edge: Bietet Daten zum CDN-Bandbreitenverbrauch, zur Edge-Cache-Bandbreite und Listen der wichtigsten Dateien, die aus dem CDN-Cache ausgeliefert werden.
- Streuung: Zeigt den prozentualen Anteil der Besuche von Desktop, Tablet und Handy.
- Leistung: Enthält verschiedene Leistungskennzahlen wie die durchschnittliche PHP-MySQL-Antwortzeit, den PHP-Durchsatz, das PHP-Thread-Limit und mehr.
- Antwort: Liefert Statistiken zu Antwortcodes, einschließlich einer detaillierten Aufschlüsselung der Fehlercodes.
- Geo & IP: Zeigt Listen der Top-Länder, Top-Städte und Top-Client-IPs an, von denen die Anfragen an deine Website stammen.
Du kannst dieselben Analysen auch auf Website-Ebene abrufen, indem du zu Websites > Websitename > Analytics navigierst.
Kinsta Analytics bietet einen beeindruckenden Datensatz. Wenn du durch dein MyKinsta-Dashboard navigierst, bekommst du ein klares Bild vom Ressourcenverbrauch, der Effizienz und der Leistung deiner Website. Du wirst genau wissen, woher die meisten Anfragen kommen und welche die meisten Ressourcen verbrauchen.
In Kombination mit unserem Kinsta APM-Tool kannst du mit Kinsta Analytics die Leistung deiner WordPress-Websites optimieren.
Was nicht jeder weiß, ist, dass die Daten von Kinsta Analytics auch über die Kinsta API zugänglich sind. Damit kannst du programmatisch Daten abrufen und Hosting-Metriken erstellen, die du dann zur Erstellung automatisierter Berichte für deine Kunden verwenden kannst.
Schauen wir uns die Kinsta-API-Endpunkte an.
Der Analytics-Endpunkt der Kinsta-API
Mit dem Analytics-Endpunkt der Kinsta-API kannst du Rohdaten über die Ressourcennutzung und den Zustand deiner Website abrufen.
- Besucherzahlen, Server-Bandbreitennutzung und CDN-Bandbreitennutzung: Diese Kennzahlen geben Aufschluss über die Ressourcennutzung im Verhältnis zu deinem Hosting-Plan während des aktuellen Abrechnungszeitraums.
- Besuche: Zeigt die Gesamtzahl der Besuche in einer bestimmten Umgebung innerhalb eines bestimmten Zeitraums an.
- Speicherplatz: Zeigt den gesamten Speicherplatz an, den eine bestimmte Umgebung in einem bestimmten Zeitraum verbraucht hat.
- Server-Bandbreite: Gibt die Bandbreite an, die von einer bestimmten Umgebung in einem bestimmten Zeitraum verbraucht wurde.
- CDN-Bandbreite: Zeigt die CDN-Bandbreite an, die eine bestimmte Umgebung in einem bestimmten Zeitraum verbraucht hat.
- Top-Länder: Gibt eine Liste der wichtigsten Länder an, aus denen die Anfragen an die Website innerhalb eines bestimmten Zeitraums stammen.
- Top-Städte: Gibt eine Liste der wichtigsten Städte an, aus denen in einem bestimmten Zeitraum Anfragen an die Website gestellt wurden.
- Top Client IPs: Enthält eine Liste der wichtigsten Client-IP-Adressen, von denen in einem bestimmten Zeitraum Zugriffe auf die Website ausgingen.
- Besuchsstreuung: Sie liefert Daten über die Verteilung der Besuche auf Desktop-, Tablet- und Mobilgeräte in einem bestimmten Zeitraum.
- Aufschlüsselung der Antwortcodes: Liefert eine Aufschlüsselung der HTTP-Statuscodes, die vom Server innerhalb eines bestimmten Zeitraums zurückgegeben wurden.
Im Folgenden findest du einige Beispiele für die Nutzung des Analyse-Endpunkts.
Besuche
Die folgende Anfrage liefert die Gesamtzahl der Besuche auf deiner Website und die Anzahl der eindeutigen IP-Adressen, die in den letzten 30 Tagen auf die Website zugegriffen haben:
https://api.kinsta.com/v2/sites/environments/{KINSTA_ENV_ID}/analytics/visits?time_span=30_days&company_id={KINSTA_COMPANY_ID}Die Antwort wird wie folgt aufgebaut sein:
{
"analytics": {
"analytics_response": {
"key": "uniqueip",
"data": [
{
"name": "uniqueip",
"total": 1000,
"dataset": [
{
"key": "2025-10-28T00:00:00.000Z",
"value": "1000"
},
{
"key": "2025-10-28T00:00:00.000Z",
"value": "900"
},
{
"key": "2025-10-28T00:00:00.000Z",
"value": "820"
},
...
]
}
]
}
}
}Bandbreite
Das folgende Beispiel zeigt, wie du die Kinsta-API abfragst, um die Bandbreitennutzung des Servers in den letzten 30 Tagen zu ermitteln:
https://api.kinsta.com/v2/sites/environments/{KINSTA_ENV_ID}/analytics/bandwidth?time_span=30_days&company_id={KINSTA_COMPANY_ID}Die Antwort des Kinsta-Servers liefert die tägliche Bandbreitennutzung für die letzten 30 Tage:
{
"analytics": {
"analytics_response": {
"key": "bandwidth",
"data": [
{
"name": "bandwidth",
"total": 1000,
"dataset": [
{
"key": "2026-03-11T00:00:00.000Z",
"value": "37347250"
},
{
"key": "2026-03-12T00:00:00.000Z",
"value": "9276458"
},
...
]
}
]
}
}
}CDN-Bandbreite
In diesem anderen Beispiel fragen wir die Kinsta-API ab, um die CDN-Bandbreitennutzung der letzten 7 Tage herauszufinden:
https://api.kinsta.com/v2/sites/environments/{KINSTA_ENV_ID}/analytics/cdn-bandwidth?time_span=7_days&company_id={KINSTA_COMPANY_ID}Der Server liefert die folgenden Daten:
{
"analytics": {
"analytics_response": {
"key": "cdn-bandwidth",
"data": [
{
"name": "cdn-bandwidth",
"total": 1000,
"dataset": [
{
"key": "2026-04-02T00:00:00.000Z",
"value": "753447"
},
{
"key": "2026-04-03T00:00:00.000Z",
"value": "16911"
},
...
]
}
]
}
}
}Du kannst es selbst ausprobieren, indem du deinen Kinsta-API-Schlüssel (Inhaber-Token), die Umgebungs-ID und die Unternehmens-ID in den API-Spielplatz eingibst.
Jetzt, wo du weißt, wie du auf die Analysedaten deiner Website auf Kinsta zugreifen kannst, kannst du sie nutzen, um deinen Betrieb zu automatisieren. Dazu gehört auch das Automatisieren des Berichtswesens.
In den folgenden Abschnitten zeigen wir dir, wie du das Berichtswesen deiner Agentur mithilfe der Kinsta-API automatisieren kannst. Wir werden ein Python-Skript erstellen und GitHub Actions nutzen, um die Erstellung und Ausführung zu automatisieren. Damit werden die von der API zurückgegebenen Rohdaten in Tabellen und Diagramme umgewandelt und Google AI abgefragt, um einen endgültigen Bericht zu erstellen.
Es ist Zeit anzupacken.
Baue ein automatisiertes Meldesystem mit der Kinsta API und Google AI
Unser Ziel ist es, einen automatisierten Bericht zu erstellen, der in bestimmten Abständen generiert wird. Das System wird die Kinsta-API abfragen, um Daten über Besuche, Server-Bandbreite und CDN-Bandbreite zu erhalten. Diese Daten werden dann verwendet, um Diagramme und Tabellen in einer PDF-Datei zu erstellen. Als Teil dieses Prozesses werden die Daten an die Gemini API gesendet, um eine Analyse der extrahierten Daten zu erstellen, die dann in den Bericht aufgenommen wird.
Einrichten des Projekts auf GitHub
Auf der GitHub-Startseite klickst du auf die grüne Schaltfläche Neu, um ein neues Projekt zu erstellen. Sobald du ein leeres Projekt hast, gehst du zu Einstellungen > Geheimnisse und Variablen > Aktionen und fügst die im folgenden Bild gezeigten Geheimnisse hinzu.
Wenn du deine API-Schlüssel und IDs in GitHub Secrets speicherst, sind sie für jeden unzugänglich und dein Code bleibt sicher.
GEMINI_API_KEY
Du kannst einen Google AI API-Schlüssel im Google AI Studio Dashboard erstellen. Weitere Informationen findest du in der Google AI-Dokumentation.
KINSTA_API-KEY
Befolge als Nächstes die Anweisungen in unserem Artikel, um einen Kinsta-API-Schlüssel zu generieren.
KINSTA_COMPANY_ID, KINSTA_ENV_ID, KINSTA_SITE_ID
Du findest die Site ID, Environment ID und Company ID unter Websites > Websitename > Info in deinem MyKinsta Dashboard.
Kommen wir nun zu den Projektdateien.
Erforderliche Bibliotheken und GitHub Actions Konfiguration
Erstelle im Stammverzeichnis deines GitHub-Projekts eine Datei namens requirements.txt und füge Folgendes hinzu:
google-genai
requests
matplotlib
fpdf2Diese Datei listet die Komponenten auf, die für dein Projekt benötigt werden.
google-genai: Dies ist die Bibliothek von Google für die Interaktion mit Gemini-Modellen.requests: Eine Bibliothek, um HTTP-Anfragen zu stellen. In diesem Projekt wird sie verwendet, um HTTP-Anfragen an die Kinsta-API zu senden.matplotlib: Eine Python-Bibliothek zur Erstellung von Diagrammen und zur Visualisierung von Daten.fpdf2: Eine Bibliothek, mit der du PDF-Dateien erstellen kannst.
Als Nächstes erstellst du eine Datei namens .github/workflows/generate_report.yml mit dem folgenden Code:
name: Generate Kinsta Analytics Report
on:
push:
branches: [main]
workflow_dispatch:
jobs:
build-and-run:
runs-on: ubuntu-latest
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.12'
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.txt
- name: Run Report Script
env:
KINSTA_API_KEY: ${{ secrets.KINSTA_API_KEY }}
KINSTA_ENV_ID: ${{ secrets.KINSTA_ENV_ID }}
KINSTA_SITE_ID: ${{ secrets.KINSTA_SITE_ID }}
KINSTA_COMPANY_ID: ${{ secrets.KINSTA_COMPANY_ID }}
GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
run: python main.py
- name: Upload Report
uses: actions/upload-artifact@v4
with:
name: Kinsta-Advanced-Report
path: "*.pdf"GitHub verwendet diese Datei, um deinen Code automatisch über GitHub Actions auszuführen. Schauen wir uns das mal genauer an:
name: Generate Kinsta Analytics Report
on:
push:
branches: [main]
workflow_dispatch:name: Der Name deines Projekts, wie er in der Registerkarte Aktionen auf GitHub erscheint.on: Legt fest, wann der Workflow ausgelöst werden soll.push: Der Workflow wird jedes Mal ausgeführt, wenn du eine Codeänderung in den Hauptzweig verschiebst.workflow_dispatch: Ermöglicht es dir, den Workflow manuell auszuführen.
jobs:
build-and-run:
runs-on: ubuntu-latestjobs: Der Start der auszuführenden Aufgaben.build-and-run: Ein beliebiger Name, der eine bestimmte Abfolge von Aktionen kennzeichnet.runs-on: Legt das System fest, auf dem der Arbeitsablauf ausgeführt werden soll.ubuntu-latest: Legt die neueste Version von Ubuntu Linux fest.
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.12'steps: Die Reihenfolge der auszuführenden Operationen.name: Der Name der Operation, die durchgeführt werden solluses: Das vorkonfigurierte GitHub-Modul (Action)
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.txtpython -m pip install --upgrade pip: Aktualisiert pip (den Python-Paketmanager) auf die neueste verfügbare Version.pip install -r requirements.txt: Liest die Dateirequirements.txtund installiert die darin aufgeführten Pakete.
- name: Run Report Script
env:
KINSTA_API_KEY: ${{ secrets.KINSTA_API_KEY }}
KINSTA_ENV_ID: ${{ secrets.KINSTA_ENV_ID }}
KINSTA_SITE_ID: ${{ secrets.KINSTA_SITE_ID }}
KINSTA_COMPANY_ID: ${{ secrets.KINSTA_COMPANY_ID }}
GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
run: python main.pyenv: Ruft die Werte der Umgebungsvariablen von GitHub Secrets ab.run: python main.py: Startet den Python-Interpreter und führt die Dateimain.pyaus.
- name: Upload Report
uses: actions/upload-artifact@v4
with:
name: Kinsta-Advanced-Report
path: "*.pdf"uses: actions/upload-artifact@v4: Verwendet die GitHub-Aktion zur Verwaltung von Artefakten, einer Datei oder einem Ordner, die während der Ausführung des Skripts erstellt werden.with: Legt die Konfigurationsparameter fest.
Die Konfiguration deines Automatisierungsprojekts ist damit abgeschlossen. Jetzt ist es an der Zeit, die Python-Skripte zu erstellen.
Programmatische Abfrage der Kinsta-API
Sobald du die Einrichtung abgeschlossen hast, navigierst du zum Stammverzeichnis deines GitHub-Projekts und erstellst eine neue Datei namens kinsta_utils.py mit dem folgenden Code:
import requests
import os
KINSTA_API_KEY = os.getenv("KINSTA_API_KEY")
KINSTA_SITE_ID = os.getenv("KINSTA_SITE_ID")
KINSTA_ENV_ID = os.getenv("KINSTA_ENV_ID")
KINSTA_COMPANY_ID = os.getenv("KINSTA_COMPANY_ID")
BASE_URL = f"https://api.kinsta.com/v2/sites/environments/{KINSTA_ENV_ID}/analytics"
def get_headers():
return {"Authorization": f"Bearer {KINSTA_API_KEY}"}- Die ersten beiden
Import-Anweisungen laden die Standardbibliothek für HTTP-Anfragen und das Modul für die Interaktion mit dem Betriebssystem (os). - Die nächsten vier Zeilen (
os.getenv) rufen deine Anmeldedaten von GitHub Secrets ab. BASE_URLdefiniert den Hauptendpunkt der Kinsta-API, den das Skript verwendet.- Die Funktion
get_headersgeneriert den Autorisierungs-Header, der den Kinsta-API-Schlüssel enthält.
Als Nächstes erstellst du eine Hilfsfunktion, die die von der API zurückgegebenen Rohdaten in Megabytes umwandelt.
def format_bytes_to_mb(bytes_value):
"""Converts raw bytes from API to human-readable Megabytes."""
try:
# Standard conversion to MB
# return round(int(bytes_value) / (1024 * 1024), 2)
# Decimal standard (used in MyKinsta dashboard)
return round(int(bytes_value) / 1_000_000, 2)
except (ValueError, TypeError):
return 0- Dieser Code bietet zwei Möglichkeiten. Die erste verwendet den binären Standard (
1024 x 1024), die zweite den dezimalen Standard. Die Division durch1_000_000stellt sicher, dass die Zahl in deinem PDF-Bericht der Zahl entspricht, die deine Kunden in MyKinsta Analytics sehen würden.
Die folgende Funktion fragt die Kinsta-API ab und gibt eine Reihe von Rohdaten zurück:
def fetch_kinsta_metric(endpoint, start_date, end_date):
url = f"{BASE_URL}/{endpoint}"
params = {
"company_id": KINSTA_COMPANY_ID,
"from": f"{start_date}T00:00:00.000Z",
"to": f"{end_date}T23:59:59.000Z"
}
try:
response = requests.get(url, headers=get_headers(), params=params)
if response.status_code == 200:
data_node = response.json()['analytics']['analytics_response']['data'][0]
total = data_node.get('total', 0)
dataset = data_node.get('dataset', [])[:7]
return total, dataset
except Exception as e:
print(f"Error fetching {endpoint}: {e}")
return 0, []- Die Funktion
fetch_kinsta_metricbenötigt drei Argumente:endpoint,start_dateundend_date. Diese werden verwendet, um die URL der Anfrage zu erstellen. Der Endpunkt kannvisits,bandwidthodercdn-bandwidthsein. - Im Array
paramswerden die Parameter der Anfrage gespeichert. - Die Antwort von Kinsta ist ein verschachteltes JSON-Objekt (
data_node), das die aggregierten Werte für den Zeitraum (total) und eine Liste der täglichen Werte (dataset) enthält.
Die letzte Funktion in der Datei kinsta_utils.py ruft den Websitenamen ab.
def fetch_site_name():
url = f"https://api.kinsta.com/v2/sites/{KINSTA_SITE_ID}"
try:
response = requests.get(url, headers=get_headers())
if response.status_code == 200:
data = response.json()
site_data = data.get('site', {})
site_label = site_data.get('display_name', 'Unknown Site')
env_label = "Unknown Env"
envs = site_data.get('environments', [])
for env in envs:
if env.get('id') == KINSTA_ENV_ID:
env_label = env.get('display_name')
break
return f"{site_label} ({env_label})"
else:
print(f"Kinsta API Error: {response.status_code} - {response.text}")
except Exception as e:
print(f"Error fetching site name: {e}")
return "Unknown Site"Dieser Code sollte selbsterklärend sein. In der API-Referenz findest du weitere Informationen über den Sites-Endpunkt.
Jetzt müssen wir nur noch den Workflow einrichten.
Automatisiere den Arbeitsablauf mit Python und Gemini
Die letzte Datei, die du erstellen musst, ist die Engine für deine Anwendung. Erstelle im Hauptverzeichnis deines GitHub-Projekts eine Datei main.py. Füge zu Beginn den folgenden Code ein:
import os
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from google.genai import Client
from fpdf import FPDF, XPos, YPos
from datetime import datetime, timedelta
from kinsta_utils import fetch_kinsta_metric, format_bytes_to_mb, fetch_site_name
REPORT_LANG = "en"
MODEL_ID = "gemini-2.5-flash"
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
client = Client(api_key=GEMINI_API_KEY)
today = datetime.now()
curr_end_dt = today - timedelta(days=1)
curr_start_dt = today - timedelta(days=7)
prev_end_dt = today - timedelta(days=8)
prev_start_dt = today - timedelta(days=14)
CURR_RANGE = f"{curr_start_dt.strftime('%b %d')} - {curr_end_dt.strftime('%b %d')}"
PREV_RANGE = f"{prev_start_dt.strftime('%b %d')} - {prev_end_dt.strftime('%b %d')}"
DATES = [
prev_start_dt.strftime("%Y-%m-%d"),
prev_end_dt.strftime("%Y-%m-%d"),
curr_start_dt.strftime("%Y-%m-%d"),
curr_end_dt.strftime("%Y-%m-%d")
]
CURR_DAYS_LABELS = [(curr_start_dt + timedelta(days=i)).strftime("%d %a") for i in range(7)]
PREV_DAYS_LABELS = [(prev_start_dt + timedelta(days=i)).strftime("%d %a") for i in range(7)]
X_AXIS_LABELS = [(curr_start_dt + timedelta(days=i)).strftime("%d") for i in range(7)]So ist das Skript aufgebaut:
- Die
Import-Anweisungen laden die notwendigen Bibliotheken, undmatplotlib.use('Agg')weist Python an, die Diagramme zu erstellen und im Speicher zu halten. - Der folgende Block legt die Sprache (
en) und das Modell (gemini-2.5-flash) fest und initialisiert dann den Google-Client. - Als Nächstes werden Zeitfenster definiert, um die Werte der letzten sieben Tage mit denen der vorherigen sieben Tage zu vergleichen.
- Schließlich werden die Beschriftungen für Tabellen und Diagramme festgelegt.
Im nächsten Schritt wird eine KinstaReport-Klasse definiert, die mit Hilfe der FPDF-Bibliothek Berichtsseiten erstellt:
class KinstaReport(FPDF):
def __init__(self, site_name="Unknown Site"):
super().__init__()
self.site_name = site_name
def header(self):
self.set_font("Helvetica", "B", 8)
self.set_text_color(150)
# Site name
self.cell(100, 10, f"Site: {self.site_name}", align="L")
# Date generated
self.cell(0, 10, f"Kinsta Analytics Report | Generated: {datetime.now().strftime('%Y-%m-%d')}",
align="R", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
def add_metric_page(self, title, chart_path, prev_vals, curr_vals, unit=""):
self.add_page()
# Page title
self.set_font("Helvetica", "B", 24)
self.set_text_color(83, 51, 237)
self.cell(0, 15, title, align="C", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
# Subtitle
self.set_font("Helvetica", "I", 10)
self.set_text_color(120)
self.cell(0, 5, f"Comparison: {CURR_RANGE} vs {PREV_RANGE}", align="C", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
self.image(chart_path, x=10, y=42, w=190)
# Data tables
self.set_y(150)
self.set_font("Helvetica", "B", 10)
self.set_fill_color(245, 245, 255)
self.set_text_color(83, 51, 237)
# Table header
col1, col2 = 35, 60
self.cell(col1, 10, " Day (Prev)", border=1, align='C', fill=True, new_x=XPos.RIGHT, new_y=YPos.TOP)
self.cell(col2, 10, f"Value {unit}", border=1, align='C', fill=True, new_x=XPos.RIGHT, new_y=YPos.TOP)
self.cell(col1, 10, " Day (Curr)", border=1, align='C', fill=True, new_x=XPos.RIGHT, new_y=YPos.TOP)
self.cell(col2, 10, f"Value {unit}", border=1, align='C', fill=True, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
self.set_font("Helvetica", "", 10)
self.set_text_color(50)
for i in range(7):
# Zebra striping
fill = (i % 2 == 0)
if fill: self.set_fill_color(250, 250, 250)
else: self.set_fill_color(255, 255, 255)
self.cell(col1, 9, f" {PREV_DAYS_LABELS[i]}", border=1, align='C', fill=fill, new_x=XPos.RIGHT, new_y=YPos.TOP)
self.cell(col2, 9, f" {prev_vals[i]}", border=1, align='C', fill=fill, new_x=XPos.RIGHT, new_y=YPos.TOP)
self.cell(col1, 9, f" {CURR_DAYS_LABELS[i]}", border=1, align='C', fill=fill, new_x=XPos.RIGHT, new_y=YPos.TOP)
self.cell(col2, 9, f" {curr_vals[i]}", border=1, align='C', fill=fill, new_x=XPos.LMARGIN, new_y=YPos.NEXT)Wir werden diesen Code nicht zu sehr ins Detail gehen. Weitere Informationen über die FPDF-Bibliothek findest du in den Online-Ressourcen:
Als nächstes definierst du eine Funktion generated_chart. Diese Funktion wandelt die von Kinsta erhaltenen Rohdaten in Diagramme um.
def generate_chart(labels, curr, prev, title, ylabel, filename, is_bar=False):
plt.figure(figsize=(10, 5), dpi=100)
ax = plt.gca()
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['left'].set_color('#dddddd')
ax.spines['bottom'].set_color('#dddddd')
if is_bar:
# Bar Chart for bandwidth
bars = plt.bar(labels, curr, color='#00c4b4', alpha=0.6, label='Current Period', width=0.6)
# Add labels above the bars
for bar in bars:
height = bar.get_height()
plt.text(bar.get_x() + bar.get_width()/2., height + 0.02, f'{height}', ha='center', va='bottom', fontsize=8, color='#00a194')
else:
# Line chart for visits
plt.plot(labels, curr, color='#5333ed', marker='o', markersize=6, linewidth=3, label='Current', zorder=3)
plt.plot(labels, prev, color='#a1a1a1', linestyle='--', marker='x', markersize=5, linewidth=1.5, label='Previous', alpha=0.6)
plt.fill_between(labels, curr, color='#5333ed', alpha=0.1)
plt.title(title, fontsize=14, pad=20, color='#333333', fontweight='bold')
plt.ylabel(ylabel, color='#666666')
plt.xlabel("Day of Month", color='#666666')
plt.legend(frameon=False, loc='upper right')
plt.grid(axis='y', linestyle='--', alpha=0.3)
plt.tight_layout()
plt.savefig(filename)
plt.close()Diese Funktion verwendet die Matplotlib-Bibliothek, um die aus Kinsta extrahierten Daten in Diagramme umzuwandeln, die in den PDF-Bericht eingefügt werden können. Weitere Informationen zur Verwendung der Matplotlib-Bibliothek findest du in der Online-Dokumentation:
Zum Schluss fügst du die Funktion hinzu, die alle Teile, die wir bisher beschrieben haben, kombiniert.
def main():
site_display_name = fetch_site_name()
metrics = {
"visits": {"title": "Site Visits", "unit": ""},
"bandwidth": {"title": "Server Bandwidth", "unit": "(MB)"},
"cdn-bandwidth": {"title": "CDN Bandwidth", "unit": "(MB)"}
}
report_data = {}
for key in metrics:
_, data_curr = fetch_kinsta_metric(key, DATES[2], DATES[3])
_, data_prev = fetch_kinsta_metric(key, DATES[0], DATES[1])
curr_vals = []
prev_vals = []
for i in range(7):
c = float(data_curr[i]['value']) if i < len(data_curr) else 0
p = float(data_prev[i]['value']) if i < len(data_prev) else 0
if "bandwidth" in key:
curr_vals.append(format_bytes_to_mb(c))
prev_vals.append(format_bytes_to_mb(p))
else:
curr_vals.append(int(c))
prev_vals.append(int(p))
report_data[key] = {"curr": curr_vals, "prev": prev_vals}
pdf = KinstaReport(site_name=site_display_name)
for key, info in metrics.items():
chart_file = f"{key}_chart.png"
generate_chart(X_AXIS_LABELS, report_data[key]["curr"], report_data[key]["prev"],
f"{info['title']} Trends", "Units", chart_file, is_bar=("bandwidth" in key))
pdf.add_metric_page(info["title"], chart_file, report_data[key]["prev"], report_data[key]["curr"], info["unit"])
# Executive Summary
pdf.add_page()
pdf.set_font("Helvetica", "B", 20)
pdf.set_text_color(83, 51, 237)
pdf.cell(0, 15, "Executive Summary", align="C", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
curr_visits = sum(report_data['visits']['curr'])
prev_visits = sum(report_data['visits']['prev'])
curr_bw = sum(report_data['bandwidth']['curr'])
prev_bw = sum(report_data['bandwidth']['prev'])
try:
summary_prompt = (
f"Analyze Kinsta performance for site {site_display_name}. "
f"Current Period ({CURR_RANGE}): {curr_visits} visits, {curr_bw:.2f}MB server bandwidth. "
f"Previous Period ({PREV_RANGE}): {prev_visits} visits, {prev_bw:.2f}MB server bandwidth. "
f"Compare these periods and identify trends. Language: {REPORT_LANG}. Max 4 sentences."
)
response = client.models.generate_content(model=MODEL_ID, contents=summary_prompt)
summary = response.text
except Exception as e:
summary = f"Analytical insights unavailable. Error: {str(e)}"
pdf.set_y(40)
pdf.set_font("Helvetica", "", 12)
pdf.set_text_color(0)
pdf.multi_cell(0, 8, summary)
report_filename = f"Kinsta_Report_{datetime.now().strftime('%Y-%m-%d')}.pdf"
pdf.output(report_filename)
print(f"Report generated: {report_filename}")
if __name__ == "__main__":
main()Das macht dieser Code:
- Die
for-Schleife iteriert durch dasmetrics-Array und fragt die Kinsta-API zweimal ab: einmal für die aktuelle Woche und einmal für die vorherige Woche. - Wenn sich die Daten auf die Bandbreite beziehen, wandelt die Funktion
format_bytes_to_mb()die Rohdaten in MB um. - Die Funktion
report_data()speichert die abgerufenen Daten. KinstaReporterstellt dann für jede Website eine PDF-Datei.- Die nächste
for-Schleife erzeugt PNG-Bilder für die Diagramme und erstellt für jede Kennzahl eine neue Seite. - Der nächste Abschnitt erstellt die Zusammenfassung, berechnet die Gesamtzahl der Besuche und die Gesamt-Megabytes für den Zeitraum und sendet eine dynamische Eingabeaufforderung an Gemini 2.5 Flash. Schließlich wird die Antwort verwendet, um die letzte Seite des PDF-Dokuments zu vervollständigen.
- Das Skript speichert das Dokument unter einem Dateinamen, der das aktuelle Datum enthält.
- * Die letzte Bedingung stellt sicher, dass der Prozess nur läuft, wenn das Skript als Hauptprogramm ausgeführt wird.
Jetzt ist es an der Zeit, deine Anwendung zu erstellen und auszuführen.
Abrufen des Artefakts
Du kannst deine Anwendung jetzt ausführen. Klicke auf deiner GitHub-Projektseite auf die Registerkarte Aktionen. Suche im Menü auf der linken Seite nach dem Namen deiner Aktion (in unserem Beispiel ist das der Name Generate Kinsta Analytics Report, wie in deiner Datei generate_report.yml angegeben).
Als Nächstes klickst du auf das Menü Workflow ausführen auf der rechten Seite und dann auf die grüne Schaltfläche Workflow ausführen (derzeit ist nur der Hauptzweig verfügbar).
Auf der nächsten Seite wird der aktuelle Workflow angezeigt. Klicke darauf, um die Liste der laufenden Vorgänge zu sehen.
Der Abschnitt Berichtsskript ausführen enthält eine Liste der durchgeführten Vorgänge, während der Abschnitt Bericht hochladen die URL für den Download des Artefakts enthält. Klicke auf diesen Link, um deinen Bericht im PDF-Format herunterzuladen.
Denselben Link findest du auch im Abschnitt Artefakte, unten auf der Seite Zusammenfassung des Workflows.
Die Bilder unten zeigen den vollständigen Bericht, einschließlich der von Google AI erstellten Zusammenfassung.
Die nächsten Schritte: Wie man die Skalierbarkeit verbessert und die Auslieferung automatisiert
Dies ist nur ein Vorgeschmack darauf, was die Kinsta-API in Kombination mit fortschrittlichen Automatisierungstools wie GitHub Actions leisten kann. Die KI-Integration geht noch einen Schritt weiter und verwandelt rohe Zahlen in tiefgehende Berichte, die du mit deinen Kunden teilen kannst.
Du kannst deine Berichte auf verschiedene Arten weiter verbessern:
- Du kannst deine Anwendung konfigurieren, indem du eine Zeile in die YAML-Datei einfügst (
schedule: '0 9 * * 1'), um den Bericht jeden Montagmorgen um 9:00 Uhr zu erstellen. - Du könntest eine Bibliothek wie
smtpliboder einen Dienst wie SendGrid integrieren, um den Bericht direkt an deinen Kunden zu senden. - Wenn du eine Agentur mit Dutzenden oder sogar Hunderten von Websites bist, könntest du eine Schleife implementieren, die über eine Liste von Website-IDs iteriert, um alle Berichte in einem einzigen Durchlauf zu erstellen.
- Du kannst den Inhalt deines Berichts noch weiter anreichern, indem du die Kinsta-API nutzt, um geografische Daten, HTTP-Code-Aufschlüsselungen, Server-Logs und andere Daten, die du einbeziehen möchtest, abzurufen. Durch die Analyse dieser Daten kann die KI Angriffsversuche (4xx-Codes) oder Verkehrsspitzen aus unerwarteten Regionen erkennen.
- Du kannst deine Eingabeaufforderung feinabstimmen, um detailliertere und umfassendere KI-Antworten zu erhalten.
- Du kannst die PDF-Vorlage mit den Logos deiner Agentur und deines Kunden anpassen.
Die automatisierte Berichterstattung entlastet dein Team, und die Konsistenz und Präzision, die sie bietet, stärkt das Vertrauen und die Loyalität deiner Kunden.
Du möchtest sofort mit der Automatisierung deiner Kundenberichte beginnen? Melde dich für den Plan an, der am besten zu deinen Bedürfnissen passt, und beginne noch heute mit der Kinsta-API zu arbeiten.
Carlo ist ein leidenschaftlicher Liebhaber von Webdesign und Frontend-Entwicklung. Er beschäftigt sich seit über 10 Jahren mit WordPress, auch in Zusammenarbeit mit italienischen und europäischen Universitäten und Bildungseinrichtungen. Er hat Dutzende von Artikeln und Leitfäden über WordPress geschrieben, die sowohl auf italienischen und internationalen Websites als auch in gedruckten Magazinen veröffentlicht wurden. Du kannst Carlo auf X und LinkedIn finden.
