Für eine Webagentur wird eine zu schnelle Skalierung oft zu einem Albtraum. Wenn sie zu einer Zunahme von sich wiederholenden Aufgaben führt, sind die verfügbaren Ressourcen erschöpft, lange bevor die Arbeit abgeschlossen ist: Deine Arbeitsabläufe sind fragmentiert, deine Prozesse sind ineffizient und dein Team ist demotiviert.

Gesundes und nachhaltiges Wachstum erfordert einen grundlegenden Mentalitätswandel: intelligenter arbeiten, nicht härter. In diesem Szenario ist Automatisierung kein Luxus, sondern eine strategische Voraussetzung für Überleben und Erfolg.

Aber wie setzt du die Idee, intelligenter zu arbeiten, in einen funktionierenden Arbeitsablauf um? Die schnelle Antwort ist: Verbinde deine Infrastruktur mit deinen Verwaltungstools.

In diesem Leitfaden zeigen wir dir, wie du deine Kinsta-Hosting-Infrastruktur und dein Trello-Projektmanagementsystem miteinander verbinden kannst, indem du eine benutzerdefinierte, automatisierte Synchronisierungsebene erstellst.

Lass uns eintauchen.

Die Lücke zwischen Infrastruktur und Management

Wenn du Trello benutzt, um die Projekte deiner Agentur zu verwalten, kennst du das Onboarding-Ritual: Für jede Website, die du startest, musst du manuell ein Trello-Board erstellen und konfigurieren und Checklisten für alle anfallenden Aufgaben ausfüllen, von der DNS-Einrichtung bis zur SEO-Optimierung.

Dann kommt die tägliche Wartung – wiederkehrende Aufgaben und Überprüfungen, die regelmäßig durchgeführt werden, um sicherzustellen, dass die Kunden-Websites reibungslos laufen, die Ressourcennutzung im Rahmen des Plans bleibt und Aktualisierungen fehlerfrei durchgeführt werden. Bei einem manuellen Arbeitsablauf bedeutet dies, dass du dich in mehrere Dashboards einloggen musst, nur um zu überprüfen, ob die Bandbreite einer Website nicht ausgereizt ist oder der Speicherplatz nicht knapp wird.

Je mehr Kundenprojekte du übernimmst, desto größer ist die Gefahr menschlicher Fehler und desto wahrscheinlicher wird eine „Überwachungsmüdigkeit“. Betrachte den normalen Lebenszyklus einer Kunden-Website:

  • Der Onboarding-Prozess: Bereitstellung von Umgebungen, DNS-Konfiguration, SSL-Bereitstellung und CI/CD-Einrichtung.
  • Die Betriebsphase: Die Überwachung des Serverzustands und des Ressourcenverbrauchs, um Ausfallzeiten oder unerwartete Mehrkosten zu vermeiden.

In der Realität erfordern beide Phasen eine ständige organisatorische Abstimmung. Das Hauptproblem ist der Silo-Effekt: Hosting und Management sind zwei isolierte Ökosysteme. Informationen fließen nur, wenn jemand daran denkt, eine Kennzahl zu überprüfen und eine Slack-Nachricht zu senden.

Wenn eine Website ihr Ressourcenlimit erreicht, der Entwickler es aber versäumt, den Projektmanager zu informieren, sind Ineffizienzen und Verzögerungen vorprogrammiert.

Moderne, wachstumsorientierte Agenturen können sich nicht auf manuelle Koordination verlassen. Die Kommunikation muss nahtlos und automatisch von der Infrastruktur (Kinsta-Hosting) direkt zum Management-Tool (Trello) fließen.

An dieser Stelle wird die Kinsta-API zu deinem wertvollsten Teammitglied, denn sie hilft dir dabei, Hosting-Rohdaten in verwertbare Informationen für deine Projektmanager umzuwandeln.

Der technische Stack: Warum Kinsta und Trello

