Eine WordPress-Website mithilfe von Kinsta-API-Endpunkten durch die Entwicklung pushen

Die Kinsta-API dient nicht nur zur Überwachung der Sicherheit deiner Website oder zum Abrufen von Umgebungsinformationen. Ein Teil unserer Philosophie ist es, dir dabei zu helfen, deine Entwicklungsabläufe zu optimieren.

So können die Endpunkte dich von der ersten lokalen Einrichtung über die erste Bereitstellung bis hin zur Wartung nach dem Start begleiten. Die API kann die meisten Aufgaben auf deiner To-Do-Liste erledigen, z. B. das Erstellen von Umgebungen, das Klonen von Websites und vieles mehr.

In diesem Artikel zeigen wir dir, wie du Websites entwickeln kannst, indem du die Kinsta-API-Endpunkte nutzt. Dabei erfährst du, wie du die API in deinen typischen Entwicklungsworkflow integrieren kannst und wie du den Prozess effizienter und reibungsloser gestalten kannst. Beginnen wir mit einem kurzen Überblick darüber, was die Kinsta-API ist und was sie kann.

Eine kurze Einführung in die Kinsta-API

Kurz gesagt: Mit der Kinsta-API kannst du programmatisch mit deinen Websites und Umgebungen auf unserer Plattform interagieren. Wir stellen dir eine Reihe von Endpunkten zur Verfügung, mit denen du verschiedene Aufgaben erledigen kannst, z. B. neue WordPress-Websites erstellen, bestehende Websites klonen, Backups verwalten und vieles mehr.

Diese RESTful-API bietet dank ihrer wichtigsten Merkmale und Funktionen viele Vorteile für deine Entwicklungsprojekte:

• Automatisierung. Du kannst gängige Aufgaben und Arbeitsabläufe automatisieren, was Zeit spart, den manuellen Aufwand reduziert und dir den Kopf für wichtigere Aufgaben frei macht.
• Integration. Du kannst die API in deine bestehenden Tools und Systeme integrieren. Kontinuierliche Integration und kontinuierliche Bereitstellung (CI/CD) ist ein hervorragender Anwendungsfall für die gemeinsame Nutzung der Kinsta-API und der Tools von Drittanbietern.
• Flexibilität. Mit der API kannst du deine Websites und Umgebungen genau steuern und deine Einrichtung mit wenigen Einschränkungen an deine spezifischen Bedürfnisse anpassen.

Wenn du mehr über die Möglichkeiten der Kinsta-API erfahren möchtest, schau dir die entsprechende Dokumentation an. Im weiteren Verlauf dieses Beitrags werden wir uns viele Beispiele ansehen, nachdem wir die Vorteile der API näher beleuchtet haben.

Warum deine Entwicklungsabläufe von der Kinsta-API profitieren können

Natürlich lieben wir das MyKinsta-Dashboard für seine Tiefe, die wunderschöne Oberfläche und den Umfang der Kontrolle. Die meisten Funktionen findest du aber auch in der Kinsta-API. Für dich als Entwicklerin oder Entwickler ist das aus mehreren Gründen interessant:

1. Schnelleres Provisioning. Die API bietet eine programmatische Möglichkeit, neue WordPress-Websites und -Umgebungen zu erstellen. Abhängig von den Skripten, die du erstellst, wirst du die Zeit, die du für die Einrichtung eines neuen Projekts brauchst, wahrscheinlich verkürzen.
2. Optimierte Zusammenarbeit. Für Teams kann die API dabei helfen, Websites zu klonen und schnell Staging-Umgebungen zu erstellen. Das ist eine gute Möglichkeit, zusammenzuarbeiten und gleichzeitig an verschiedenen Versionen einer Website zu arbeiten.
3. Automatisierte Bereitstellungen. Wenn du die Kinsta-API in deine CI/CD-Pipeline integrierst, kannst du den Bereitstellungsprozess für alle deine Staging- und Produktionsumgebungen automatisieren.
4. Konsistente Konfigurationen. Da du mit der API Einstellungen über mehrere Websites und Umgebungen hinweg konfigurieren kannst, kannst du Fehler reduzieren und deine Arbeitsabläufe konsistenter gestalten.

Genug geredet: Lass uns jetzt die Kinsta-API nutzen. Wir beginnen mit den Endpunkten, die sich gut für die Entwicklung eignen, und nutzen sie dann in deinem Workflow.

Die API-Endpunkte von Kinsta für die Entwicklung

