Warum Container?

Container-Images spielen eine entscheidende Rolle bei der Effizienz und Sicherheit von Anwendungen. Sie bieten eine standardisierte Möglichkeit, Anwendungen und ihre Abhängigkeiten zu verpacken und über verschiedene Umgebungen hinweg konsistent auszuführen. Hier sind einige gute Gründe, warum Container eine entscheidende Rolle spielen:

Effizienter Build-Prozess

Durch die Verwendung von Container-Images können Entwickler den Build-Prozess beschleunigen. Container bündeln die Anwendungslogik und die erforderlichen Abhängigkeiten in einer einzigen Einheit, was den Prozess der Bereitstellung und Verteilung vereinfacht. Dadurch können Entwickler schneller entwickeln, testen und neue Funktionen einführen.

Konsistente Umgebungen

Container stellen sicher, dass Anwendungen in verschiedenen Umgebungen konsistent ausgeführt werden. Dies ist besonders wichtig, wenn Anwendungen von Entwicklungs- und Testumgebungen in die Produktion überführt werden. Container ermöglichen es, dass die Anwendungsumgebung, einschließlich der Konfiguration und Abhängigkeiten, überall reproduzierbar ist. Dadurch werden potenzielle Probleme vermieden, die durch unterschiedliche Umgebungen entstehen können.

Skalierbarkeit und Ressourcenmanagement

Container bieten eine effiziente Möglichkeit, Anwendungen zu skalieren und Ressourcen effektiv zu verwalten. Durch die Isolierung von Anwendungen in Containern kann jede Anwendung unabhängig voneinander skaliert werden, ohne die anderen Komponenten zu beeinträchtigen. Dies ermöglicht eine optimale Ressourcenauslastung und eine bessere Skalierbarkeit.

Einsparen von Infrastrukturkosten

Die Verwendung von Container-Images kann zu geringeren Kosten führen, insbesondere in der Cloud-Umgebung. Container ermöglichen es, Ressourcen effizienter zu nutzen, da sie in der Lage sind, auf einer gemeinsamen Infrastruktur zu laufen. Darüber hinaus ermöglichen Container eine schnellere Bereitstellung und reduzieren die Ausfallzeiten, was zu geringeren Kosten für die Wartung und den Betrieb von Anwendungen führt.

Erhöhte Sicherheit

Container bieten eine zusätzliche Sicherheitsebene für Anwendungen. Durch die Isolation von Anwendungen und deren Abhängigkeiten wird das Risiko einer Ausbreitung von Sicherheitslücken minimiert. Darüber hinaus ermöglichen Container eine granulare Steuerung über Zugriffsrechte und Berechtigungen, wodurch Anwendungen besser geschützt werden können.

Durch die Reduzierung der Image-Größe und die Anwendung bewährter Best Practices bei der Verwendung von Containern können Unternehmen wie Conventic ihre Effizienz steigern und gleichzeitig die Sicherheit ihrer Anwendungen gewährleisten. Im nächsten Abschnitt werden wir uns genauer mit der Verwendung von Alpine-Images als eine bewährte Container-Praxis befassen.

Container Image Größe minimieren

Warum möglichst kleine Container?

Die Minimierung der Image-Größe bietet eine Reihe von Vorteilen, die sowohl die Effizienz als auch die Sicherheit von Anwendungen verbessern:

Schnellerer Build-Prozess

Durch die Reduzierung der Image-Größe werden die Build-Zeiten erheblich verkürzt. Weniger Daten müssen heruntergeladen und verarbeitet werden, was zu einem schnelleren Bereitstellungsprozess führt. Dadurch können Entwickler ihre Änderungen schneller testen und in die Produktion bringen.

Geringere Kosten in der Container Registry

Die Verwaltung von Container-Images erfolgt oft über Container-Registries wie Amazon Elastic Container Registry (ECR). Durch die Reduzierung der Image-Größe verringert sich der Speicherbedarf in diesen Registries. Dies führt zu niedrigeren Speicher- und Betriebskosten, insbesondere in großen und skalierbaren Umgebungen.

Erhöhte Sicherheit durch Verringerung der Angriffsfläche

Container-Images mit kleinerer Größe enthalten weniger potenzielle Angriffsvektoren. Weniger Abhängigkeiten und unnötige Komponenten reduzieren die Angriffsfläche und minimieren das Risiko von Sicherheitslücken und Exploits. Eine geringere Angriffsfläche erhöht die Sicherheit der Anwendungen und schützt vor möglichen Angriffen.

Die Minimierung der Image-Größe ist somit von entscheidender Bedeutung, um einen schnellen Build-Prozess zu gewährleisten, die Kosten in Container-Registries zu senken und die Sicherheit von Anwendungen zu verbessern. Im nächsten Abschnitt werden wir uns genauer mit der Verwendung von Alpine-Images befassen, um die Container-Größe weiter zu reduzieren.

Wie kann ich die Größe meiner Docker-Container reduzieren?

Verwendung von optimierten base images (Alpine-Images)

Alpine ist eine leichtgewichtige Linux-Distribution, die nur die erforderlichen Pakete enthält. Durch die Verwendung von Alpine-Images können wir die Containergröße erheblich reduzieren, was zu schnelleren Build-Zeiten führt. Gleichzeitig gewährleisten wir die Sicherheit, da Alpine regelmäßig Sicherheitsupdates erhält.

Minimierung von Abhängigkeiten

Jede im Container enthaltene Bibliothek oder Anwendung erhöht die Image-Größe. Daher sollten wir unnötige Abhängigkeiten entfernen und nur diejenigen Komponenten einbinden, die für den reibungslosen Betrieb der Anwendung erforderlich sind. 