Die Wahl der richtigen Tools ist der erste Schritt zu einer effektiven Automatisierung. Kinsta und Trello passen perfekt zusammen, denn beide Plattformen bieten robuste APIs, mit denen du eine automatisierte Brücke zwischen den technischen und verwaltungstechnischen Aspekten deiner Arbeitsabläufe bauen kannst.

  • Die Kinsta-API: Kinsta bietet eine RESTful-API, mit der die Entwickler deines Teams technische und betriebliche Aktionen programmatisch durchführen können – von der Bereitstellung von Umgebungen bis hin zur Extraktion von Echtzeit-Analysen und Serverprotokollen. Kinsta ist eine programmierbare Infrastruktur.
  • Das Projektmanagementsystem von Trello: Trello ist viel mehr als eine Sammlung von Notizen und Listen; es ist eine visuelle Darstellung der Prozesse deiner Agentur, die auf der Kanban-Board-Logik basiert. Mit der Trello-API kannst du ein statisches Dashboard in eine dynamische Umgebung verwandeln, die auf Ereignisse auf deinem Server reagiert.

Durch die Integration von Kinsta und Trello verwandelst du die Rohdaten von MyKinsta in umsetzbare Erkenntnisse für deine Teams. Keine manuelle Arbeit mehr, keine verpassten Schritte, kein Overhead und kein verlorener Wert für deine Entwickler.

Jetzt ist es an der Zeit, die Ärmel hochzukrempeln und deine Werkzeuge zusammenzustellen.

Sammle deine Tools

Bevor du mit der Codierung beginnst, musst du die nötigen Werkzeuge zusammensuchen:

  • Kinsta-API-Schlüssel
  • Trello-API-Schlüssel
  • Trello-Token
  • Ein GitHub-Code-Repository

Beginnen wir mit dem Kinsta-API-Schlüssel.

Schritt 1: Erstelle einen Kinsta-API-Schlüssel

Mit dem Kinsta-API-Schlüssel kannst du über die API auf deinen Hosting-Dienst zugreifen. Befolge diese Schritte, um einen neuen Kinsta-API-Schlüssel zu erstellen:

  1. Gehe zu deinem MyKinsta-Dashboard.
  2. Navigiere zur Seite mit den API-Schlüsseln (Dein Name > Unternehmenseinstellungen > API-Schlüssel).
  3. Klicke auf API-Schlüssel generieren.
  4. Wähle ein Ablaufdatum oder lege ein benutzerdefiniertes Startdatum und die Anzahl der Stunden fest, nach denen der Schlüssel abläuft.
  5. Gib dem Schlüssel einen eindeutigen Namen.
  6. Klicke auf Generieren.
API-Schlüssel auf MyKinsta erstellen
API-Schlüssel auf MyKinsta generieren

Stelle sicher, dass du deinen API-Schlüssel kopierst und an einem sicheren Ort aufbewahrst. Du wirst ihn nicht mehr sehen können. Wenn du ihn verlierst, musst du ihn widerrufen und einen neuen Schlüssel generieren.

Schritt 2: Erstelle den Trello API-Schlüssel und das Token

Um einen API-Schlüssel zu generieren, musst du bei Trello ein Trello Power-Up erstellen, das im Grunde eine Trello-Anwendung ist. Gehe dazu in das Power-Up Verwaltungsportal.

Trello Power-Up Verwaltungsportal
Trello Power-Up Verwaltungsportal

Klicke auf Neu und fülle das Formular aus, das sich öffnet.

Formular für neue Trello-App
Formular für neue Trello-App

Sobald du deine Informationen gespeichert hast, wirst du zu deinem Power-Up Dashboard weitergeleitet. Gib die erforderlichen Daten ein und speichere deine Einstellungen. Klicke dann im linken Menü auf API-Schlüssel und dann in der Mitte der Seite auf Neuen API-Schlüssel generieren.

Neuen Trello API-Schlüssel generieren
Neuen Trello API-Schlüssel generieren

Das ist alles! Du hast jetzt deinen Trello-API-Schlüssel. Achte darauf, dass du ihn an einem sicheren Ort aufbewahrst.