Die Kinsta-API bietet zwar viele Endpunkte, aber du wirst einige mehr nutzen als andere. Für die Entwicklung wirst du immer wieder auf ein paar von ihnen zurückkommen:

• WordPress-Websites. Du hast eine Auswahl an Endpunkten, mit denen du Websites erstellen, abrufen, löschen und klonen kannst.
• WordPress-Seiten-Umgebungen. Du kannst deine Seiten-Umgebungen auch über bestimmte Endpunkte verwalten. Du hast zum Beispiel mehrere Möglichkeiten, mit Staging-Seiten zu arbeiten.
• Backups. Es kann sein, dass du während der Entwicklung an der Verwaltung von Backups arbeiten musst. Wir bieten Endpunkte zum Abrufen, Wiederherstellen, Löschen und Erstellen von Backups.
• WordPress-Website-Domains. Wenn du eine neue benutzerdefinierte Domain zu deinem Hosting hinzufügen musst, sind unsere einfachen Endpunkte für die Verwaltung von Website-Domains die richtige Anlaufstelle für dich.

Diese Endpunkte decken die Kernfunktionen ab, die du für die meisten Entwicklungsabläufe brauchst. Es gibt jedoch noch weitere Endpunkte, die die von dir häufig genutzten Endpunkte ergänzen können. Zum Beispiel spielen die Endpunkte für Datenbanken, Bereitstellung, Caching und dein Content Delivery Network (CDN) eine wichtige Rolle.

Im weiteren Verlauf des Artikels gehen wir darauf ein, wie du die Kinsta-API in der Praxis einsetzen kannst. In den Kommentaren am Ende des Beitrags kannst du uns sogar deine eigenen Beispiele nennen, bei denen die Kinsta-API deiner Meinung nach nützlich sein könnte – wir würden uns freuen, sie zu hören!

Ein Anwendungsfall aus der Praxis: Eine Website in der Entwicklung vorantreiben

Lass uns versuchen, zu veranschaulichen, wie du die Kinsta-API in der Praxis nutzen kannst. Es gibt viele Möglichkeiten, WordPress zu entwickeln, also schauen wir uns an, wie eine Webdesign-Agentur die API im Rahmen eines Workflows nutzen könnte. In der Regel sind das ein paar Schritte:

1. Richte eine lokale Entwicklungsumgebung ein, initialisiere ein Git Repo und arbeite an der jungen Website.
2. Erstelle eine Staging-Umgebung in Kinsta für Tests und Kundenfreigaben. Dazu kann auch das Anlegen einer Datenbank und das Einrichten einer Domain gehören
3. Technische Einstellungen vornehmen, z.B. IP-Adressen von der Staging-Umgebung ausschließen, Backups einrichten, PHP-Versionen ändern, WordPress-Themes und Plugins installieren und vieles mehr.
4. Erledige Aufgaben vor der Bereitstellung, wie die Einrichtung eines CDN oder die Implementierung von Caching.
5. Im letzten Schritt des Arbeitsablaufs musst du die Änderungen von der Staging- in die Produktionsumgebung übertragen.

Auch wenn die Kinsta-API in diesem Beitrag eine große Rolle spielen wird, brauchen wir sie für den ersten Schritt nicht. Beginnen wir mit dem Einrichten deiner lokalen Entwicklungsumgebung und gehen dann zu den programmatischen Elementen für Staging und Produktion über.

1. Einrichten einer lokalen Entwicklungsumgebung

Deine lokale Umgebung muss absolut stabil sein, und jeder Entwickler hat seine eigene Lieblingsmethode. Unsere Wahl fällt hier natürlich auf DevKinsta.

Das kann die Einrichtung deiner lokalen Umgebung vereinfachen, besonders wenn du das Hosting von Kinsta nutzt. DevKinsta ist kostenlos und bietet dir viele Funktionen, die andere ähnliche Tools nicht bieten können:

• Die App läuft in Docker-Containern und ist somit von deinem globalen System isoliert.
• Du kannst eine eigene Top-Level-Domain (TLD) wie .local oder .staging wählen, die zu deinem Projekt und deinem Arbeitsablauf passt.
• Du hast die Wahl zwischen verschiedenen PHP-Versionen und Kinsta verwendet standardmäßig MariaDB-Datenbanken. Letzteres ist besonders wichtig, da es leistungsfähiger als MySQL ist.
• Es gibt einen integrierten Datenbankmanager, der auf Adminer läuft.