Multi-Stage-Builds

Durch die Verwendung von Multi-Stage-Builds können wir den Platzbedarf in den finalen Produktions-Images reduzieren. In den ersten Stufen können wir beispielsweise eine leichtgewichtige Build-Umgebung nutzen und nur die erforderlichen Artefakte in die finalen Images überführen.

Effiziente Verwendung von Images für verschiedene Umgebungen

Warum images wiederverwenden statt neu bauen?

Die Verwendung von Images für verschiedene Umgebungen bietet zahlreiche Vorteile, um die Bereitstellung von Anwendungen zu optimieren und einen konsistenten Code über alle Umgebungen hinweg zu gewährleisten. Hier sind die Vorteile dieser Vorgehensweise:

Schnellere Bereitstellung in der Produktion

Anstatt für jede Umgebung separate Images zu erstellen, können wir dasselbe Image in allen Umgebungen verwenden. Dadurch verkürzt sich die Bereitstellungszeit erheblich, da der Build-Prozess nicht erneut durchlaufen werden muss. Wir können Updates und neue Funktionen schneller in die Produktion bringen und somit den Time-to-Market verbessern.

Einfache Rollbacks

Durch die Verwendung derselben Images in allen Umgebungen wird sichergestellt, dass wir bei Bedarf schnell zu einer früheren Version zurückkehren können. Im Falle eines Fehlers oder einer unerwarteten Problematik können wir problemlos zu einer stabilen Version zurückkehren, ohne die Notwendigkeit eines erneuten Builds oder einer erneuten Bereitstellung.

Konsistenter Code

Die Verwendung desselben Images in allen Umgebungen gewährleistet, dass der Code überall konsistent ist. Dadurch minimieren wir das Risiko von Umgebungsfehlern oder unvorhergesehenen Verhaltensweisen in spezifischen Umgebungen. Die gleiche Codebasis wird sowohl in Entwicklungs- als auch in Test- und Produktionsumgebungen verwendet, was zu einer zuverlässigeren und vorhersehbareren Anwendung führt.

Um diese Vorteile zu realisieren, gibt es jedoch einige wichtige Voraussetzungen zu beachten:

Container images wiederverwenden: wie?

Keine ENVs im Image

Statt Umgebungsvariablen direkt im Image zu speichern, sollten wir externe Konfigurationsmechanismen nutzen. Dadurch bleibt das Image unabhängig von der Umgebung und kann flexibler eingesetzt werden. Umgebungsvariablen können zur Laufzeit injiziert werden, was die Portabilität und Skalierbarkeit unserer Anwendungen verbessert.

Verwendung des Trunk-Based-Branching-Modells

Das Trunk-Based-Branching-Modell, im Gegensatz zum Git Flow-Modell, ist eine Voraussetzung, um Images effizient für verschiedene Umgebungen zu nutzen. Beim Trunk-Based-Branching wird der Hauptentwicklungszweig als stabil angesehen, und alle Änderungen werden direkt darauf aufgespielt. Dies ermöglicht eine schnellere Bereitstellung und gewährleistet, dass der gleiche Code in allen Umgebungen verwendet wird.

Zusammenfassung

Die effiziente Wiederverwendung von Container-Images ermöglicht es uns, mit nur einem einzigen Image-Build den gesamten Entwicklungsprozess von der Pull Request (PR) bis zur Bereitstellung in der Produktionsumgebung abzudecken. Hier ist ein Überblick über die Schritte, die wir durchlaufen:

Pull Request (PR)

Sobald ein Entwickler seine Änderungen abgeschlossen hat, erstellt er eine PR, um diese in den Hauptentwicklungszweig (main) zu integrieren. Während der Code-Überprüfung wird der Code getestet und überprüft, um sicherzustellen, dass er den Qualitätsstandards entspricht.

Merge to main

Nach erfolgreicher Überprüfung wird der Code in den Hauptentwicklungszweig (main) gemerged. Zu diesem Zeitpunkt wird auch ein neues Container-Image erstellt, das den aktuellen Stand des Codes und der Abhängigkeiten enthält. Der commit hash bietet sich als image tag an, um den später genau zu wissen welche Code Version im image enthalten ist.

Staging Deployment (UAT)

Das Image, das aus dem Merge erstellt wurde, wird in der Staging-Umgebung bereitgestellt. Hier erfolgen Tests und Benutzerakzeptanztests (User Acceptance Tests, UAT). Durch die Verwendung desselben Images wie in der Produktionsumgebung gewährleisten wir, dass die Tests in einer Umgebung stattfinden, die der Produktionsumgebung so nahe wie möglich kommt. Das Staging Deployment kann automatisch mit jedem Merge to main ausgeführt werden.

Production Deployment

Nach erfolgreichem UAT wird das gleiche Image in die Produktionsumgebung bereitgestellt. Da wir dasselbe Image verwenden, das bereits in der Staging-Umgebung getestet wurde, wird sichergestellt, dass der gleiche Code in der Produktion verwendet wird. Dadurch minimieren wir potenzielle Probleme durch Unterschiede zwischen Umgebungen. Dieser Schritt braucht jetzt nur noch wenige Sekunden, da wir ja nur unseren image tag updaten müssen und unser kleines Image auch besonders schnell geladen werden kann.

Die CI/CD pipeline kann natürlich beliebig erweitert werden, um e2e-tests oder canary deployments abzubilden. In einem perfekten Setup könnte der code vollautomatisch bis zu production deployed werden. Das erfordert allerdings sehr gute e2e Tests und automatisierte Rollbacks bzw. ein zuverlässiges Canary Deployment System.