Trello-API-Schlüssel und -Geheimnis
Kopiere deinen Trello-API-Schlüssel und lege ihn an einem sicheren Ort ab

Ein API-Schlüssel allein reicht jedoch nicht aus, um Trello in deine Apps zu integrieren. Du musst auch ein Token generieren. Klicke auf den Link Token auf der rechten Seite, um eine Seite mit den Berechtigungen anzuzeigen, die du deinem Power-Up erteilst. Überprüfe diese Berechtigungen und autorisiere Trello dann, Daten zu teilen.

Trello-Token
Kopiere das Trello-Token und füge es ein

Kopiere das Trello-Token und füge es an einem sicheren Ort ein.

Schritt 3: Erstelle ein Code-Repository auf GitHub

GitHub ist nicht nur ein Code-Repository. Es ist auch ein Ort, an dem du sich wiederholende Aufgaben und Automatisierungen einrichten kannst.

Auf GitHub musst du die folgenden drei Dinge einrichten:

  • Das Repository, in dem sich dein Code befindet;
  • Die Secrets, in denen du deine API-Schlüssel und Token speicherst, und
  • Den Workflow, der die Anweisungen für die Automatisierung enthält.

1. Erstelle das GitHub-Repository

Klicke auf GitHub auf die grüne Schaltfläche Neu.

  1. Gib deinem Repository einen Namen.
  2. Füge eine Beschreibung hinzu.
  3. Setze die Sichtbarkeit auf Privat.
  4. Aktiviere die Option README hinzufügen.
  5. Klicke auf Repository erstellen.
Ein neues GitHub-Repository erstellen
Ein neues GitHub-Repository erstellen

2. Konfiguriere deine Aktionsgeheimnisse

Als Nächstes musst du deine Geheimnisse konfigurieren. Das ist ein wichtiger Schritt, denn so musst du deine API-Schlüssel nicht direkt in deinen Code einbauen.

In deinem neuen Projektarchiv klickst du oben auf der Seite auf die Registerkarte Einstellungen. Im linken Menü klickst du auf Geheimnisse und Variablen, gefolgt von Aktionen.

Seite zur Konfiguration von Aktionsgeheimnissen und Variablen
Seite zur Konfiguration von Aktionsgeheimnissen und Variablen

Klicke auf Neues Repository-Geheimnis und füge deine API-Schlüssel und dein Token hinzu.

Geheimnisse des GitHub-Repositorys
Geheimnisse des GitHub-Repositorys

3. Den Workflow konfigurieren

Jetzt musst du GitHub Schreibrechte erteilen. Gehe dazu in den Einstellungen zu Aktionen > Allgemein.

Scrolle nach unten zum Abschnitt Workflow-Berechtigungen und aktiviere das Kästchen Lese- und Schreibberechtigungen. Klicke dann auf Speichern.

GitHub Workflow-Berechtigungen
GitHub Workflow-Berechtigungen

Onboarding mit der Kinsta API und Trello automatisieren

Jetzt hast du deine API-Schlüssel und dein Trello-Token. Der nächste Schritt ist die Integration deines Kinsta-Hostings mit deinem Trello-Projektmanagementsystem.

Wir verwenden GitHub Actions, um regelmäßig ein Synchronisationsskript zwischen Kinsta und Trello auszuführen. Dieser automatisierte Prozess fragt die Kinsta-API in bestimmten Abständen nach neuen Websites ab und nutzt dann die Trello-API, um sicherzustellen, dass dein Trello-Board dein Kinsta-Site-Portfolio perfekt widerspiegelt.

In GitHub musst du eine YAML-Konfigurationsdatei erstellen, um festzulegen, wann das Skript ausgeführt werden soll. In unserem Beispiel wird das Skript alle 30 Minuten ausgeführt.

Gehe zurück in den Code-Bereich deines Repositorys und klicke auf Datei hinzufügen > Neue Datei erstellen.