DevKinsta bietet auch eine Reihe von Tools für Entwickler. Du kannst zum Beispiel Xdebug mit einem Klick aktivieren und die Konfigurationsdateien php.ini und Nginx in den Einstellungen bearbeiten:

Die Einrichtung und Nutzung von DevKinsta würde den Rahmen dieses Beitrags sprengen, da wir uns auf die Kinsta-API konzentrieren wollen. Wir haben jedoch eine ausführliche Dokumentation zum Start mit der lokalen Umgebung, die du unbedingt lesen solltest.

2. Verwaltung der lokalen und der Staging-Entwicklungsumgebung

Zu diesem Zeitpunkt hast du eine lokale Entwicklungsumgebung (hoffentlich DevKinsta!) und eine Website, die vollständig genug ist, um zum nächsten Schritt überzugehen. Die Erstellung einer Staging-Umgebung nutzt sowohl die Funktionen von DevKinsta als auch die der Kinsta-API. Lass uns das in ein paar kurze Schritte unterteilen.

Erstellen einer Staging-Umgebung

Als erstes musst du mit der Kinsta-API eine neue Staging-Umgebung erstellen. Dies kannst du innerhalb von DevKinsta über Links zum MyKinsta-Dashboard tun:

Die Kinsta-API hat jedoch Endpunkte für jeden praktischen Anwendungsfall. Du kannst zum Beispiel sowohl einfache als auch bestückte Websites und Umgebungen erstellen. Wir empfehlen an dieser Stelle, einfache Umgebungen zu verwenden, da du so die Gewissheit hast, dass deine lokale Website an einen „frischen“ Ort verschoben wird.

Dazu musst du zunächst eine neue WordPress-Website auf Kinsta einrichten und den entsprechenden Endpunkt verwenden:

const resp = await fetch(
  `https://api.kinsta.com/v2/sites/plain`,
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: 'Bearer <YOUR_TOKEN_HERE>'
    },
    body: JSON.stringify({
      company: '54fb80af-576c-4fdc-ba4f-b596c83f15a1',
      display_name: 'First plain site',
      region: 'us-central1'
    })
  }
);

const data = await resp.json();

Sobald die Website eingerichtet ist, kannst du eine Liste der Websites abrufen, indem du eine Unternehmens-ID angibst:

…
  "company": {
    "sites": [
      {
        "id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
        "name": "firstsite",
        "display_name": "First site",
        "status": "live",
        "siteLabels": [
          {
            "id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
            "name": "Do not remove"
…

Danach kannst du die Staging-Umgebung mit der richtigen Site-ID erstellen:

const siteId = 'YOUR_site_id_PARAMETER';
const resp = await fetch(
  `https://api.kinsta.com/v2/sites/${siteId}/environments/plain`,
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: 'Bearer <YOUR_TOKEN_HERE>'
    },
    body: JSON.stringify({
      display_name: 'staging',
      is_premium: false
    })
  }
);

const data = await resp.json();

Wir empfehlen dir auch, gleich eine Datenbank für die Staging-Website zu erstellen. In wenigen Augenblicken wirst du sie mit deiner lokalen Datenbank überschreiben, aber es ist eine gute Praxis, einen Platzhalter zu initialisieren:

…
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: 'Bearer <YOUR_TOKEN_HERE>'
    },
    body: JSON.stringify({
      company_id: '54fb80af-576c-4fdc-ba4f-b596c83f15a1',
      location: 'us-central1',
      resource_type: 'db1',
      display_name: 'test-db',
      db_name: 'test-db',
      db_password: 'example-password',
      db_user: 'example-user',
      type: 'postgresql',
      version: '15'
    })
  }
);
…

Je nach deiner Konfiguration musst du vielleicht auch eine neue Domain zu Kinsta hinzufügen, was du über einen einfachen Endpunkt tun kannst. Sobald das Staging eingerichtet ist, kannst du deine lokalen Änderungen dorthin übertragen.

Änderungen von lokal nach Staging synchronisieren

Wie genau du deine Änderungen ins Staging überträgst, hängt von deinen spezifischen Einstellungen und Tools ab. Ein allgemeiner und typischer Ansatz könnte wie folgt aussehen:

1. Nimm Änderungen an deiner lokalen WordPress-Website vor.
2. Übertrage die Änderungen auf Git.
3. Pushe die Änderungen an eine andere Stelle (z.B. GitHub oder GitLab).
4. Nutze DevKinsta oder die Kinsta-API, um die Staging-Umgebung mit den neuesten Änderungen zu aktualisieren.

