Bundles verbinden deine Deployments
Loopback Bundles verbinden GitHub, Image-Builds, Registry und Kubernetes-Deployments. Verwalte Sources, Environments und Deployment History in einem Workflow.
Loopback Bundles verbinden GitHub, Image-Builds, Registry und Kubernetes-Deployments. Verwalte Sources, Environments und Deployment History in einem Workflow.
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 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:
| Bestandteil | Aufgabe |
|---|---|
| Sources | Stellen die Quellen für Anwendung und Charts bereit |
| Environment | Definiert den Deployment-Kontext einer Umgebung |
| Ziel-Workspace | Ist der Kubernetes-Cluster, auf den deployt wird |
| Registry | Speichert die gebauten Images |
| Deployment History | Macht bisherige Deployments nachvollziehbar |
Diese Zuordnung schafft einen gemeinsamen Bezugspunkt. Wer an einer Anwendung arbeitet, findet ihre Quellen, Umgebungen und Deployments im zugehörigen Bundle.
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.
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:
| Environment | Zweck | Beispiel für das Ziel |
|---|---|---|
| Development | Änderungen während der Entwicklung prüfen | Entwicklungscluster |
| Staging | Einen vorgesehenen Release testen | Staging-Cluster |
| Production | Die Anwendung produktiv betreiben | Produktionscluster |
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.
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:
Das Bundle verbindet diese Schritte mit der Anwendung und dem jeweiligen Environment.
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.
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:
| Aktion | Zweck |
|---|---|
| Deploy | Einen vorgesehenen Stand ausrollen |
| Rollback | Auf einen vorherigen Deployment-Stand zurückgehen |
| Undeploy | Ein 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.
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.
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.
Starte mit Managed Kubernetes, Object Storage, Registry oder Bundles. Ein Account, ein Rechte-Modell.