Gib als Dateinamen .github/workflows/main.yml ein. GitHub wird automatisch die Ordner .github und workflows erstellen. Füge dann den folgenden Code ein:

name: Kinsta-Trello Integration
on:
  schedule:
    - cron: '*/30 * * * *' # Run every 30 minutes
  workflow_dispatch:       # Allows to start it manually for testing

jobs:
  run-sync:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Run automation script
        env:
          KINSTA_API_KEY: ${{ secrets.KINSTA_API_KEY }}
          KINSTA_COMPANY_ID: ${{ secrets.KINSTA_COMPANY_ID }}
          TRELLO_API_KEY: ${{ secrets.TRELLO_API_KEY }}
          TRELLO_TOKEN: ${{ secrets.TRELLO_TOKEN }}
        run: node index.js

Wenn du fertig bist, klicke auf die grüne Schaltfläche Änderungen speichern….

Die Ersteinrichtung ist abgeschlossen. Jetzt kannst du mit der Erstellung des Skripts fortfahren.

Schritt 2. Das Skript erstellen

Du musst eine neue index.js-Datei im Hauptverzeichnis deines GitHub-Projekts erstellen und den in den folgenden Abschnitten gezeigten Code hinzufügen.

1. Variablen deklarieren

Der erste Schritt besteht darin, die Variablen zu deklarieren, die das Skript benötigt, um seine Aufgaben zu erfüllen.

const KINSTA_API_URL = 'https://api.kinsta.com/v2';
const TRELLO_API_URL = 'https://api.trello.com/1';

const secrets = {
	kinsta: process.env.KINSTA_API_KEY,
	company: process.env.KINSTA_COMPANY_ID,
	trelloKey: process.env.TRELLO_API_KEY,
	trelloToken: process.env.TRELLO_TOKEN
};

2. Definiere die Automatisierungsfunktion

Der nächste Schritt ist die Definition der Automatisierungsfunktion.

async function startAutomation() {
	try {
		console.log("🚀 Starting Kinsta-Trello automation...");

		const kinstaUrl = `${KINSTA_API_URL}/sites?company=${secrets.company}`;

		const kinstaResponse = await fetch(kinstaUrl, {
			method: 'GET',
			headers: { 
				'Authorization': `Bearer ${secrets.kinsta}` 
			}
		});

		if (!kinstaResponse.ok) throw new Error(`Kinsta API error: ${kinstaResponse.status}`);

		const kinstaData = await kinstaResponse.json();

		const sites = kinstaData.company?.sites || [];

		console.log(`✅ Successfully fetched ${sites.length} sites from Kinsta.`);

		const trelloResponse = await fetch(`${TRELLO_API_URL}/members/me/boards?key=${secrets.trelloKey}&token=${secrets.trelloToken}`);
		
		if (!trelloResponse.ok) throw new Error(`Trello API error: ${trelloResponse.statusText}`);
		
		const trelloBoards = await trelloResponse.json();

		for (const site of sites) {
			const boardExists = trelloBoards.find(board => board.name === site.name);

			if (!boardExists) {
				console.log(`✨ New site found: ${site.name}. Provisioning workflow...`);

				const createBoardUrl = `${TRELLO_API_URL}/boards/?name=${encodeURIComponent(site.name)}&defaultLists=false&key=${secrets.trelloKey}&token=${secrets.trelloToken}`;
				const newBoardResponse = await fetch(createBoardUrl, { method: 'POST' });
				const newBoard = await newBoardResponse.json();

				if (newBoardResponse.ok) {
					console.log(`✅ Board created for ${site.name}. Setting up workflow...`);

					const toDoListId = await createWorkflow(newBoard.id);

					if (toDoListId) {
						await createGoLiveCard(toDoListId);
					}
				} else {
					console.log(`❌ Failed to create board for ${site.name}.`);
				}
			} else {
				console.log(`ℹ️ Site "${site.name}" already has a board. Skipping.`);
			}
		}

		console.log("🏁 Automation workflow finished!");
	
	} catch (error) {
		console.error("❌ Critical error during automation:", error.message);
	}
}