Wir werden hier nicht auf die Versionskontrolle eingehen, aber DevKinsta bietet praktische Tools, mit denen du Änderungen auf dein Kinsta-Hosting übertragen kannst:

Damit kannst du die Umgebung deines gesamten Hosting-Servers auswählen. Wenn du das tust, kannst du auch deine Datenbank pushen – etwas, das nicht viele lokale Entwicklungstools ermöglichen:

Sobald du deine Kinsta-Staging-Umgebung eingerichtet hast, wird dir die API sehr nützlich sein. Du kannst zum Beispiel ein Skript erstellen und ein erstes Backup durchführen, für das du nur eine Umgebungs-ID und ein Tag benötigst:

  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: 'Bearer <YOUR_TOKEN_HERE>'
    },
    body: JSON.stringify({
      tag: 'my-awesome-backup'
    })
  }
);

Wenn du möchtest, kannst du in dieser Phase auch weitere Themes und Plugins installieren. An diesem Punkt endet unsere DevKinsta-Nutzung, denn von nun an kannst du deine Website über die Kinsta-API bereitstellen.

3. Änderungen vom Staging in die Produktion übertragen

Bevor du die Änderungen in die Produktion überführst, musst du ein paar wichtige Aufgaben mit der Kinsta-API erledigen:

• Aktualisiere deine IP-Blockliste, falls nötig.
• Richte dein CDN und Caching ein.
• Möglicherweise musst du eine weitere Datenbank für deine Produktionsseite anlegen.
• Eventuell musst du auch eine neue Live-Umgebung erstellen.

Ab hier solltest du deine Website im Staging-Modus vollständig testen und die Zustimmung deines Kunden einholen. Jetzt kannst du dich an die Bereitstellung machen. Kinsta bietet dir dafür mehrere Möglichkeiten:

1. Über das MyKinsta-Dashboard kannst du Änderungen vom Staging in die Produktion übertragen.
2. Du kannst die Kinsta-API nutzen, um Änderungen programmatisch zu verteilen.

Wir werden uns (natürlich) auf die zweite Option konzentrieren, da sie einen automatisierten und rationalisierten Arbeitsablauf ermöglicht.

Änderungen über die API bereitstellen

Die Kinsta-API bietet mehrere Möglichkeiten, eine Umgebung zu verschieben. Du kannst deine Staging-Umgebung in deine Produktionsumgebung verschieben oder sie klonen.

const siteId = 'YOUR_site_id_PARAMETER';
const resp = await fetch(
  `https://api.kinsta.com/v2/sites/${siteId}/environments`,
  {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json',
      Authorization: 'Bearer <YOUR_TOKEN_HERE>'
    },
    body: JSON.stringify({
      source_env_id: '54fb80af-576c-4fdc-ba4f-b596c83f15a1',
      target_env_id: '54fb80af-576c-4fdc-ba4f-b596c83f15a1',
      push_db: true,
      push_files: true,
      run_search_and_replace: true
    })
  }
);

const data = await resp.json();

In jedem Fall ist es eine gute Idee, von jeder Umgebung, die du betreibst, ein weiteres Backup zu erstellen, damit du sie wiederherstellen kannst, falls etwas schiefgeht.

Typische Praktiken und Tipps für die Nutzung der Kinsta-API

Die Kinsta-API ist eine leistungsstarke Methode, um programmatische Änderungen an deinen Websites und Umgebungen vorzunehmen. Wenn etwas schief geht, bist du dafür verantwortlich, es zu reparieren.

Aus diesem Grund möchten wir dir ein paar Tipps, Tricks und typische Vorgehensweisen vorstellen, die du in deinen eigenen Entwicklungsprozess integrieren solltest:

• Sichere deine API-Anmeldedaten. Du solltest dein API-Token niemals an andere weitergeben oder es in Git-Pushes einbinden. Verwende stattdessen Umgebungsvariablen oder Ähnliches, um deine Anmeldedaten zu speichern und darauf zuzugreifen. Die Kinsta-API enthält einen Authentifizierungsendpunkt, der dich dabei unterstützt.
• Gib den Zugang nach dem Prinzip der geringsten Rechte frei. Verwalte den Zugang zu deinem Kinsta-Konto und der API richtig. Gib nur denjenigen Teammitgliedern Zugang, die ihn brauchen. Außerdem solltest du regelmäßige Überprüfungen und Aktualisierungen der Zugriffsberechtigungen einplanen.
• Verwende eine Fehlerbehandlung. Wenn du API-Anfragen stellst, solltest du die Behandlung von Fehlern und Ausnahmen in Betracht ziehen. Der Endpunkt Logs kann dabei helfen, Probleme schnell zu erkennen und zu beheben.
• Halte die API auf dem neuesten Stand. Wir kümmern uns um alle Änderungen und Aktualisierungen der Kinsta-API, aber auch du solltest sie im Auge behalten. Der Kinsta Changelog ist hier deine erste Anlaufstelle, aber auch die bestehende Dokumentation sollte auf neue Änderungen überprüft werden.

