Bundles verbinden deine Deployments

Loopback Bundles verbinden GitHub, Image-Builds, Registry und Kubernetes-Deployments. Verwalte Sources, Environments und Deployment History in einem Workflow.

5 Min. Lesezeit
Bundles verbinden deine Deployments

Ein Deployment beginnt im Repository und endet mit einer laufenden Anwendung auf dem Cluster. Dazwischen müssen Quellcode, Image-Build, Registry, Deployment-Konfiguration und Zielumgebung zusammenpassen.

Loopback Bundles verbinden diese Schritte innerhalb der Plattform. Ein Bundle bildet eine Anwendung ab, die du direkt aus GitHub auf deinen Kubernetes-Cluster deployen kannst. Zur Anwendung gehören ihre Sources, Environments und Deployment History. Deploy, Rollback und Undeploy steuerst du im selben Workflow.

Eine Anwendung als Bundle

Eine Anwendung besteht im Betrieb aus mehr als ihrem Quellcode. Sie benötigt ein ausführbares Image, eine Beschreibung der Kubernetes-Ressourcen und die Konfiguration für ihre jeweilige Umgebung.

Bundles führen diese Bestandteile unter einer Anwendung zusammen. Das Team legt ein Bundle an, verbindet die benötigten Quellen und richtet die Environments ein.

Dabei haben die einzelnen Bestandteile unterschiedliche Aufgaben:

BestandteilAufgabe
SourcesStellen die Quellen für Anwendung und Charts bereit
EnvironmentDefiniert den Deployment-Kontext einer Umgebung
Ziel-WorkspaceIst der Kubernetes-Cluster, auf den deployt wird
RegistrySpeichert die gebauten Images
Deployment HistoryMacht bisherige Deployments nachvollziehbar

Diese Zuordnung schafft einen gemeinsamen Bezugspunkt. Wer an einer Anwendung arbeitet, findet ihre Quellen, Umgebungen und Deployments im zugehörigen Bundle.

Bundles mit GitHub verbinden

Der Einstieg erfolgt über die Anbindung von GitHub. Du verbindest dein GitHub-Konto und machst die benötigten Repositories als Quellen für Bundles verfügbar.

Ein Bundle unterstützt mehrere Sources für Anwendung und Charts. Damit kannst du auch einen Aufbau abbilden, bei dem der Anwendungscode und das Deployment-Paket getrennt gepflegt werden.

Ein Team könnte beispielsweise den Code seiner checkout-api in einem Repository verwalten und die zugehörigen Charts in einem weiteren. Innerhalb des Bundles gehören beide Quellen zur selben Anwendung.

Das ist besonders dann hilfreich, wenn sich die Verantwortlichkeiten unterscheiden: Entwickler arbeiten am Anwendungscode, während ein Plattformteam die Deployment-Struktur pflegt. Das Bundle führt die Quellen für den gemeinsamen Deployment-Ablauf zusammen.

Environments für unterschiedliche Umgebungen

Anwendungen durchlaufen häufig mehrere Umgebungen. In der Entwicklung werden Änderungen ausprobiert, in Staging werden Releases geprüft und in Production wird die Anwendung genutzt.

In Loopback kannst du mehrere Environments pro Bundle anlegen. Für jedes Environment legst du den Ziel-Workspace und die zugehörigen Einstellungen fest. Dazu gehören beispielsweise der verwendete Branch, Build-Trigger und die Auswahl der Chart-Version.

Eine mögliche Aufteilung sieht so aus:

EnvironmentZweckBeispiel für das Ziel
DevelopmentÄnderungen während der Entwicklung prüfenEntwicklungscluster
StagingEinen vorgesehenen Release testenStaging-Cluster
ProductionDie Anwendung produktiv betreibenProduktionscluster

Die Environments gehören zur selben Anwendung, bilden aber unterschiedliche Deployment-Kontexte ab.

Für dein Team lohnt es sich, diese Kontexte bewusst zu definieren. Welche Änderungen sollen einen Build auslösen? Welcher Branch gehört zu welcher Umgebung? Welche Chart-Version soll eingesetzt werden? Die Antworten bilden die Grundlage für einen nachvollziehbaren Workflow.

Vom Quellcode zum Image

Sobald Quellen und Environment eingerichtet sind, kann die Pipeline den Anwendungscode verarbeiten und das Container Image bauen.

In Loopback kannst du Pipeline-Runs und Build-Logs einsehen. Dadurch lässt sich nachvollziehen, welcher Quellcode verarbeitet wurde und wie der Build abgelaufen ist.