startAutomation();

Lasst uns diese Funktion Block für Block analysieren.

Das erste console.log zeigt an, dass der Prozess gestartet wurde:

console.log("🚀 Starting Kinsta-Trello automation...");

Der folgende Code ruft die Websites deines MyKinsta-Unternehmens ab:

const kinstaUrl = `${KINSTA_API_URL}/sites?company=${secrets.company}`;

const kinstaResponse = await fetch(kinstaUrl, {
	method: 'GET',
	headers: { 
		'Authorization': `Bearer ${secrets.kinsta}` 
	}
});

if (!kinstaResponse.ok) throw new Error(`Kinsta API error: ${kinstaResponse.status}`);

const kinstaData = await kinstaResponse.json();

const sites = kinstaData.company?.sites || [];

console.log(`✅ Successfully fetched ${sites.length} sites from Kinsta.`);
  • Wenn die Antwort nicht kinstaResponse.ok lautet, wird eine Fehlermeldung ausgegeben. Wenn die API ein gültiges Ergebnis liefert, speichert die Funktion die Liste der Websites im Array sites und zeigt eine Erfolgsmeldung an.

Der nächste Schritt besteht darin, deine bestehenden Trello-Boards abzurufen:

const trelloResponse = await fetch(`${TRELLO_API_URL}/members/me/boards?key=${secrets.trelloKey}&token=${secrets.trelloToken}`);

if (!trelloResponse.ok) throw new Error(`Trello API error: ${trelloResponse.statusText}`);

const trelloBoards = await trelloResponse.json();

Als Nächstes machen wir mit der Synchronisierungslogik weiter.

for (const site of sites) {
	const boardExists = trelloBoards.find(board => board.name === site.name);

	if (!boardExists) {
		console.log(`✨ New site found: ${site.name}. Provisioning workflow...`);

		const createBoardUrl = `${TRELLO_API_URL}/boards/?name=${encodeURIComponent(site.name)}&defaultLists=false&key=${secrets.trelloKey}&token=${secrets.trelloToken}`;
		const newBoardResponse = await fetch(createBoardUrl, { method: 'POST' });
		const newBoard = await newBoardResponse.json();

		if (newBoardResponse.ok) {
			console.log(`✅ Board created for ${site.name}. Setting up workflow...`);

			const toDoListId = await createWorkflow(newBoard.id);

			if (toDoListId) {
				await createGoLiveCard(toDoListId);
			}
		} else {
			console.log(`❌ Failed to create board for ${site.name}.`);
		}
	} else {
		console.log(`ℹ️ Site "${site.name}" already has a board. Skipping.`);
	}
}
  • Die for-Schleife durchläuft die Elemente des Sites-Arrays (d.h. die Liste der MyKinsta-Unternehmensseiten) und überprüft, ob für jede Website ein Board existiert. Wenn es kein Board mit dem Namen der Website gibt, wird eines erstellt.
  • Wenn das neue Board erfolgreich erstellt wurde (if (newBoardResponse.ok) {...}), rufst du die unten beschriebenen Funktionen createWorkflow() und createGoLiveCard() auf. Beachte, dass createGoLiveCard() nur für deine ToDo-Liste aufgerufen wird.

3. Definiere die Funktion createWorkflow()

Die Funktion createWorkflow() erstellt drei Standardlisten in deinem Trello-Bereich und gibt die ID der To Do-Liste zurück.

async function createWorkflow(boardId) {
	const lists = ['To Do', 'Doing', 'Done'];
	let toDoListId = null;

	for (const listName of lists) {
		const url = `${TRELLO_API_URL}/boards/${boardId}/lists?name=${encodeURIComponent(listName)}&key=${secrets.trelloKey}&token=${secrets.trelloToken}`;
		const response = await fetch(url, { method: 'POST' });
		const newList = await response.json();

		console.log(`   - List "${listName}" created.`);

		if (listName === 'To Do') toDoListId = newList.id;
	}
	return toDoListId;
}

