Warum ist die Build-Größe so wichtig?

Ich höre oft (von Leuten, aber auch von informativen CLIs), dass die "Build / Slug-Größe groß ist". Dies gilt insbesondere dann, wenn der Build eine Größe von 0,5 bis 2 GB hat

Warum (oder unter welchen Umständen) ist die Build-Größe so ein Problem?

Hinweis: Der Grund, den ich frage, ist, dass ich Ressourcen wie Speicher und Computing im Vergleich zu früher als relativ billig betrachte. Wenn überhaupt, würde ich erwarten, dass die Build-Größe jetzt weniger ein Problem darstellt als in der Vergangenheit

Wenn ich das Problem der Build-Größe als Problem anspreche, kommt es normalerweise nicht von "es ist so groß, dass es teuer ist, es zu speichern".

Die Hauptprobleme bei großen Builds sind die folgenden:

• erhöhte Lieferzeit. Das häufige Verschieben großer Teile von Ort zu Ort ist zeitaufwändig.
• Häufige Änderungen an großen Artefakten sowie eine lange Aufbewahrungsdauer machen das Speichern solcher Artefakte kostspieliger, weniger bei geschichteten Artefakten wie Docker-Bildern.
• Das Erstellen derart großer Artefakte ist normalerweise zeitaufwändig, mehr als das Erstellen viel kleinerer Artefakte. Die Automatisierung des Prozesses zur Erstellung kleinerer Artefakte kann einige Zeit in Anspruch nehmen. Die wiederholbare Automatisierung sollte jedoch so kurz wie möglich sein, um eine schnelle Rückmeldung zu ermöglichen.
• Die Wiederherstellung nach einem Fehler (abhängig von der Konfiguration) kann bei größeren Artefakten länger dauern, insbesondere wenn ein älteres Artefakt anstelle eines fehlerhaften neuen erneut angewendet werden muss.

Ich abonniere die vier Devops-Metriken:

• Vorlaufzeit für Änderungen - verkürzen Sie diese
• Bereitstellungshäufigkeit - Erhöhen Sie die Häufigkeit
• Zeit, den Dienst wiederherzustellen - verkürzen Sie ihn
• Ausfallrate ändern - auf nie reduzieren

Große Artefakte verursachen normalerweise ein Problem in jeder dieser Metriken, und keine dieser Metriken befasst sich wirklich mit den Speicherkosten - denn das ist billig, Zeit ist teuer.

Ergänzen Sie Evgenys Antwort mit einigen weiteren Beispielen.

Was Sie unter Build-Größe verstehen, kann eine Rolle spielen:

• Wenn es sich um die Größe der zu erstellenden Artefakte handelt (jedes einzeln oder in ihrer kombinierten Größe), kann dies beim Speichern oder Verwenden / Bereitstellen von Artefakten von Bedeutung sein, wenn diese Vorgänge Größenbeschränkungen aufweisen und diese überschritten werden. Für Google App Engine-Apps gelten beispielsweise solche Bereitstellungsbeschränkungen . Wenn erreichte Bereitstellungen fehlschlagen, lesen Sie Fehler bei der Bereitstellung in Google App Engine .

• Wenn es sich um die Größe des Arbeitsbereichs handelt, in dem Sie den Build ausführen, kann dies aus Sicht der Arbeitsbereichsverwaltung von Bedeutung sein. Sogar 2G kann von Bedeutung sein - zum Beispiel, wenn Sie ein RAM-Dateisystem auf einem Computer mit wenig RAM einbauen. Einige Builds könnten jedoch viel größer sein - ich musste mich mit Arbeitsbereichen von über 500 G befassen (als die meisten meiner Server-Festplatten unter 1 TB lagen).

Wenn der Build Teil Ihrer CI / CD-Pipeline ist, ist die Ausführungszeit der Pipeline umso länger, je größer der Build ist (Durchführung des eigentlichen Builds und ggf. Archivierung, Bereitstellung zum Testen, Analyse im Fehlerfall, Bereinigung). usw.) - Je langsamer / riskanter / kostspieliger Ihre Gesamtentwicklung sein mag.

Wenn Sie ein hartes Limit erreichen, müssen Sie kreativ werden, um es zu umgehen (nicht immer einfach / möglich). Wenn es sich nur um einen Leistungs- / Kosteneinbruch handelt, haben Sie auch die Möglichkeit, ihn zu akzeptieren und damit zu leben und / oder ihn teilweise / schrittweise anzugehen.

Es kann sich lohnen, zu unterscheiden zwischen:

• Aufgeblähte Builds - wenn die Größe unnötig erhöht wird - ist das Beheben des Problems normalerweise möglich, indem unnötige Teile fallen gelassen werden
• In den Fällen, in denen der Inhalt des Builds selbst wirklich benötigt wird - die Größe spielt keine Rolle -, wird er benötigt. Die einzige Möglichkeit, dies zu beheben, besteht möglicherweise darin, einige Funktionen zu opfern

Ich werde ein sehr konkretes Problem hinzufügen, auf das wir tatsächlich stoßen. Es ist ein Nebeneffekt der schlechten Architektur, unter dem wir derzeit leiden:

Da unser Build groß ist und wir viele Abhängigkeiten laden müssen, dauert es sehr lange, alles einfach zusammenzusetzen. Wir hätten den Aufbau längst in zahlreiche kleine Builds aufteilen sollen, um eine Microservice-Architektur anstelle eines großen Monolithen zu entwickeln.

Das Ausführen aller Tests für den Monolithen dauert etwa 45 Minuten und blockiert vorerst unsere CI-Umgebung.

Da es so lastintensiv ist und so lange dauert, ist es derzeit unmöglich, mehrere Builds parallel zueinander auszuführen.

Wie die Poster vor mir bereits auf einer theoretischeren Ebene dargelegt haben, sollte dies einige potenzielle (und wahrscheinliche) Nebeneffekte aufzeigen, die ein großer Build normalerweise hat, wenn er nicht mehr Platz auf der Festplatte benötigt.