Das gebaute Image wird automatisch in der organisationsweiten Loopback Registry gespeichert. Damit erhält das Build-Ergebnis einen festen Platz innerhalb des Stacks und steht für das anschließende Deployment bereit.

Die einzelnen Schritte erfüllen dabei klar getrennte Aufgaben:

  1. Quellcode beziehen: Die Pipeline arbeitet mit dem vorgesehenen Stand aus dem Repository.
  2. Image bauen: Aus dem Anwendungscode entsteht das Container Image.
  3. Image speichern: Das Artefakt wird in der Loopback Registry abgelegt.
  4. Deployment ausführen: Die Anwendung wird mit ihrer Deployment-Konfiguration auf dem Ziel-Cluster ausgerollt.

Das Bundle verbindet diese Schritte mit der Anwendung und dem jeweiligen Environment.

Charts beschreiben das Deployment

Das Container Image enthält die ausführbare Anwendung. Für den Betrieb auf Kubernetes braucht es zusätzlich eine Beschreibung der Ressourcen und ihrer Konfiguration.

Bundles integrieren dafür einen Chart Builder und unterstützen Sources für Charts. Die Auswahl der Chart-Version gehört zu den Einstellungen des Environments.

Damit lassen sich Anwendung und Deployment-Konfiguration gemeinsam betrachten. Ein neuer Stand des Anwendungscodes kann andere Anforderungen an die Konfiguration mitbringen. Ebenso kann sich die Deployment-Struktur weiterentwickeln, während der Anwendungscode unverändert bleibt.

Für die Release-Planung ist deshalb die Kombination entscheidend: Welcher Anwendungsstand wird mit welcher Chart-Version in welcher Umgebung eingesetzt?

Eine klare Zuordnung dieser Bestandteile hilft dem Team, Änderungen gezielt zu prüfen und Deployments später nachzuvollziehen.

Deployments nachvollziehen und steuern

Nach dem Build folgt der Schritt auf den Cluster. Auch danach bleibt das Bundle der Bezugspunkt für die Anwendung.

Die Deployment History zeigt die bisherigen Deployments. Über die zugehörige Steuerung kannst du Deploy, Rollback und Undeploy ausführen.

Diese Aktionen erfüllen unterschiedliche Aufgaben:

AktionZweck
DeployEinen vorgesehenen Stand ausrollen
RollbackAuf einen vorherigen Deployment-Stand zurückgehen
UndeployEin Deployment entfernen

Für den Betrieb ist vor allem die Verbindung zwischen Verlauf und Handlung hilfreich. Das Team kann sich mit bisherigen Deployments befassen und den nächsten Schritt im selben Anwendungskontext ausführen.

Ein Rollback sollte dabei zur Anwendung passen. Wenn ein Release beispielsweise externe Datenformate oder Schnittstellen verändert, gehören diese Änderungen ebenfalls in die Release-Planung. Der Deployment-Verlauf liefert den technischen Kontext für die Entscheidung.

Ein Workflow für dein Team

Angenommen, ein Team entwickelt eine Anwendung mit getrennten Entwicklungs- und Produktionsumgebungen.

Zunächst verbindet es die GitHub-Quellen für Anwendung und Charts. Anschließend legt es ein Bundle mit den benötigten Environments an und ordnet jedem Environment den Ziel-Cluster zu.

Für die Entwicklungsumgebung definiert das Team den vorgesehenen Branch und die Build-Trigger. Änderungen können dort gebaut und geprüft werden. Für die Produktionsumgebung legt es fest, welcher Anwendungsstand mit welcher Chart-Version ausgerollt werden soll.

Während des Ablaufs bleiben die Zusammenhänge sichtbar: Die Sources liefern den Code und die Charts, die Pipeline erzeugt das Image, die Registry speichert das Artefakt und das Environment bestimmt den Deployment-Kontext.

Deployment als Teil des Stacks

Mit Bundles wird die Anwendung zum gemeinsamen Bezugspunkt für Quellen, Builds und Deployments.

GitHub liefert den Quellcode. Gebaute Images landen in der Loopback Registry. Environments verbinden die Anwendung mit ihren Ziel-Clustern. Deployment History und Steuerung begleiten den weiteren Betrieb.

So kannst du den Weg vom Repository bis zur laufenden Anwendung innerhalb derselben Plattform verwalten.

Bundles auf Loopback entdecken

Dein Stack. Eine Plattform.

Starte mit Managed Kubernetes, Object Storage, Registry oder Bundles. Ein Account, ein Rechte-Modell.