4. Definiere die Hilfsfunktion createGoLiveCard()

Jetzt musst du die Funktion definieren, die die Checkliste der Go-Live-Pipeline erstellt.

async function createGoLiveCard(listId) {
	const cardUrl = `${TRELLO_API_URL}/cards?idList=${listId}&name=${encodeURIComponent('🚀 Go-Live Pipeline')}&desc=${encodeURIComponent('Standard agency tasks for site launch.')}&key=${secrets.trelloKey}&token=${secrets.trelloToken}`;
	const cardResponse = await fetch(cardUrl, { method: 'POST' });
	const card = await cardResponse.json();

	if (cardResponse.ok) {
		const checklistUrl = `${TRELLO_API_URL}/checklists?idCard=${card.id}&name=Launch%20Tasks&key=${secrets.trelloKey}&token=${secrets.trelloToken}`;
		const checklistResponse = await fetch(checklistUrl, { method: 'POST' });
		const checklist = await checklistResponse.json();

		const tasks = [
			'Point DNS to Kinsta',
			'Install & Force SSL (Let\'s Encrypt)',
			'Set up Search Console & Analytics',
			'Performance Test (Kinsta APM)',
			'Final Backup before Launch'
		];

		for (const task of tasks) {
			await fetch(`${TRELLO_API_URL}/checklists/${checklist.id}/checkItems?name=${encodeURIComponent(task)}&key=${secrets.trelloKey}&token=${secrets.trelloToken}`, {
				method: 'POST'
			});
		}
		console.log(`   - Go-Live Pipeline card with checklist created.`);
	}
}

Diese Funktion macht Folgendes:

  • Zuerst verwendet sie die Trello-API, um die Go-Live-Pipeline-Liste zu erstellen.
  • Wenn die Antwort cardResponse.ok lautet, fügt sie der To Do-Karte eine Liste mit 5 Elementen hinzu.

5. Ausführen des Workflows

Es ist an der Zeit, deinen Code zu testen. Bestätige zuerst deine Änderungen und gehe dann in den Bereich Actions (Link im oberen Menü).

Änderungen in GitHub speichern
Änderungen in GitHub speichern

Wenn du fertig bist, klicke auf deine App im Menü links. In unserem Beispiel ist das die Kinsta-Trello-Integration.

GitHub-Aktionsseite
GitHub-Aktionsseite

Klicke auf die Schaltfläche Workflow ausführen auf der rechten Seite. Dadurch wird dein Workflow gestartet. Klicke auf den laufenden Workflow und dann auf Automatisierungsskript ausführen. Du siehst dann die Schritte des laufenden Prozesses, zusammen mit console.log Erfolgsmeldungen oder Fehlermeldungen, wenn der Prozess fehlschlägt.

Automatisierungsskript auf GitHub ausführen
Automatisierungsskript auf GitHub ausführen

Wie im Bild oben zu sehen ist, hat das Skript ein neues Trello-Board mit drei Listen erstellt, darunter die Go-Live Pipeline-Liste. Die folgenden Bilder zeigen das neue Trello-Board und die Go-Live-Pipeline-Checkliste innerhalb der To-Do-Karte.

Ein Trello-Board
Ein Trello-Board wurde automatisch erstellt
Die 'Go-Live'-Pipeline-Checkliste
Die ‚Go-Live‘-Pipeline-Checkliste wurde der ‚To Do‘-Liste hinzugefügt

Proaktives Monitoring mit Kinsta API und Trello

Die Integration des Kinsta-Hostings mit dem Trello-Projektmanagement geht weit über das erste Onboarding hinaus. Durch die Nutzung der jeweiligen APIs kannst du einen kontinuierlichen Kommunikationsfluss zwischen den beiden Umgebungen aufrechterhalten und sicherstellen, dass dein Team in Echtzeit über den Zustand deiner Websites informiert ist.