Das ist viel wichtiger, wenn es um die weitere Zusammenarbeit mit den Teams und die Automatisierung geht, die du vielleicht einsetzen möchtest. In unserem letzten Abschnitt gehen wir darauf etwas genauer ein.

Automatisiere deinen Entwicklungsworkflow

Einer der größten Vorteile der Kinsta-API ist die Möglichkeit, sich wiederholende Aufgaben in deinem Entwicklungsworkflow zu automatisieren. Durch das Schreiben von Skripten oder die Integration mit anderen Tools kannst du Prozesse rationalisieren und Zeit sparen.

Um deinen Arbeitsablauf vollständig zu optimieren, kannst du den Push vom Staging zur Produktion automatisieren, indem du die Kinsta-API in deine CI/CD-Pipeline integrierst. Dies kann ein komplexer und subjektiver Prozess sein, der sich sogar von Projekt zu Projekt ändern kann. Hier ist zum Beispiel ein Beispielworkflow für ein geeignetes Skript:

1. Implementiere einen Trigger für den Fall, dass Änderungen in einen bestimmten Git-Zweig (z.B. einen Release-Zweig ) gepusht werden.
2. Erstelle ein manuelles Backup der Produktionsumgebung mithilfe der API.
3. Ersetze die Produktionsumgebung durch die Staging-Umgebung, indem du den entsprechenden Endpunkt verwendest.
4. Führe alle notwendigen Post-Deployment-Aufgaben durch (z. B. Löschen des Cache, Datenbankmigrationen usw.).

Das ist der große Pluspunkt der Kinsta-API. Du kannst fast jeden Aspekt deines Workflows automatisieren, um konsistente und zuverlässige Bereitstellungen zu gewährleisten. Und es gibt noch viel mehr, was du damit machen kannst:

• Erstelle Backups vor Key-Pushes. Das sollte ein wichtiger Teil deines Verteilungsworkflows sein, damit du von jeder Phase des Prozesses Schnappschüsse hast.
• Überwache die Leistung deiner Website und lass dich benachrichtigen. Mit dem APM-Tool von Kinsta kannst du alle Metrik-Anomalien im Auge behalten, über die du Bescheid wissen musst. Mit der Kinsta-API hast du eine Reihe von Endpunkten, um bestimmte Kennzahlen zu überwachen. Von dort aus kannst du im MyKinsta-Dashboard Benachrichtigungen einrichten.
• Überprüfe die Nutzer deiner Website regelmäßig. Es gibt einen einfachen Endpunkt, der eine Liste der Nutzer/innen auf Basis der Website-ID abruft. Wenn du diesen Endpunkt so einrichtest, dass er in wichtigen Momenten des Workflows angezeigt wird, können deine Websites sicher bleiben.

Das Schöne an der Kinsta-API ist, wie viel du mit programmatischen Methoden steuern kannst. Du kannst sogar benutzerdefinierte Dashboards erstellen, die einige dieser Metriken oder Optionen für einen noch reibungsloseren Entwicklungsworkflow anzeigen.

Zusammenfassung

Die Kinsta-API ist wohl die einzige Möglichkeit, mit der du deinen Entwicklungsworkflow optimieren solltest. Wenn du die verschiedenen Endpunkte für die Verwaltung von Websites, Umgebungen, Backups und mehr nutzt, kannst du sich wiederholende Aufgaben automatisieren, die Zusammenarbeit verbessern und Änderungen zuverlässig einführen.

Außerdem kannst du durch die Integration der Kinsta-API in deinen Entwicklungsprozess den Prozess für jedes Projekt individuell anpassen. So kannst du schneller als je zuvor hochwertige Websites bereitstellen.

Welcher Aspekt der Kinsta-API gefällt dir in deinem Entwicklungsprozess? Lass es uns in den Kommentaren unten wissen!

Jeremy Holcombe Kinsta

Content & Marketing Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).

• Webseite
• LinkedIn