So kannst du zum Beispiel automatisch eine Trello-Karte zum Board deines Teams hinzufügen, wenn ein kritisches Ereignis eintritt, z. B. eine hohe Bandbreitennutzung oder wenig Speicherplatz. Das System kann automatisch eine Karte auf dem Board des technischen Teams erstellen, zusammen mit einer Aufgaben-Checkliste.

Mit der gleichen Logik und den gleichen Tools, die wir für das Onboarding verwendet haben, kannst du auch die Überwachung und das Health-Check-Management deiner Standorte automatisieren. Dazu brauchst du eine neue Konfigurationsdatei und ein eigenes Skript: Gehe zurück zu GitHub und erstelle die Datei .github/workflows/health-check.yml mit dem folgenden Code:

name: Daily Health Check

on:
  schedule:
    - cron: '0 9 * * *' # Runs at 09:00
  workflow_dispatch:    # Start manually

jobs:
  health-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - name: Run Health Check
        env:
          KINSTA_API_KEY: ${{ secrets.KINSTA_API_KEY }}
          KINSTA_COMPANY_ID: ${{ secrets.KINSTA_COMPANY_ID }}
          TRELLO_API_KEY: ${{ secrets.TRELLO_API_KEY }}
          TRELLO_TOKEN: ${{ secrets.TRELLO_TOKEN }}
        run: node health-check.js

Hier sind die wichtigsten Punkte dieses Konfigurationsskripts:

  • Wir haben einen automatischen Timer eingerichtet, der das Skript jeden Tag um 09:00 UTC ausführt ((schedule: - cron: '0 9 * * *').
  • workflow_dispatch führt das Skript jederzeit über die Registerkarte Aktionen auf GitHub aus. Das ist besonders bei der Entwicklung und Fehlersuche nützlich.
  • Dann haben wir die Reihenfolge der Vorgänge festgelegt: Der letzte Befehl verwendet node, um die Datei health-check.js auszuführen.

1. Variablen deklarieren

Navigiere zum Hauptverzeichnis deines Repositorys, erstelle eine Datei namens health-check.js und deklariere die folgenden Variablen:

const KINSTA_API_URL = 'https://api.kinsta.com/v2';
const TRELLO_API_URL = 'https://api.trello.com/1';

const secrets = {
	kinsta: process.env.KINSTA_API_KEY,
	company: process.env.KINSTA_COMPANY_ID,
	trelloKey: process.env.TRELLO_API_KEY,
	trelloToken: process.env.TRELLO_TOKEN
};

2. Kinsta-Websites abrufen

Als nächstes definierst du die Funktion getKinstaSites():

async function getKinstaSites() {
	const url = `${KINSTA_API_URL}/sites?company=${secrets.company}`;
	const response = await fetch(url, {
		method: 'GET',
		headers: { 'Authorization': `Bearer ${secrets.kinsta}` }
	});
	if (!response.ok) throw new Error(`Kinsta API error: ${response.status}`);
	const data = await response.json();
	return data.company?.sites || [];
}

Diese Funktion gibt entweder eine Liste mit den Websites des Unternehmens in MyKinsta oder ein leeres Array zurück.

3. Bandbreitennutzung abfragen

Definiere eine Funktion namens getBandwidthUsage(), die die Bandbreitennutzung einer Website zurückgibt.

async function getBandwidthUsage(siteId) {
  const url = `${KINSTA_API_URL}/sites/${siteId}/usage/bandwidth/this-month`;
  const response = await fetch(url, {
    method: 'GET',
    headers: { 'Authorization': `Bearer ${secrets.kinsta}` }
  });
  if (!response.ok) return null;
  const data = await response.json();
  const bytes = data.site?.this_month_usage?.bandwidth;
  return bytes !== undefined ? Math.round(bytes / (1024 * 1024)) : 0;
}

4. Trello-Karten erstellen

Die folgende Funktion erzeugt eine Karte mit dem Titel „⚠️ Bandwidth Alert: High Traffic“:

async function postTrelloAlert(siteName, message) {
	const boardsResp = await fetch(`${TRELLO_API_URL}/members/me/boards?key=${secrets.trelloKey}&token=${secrets.trelloToken}`);
	const boards = await boardsResp.json();
	const board = boards.find(b => b.name === siteName);

	if (board) {
		const listsResp = await fetch(`${TRELLO_API_URL}/boards/${board.id}/lists?key=${secrets.trelloKey}&token=${secrets.trelloToken}`);
		const lists = await listsResp.json();
		const targetList = lists.find(l => l.name === 'To Do') || lists[0];

		const cardsResp = await fetch(`${TRELLO_API_URL}/lists/${targetList.id}/cards?key=${secrets.trelloKey}&token=${secrets.trelloToken}`);
		const cards = await cardsResp.json();
    
		const alertTitle = `⚠️ Bandwidth Alert: High Traffic`;
		if (!cards.find(c => c.name === alertTitle)) {
			await fetch(`${TRELLO_API_URL}/cards?idList=${targetList.id}&name=${encodeURIComponent(alertTitle)}&desc=${encodeURIComponent(message)}&key=${secrets.trelloKey}&token=${secrets.trelloToken}`, {
				method: 'POST'
			});
		console.log(`📌 Alert posted for ${siteName}`);
		}
	}
}
  • Beachte die Bedingung if (!cards.find(...)). Sie verhindert, dass dein Board mit doppelten Benachrichtigungen überladen wird.

5. Führe das Skript aus

Zum Schluss definierst du eine Funktion, die deine Websites überwacht.

async function runMonitoring() {
  console.log("📊 Starting standalone Health Check...");
  const sites = await getKinstaSites();
  for (const site of sites) {
    const usage = await getBandwidthUsage(site.id);
    if (usage !== null) {
      console.log(`Site: ${site.name} | Usage: ${usage} MB`);
      if (usage > 100) { // Test threshold
        await postTrelloAlert(site.name, `Bandwidth usage: ${usage} MB.`);
      }
    }
  }
}

runMonitoring().catch(console.error);

Wenn diese Funktion ausgeführt wird, ruft sie die zuvor definierten Funktionen auf:

  • getKinstaSites(): Holt die Liste der Unternehmensstandorte in MyKinsta;
  • getBandwidthUsage(): Prüft die Bandbreitennutzung des aktuellen Monats für jeden Standort;
  • postTrelloAlert(): Erzeugt automatisch eine Trello-Karte, wenn der Schwellenwert erreicht wird und keine vorherige Karte existiert.
Eine Trello-Karte, die automatisch nach einer Bandbreitenkontrolle erstellt wird
Eine Trello-Karte, die automatisch nach einer Bandbreitenkontrolle erstellt wird

Intelligenter skalieren, nicht härter mit Kinsta

Die Skalierung muss nicht bedeuten, dass du mehr Arbeit hast. Mit einer gut durchdachten Automatisierungsstrategie können sich wiederholende manuelle Aufgaben eliminiert und neue Projekte in dein Portfolio aufgenommen werden, ohne dass dein Betrieb überlastet wird.

Indem du die Lücke zwischen deiner Standortinfrastruktur und dem Projektmanagement schließt, kannst du nahtlose Kommunikationskanäle einrichten, die rohe Hosting-Daten in umsetzbare operative Aufgaben umwandeln.

Dank der Kinsta-APIs und GitHub-Aktionen haben wir ein automatisiertes Onboarding- und proaktives Überwachungssystem geschaffen, das das Risiko menschlicher Fehler reduziert, dein Team entlastet und sicherstellt, dass du immer bereit bist, auf Probleme zu reagieren, sobald sie auftreten. So kannst du von der reaktiven Brandbekämpfung zur proaktiven Zukunftssicherung übergehen.

Bist du bereit, die Arbeitsabläufe in deiner Behörde zu automatisieren? Schau dir unsere Pläne an, um den richtigen für dich zu finden.

Carlo Daniele Kinsta

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.