Ja, hallo liebe Hörerinnen und Hörer. Willkommen beim Python-Podcast Episode 52.
Heute reden wir über Kubernetes. Hallo Johannes.
Hallo zusammen.
Hallo Dominik.
Hallo Jonas.
Ja, schön, dass du wieder da bist, Johannes.
Ja, schön, dass ich wieder da sein darf.
Sogar vor Ort.
Und wir haben uns heute Kubernetes ausgedacht, obwohl das gar nicht so viel mit Python zu tun hat,
weil wir das, glaube ich, alle so ein bisschen öfter nutzen müssen, wollen.
Müssen wir.
Manche von uns müssen.
Ja, ich musste auch schon.
Genau.
Und deswegen wollen wir vielleicht so ein bisschen erklären, was das ist, was das so macht und was das so tut.
Vielleicht fangen wir wie immer ein bisschen an mit den News.
Da haben wir ja noch so ein paar offen, glaube ich.
Ja, aber ich habe mich jetzt auch nur so ein bisschen...
Also es gibt eine große News und die kleineren, da verlasse ich mich dann um das andere, das Wissen.
Okay, aber ich mache jetzt einfach mal den News-Chapter.
Fangen wir doch einfach mit dem normalen Python 3.12-News an, weil wir haben Oktober und ich glaube, da ist immer ein neues Python.
Ja, es ist jetzt immer einmal im Jahr irgendwie neue Releases.
Neue Release.
Seit drei Tagen, oder?
Ich weiß gar nicht genau, wann das released wurde, aber ja, noch nicht so lange.
Je nachdem, wann dieser Podcast gehört wird.
Ja.
Genau.
Also für uns ist es noch frisch, für euch dann vielleicht so, was, das war doch...
Das war doch zehn Jahre her.
Ja.
Genau.
Und ja, also...
Was gibt es denn da Neues?
Verwendet ihr es schon?
Nein.
Nein?
Nicht runtergeladen.
Habt nur die News gesehen.
Also ich habe gesehen, dass du Probleme hattest, das auf deinem Mac zu installieren.
Ja, aber...
Also genau, dann bist du ja schon...
Nein, bei mir läuft es, aber ich habe mir angewöhnt, bei eins erst mal alle Projekte umzuziehen, aber es ist jetzt nicht das Feature dabei, wo ich sage, das brauche ich jetzt unbedingt sofort.
Ja, das war auch so ein bisschen mein Eindruck.
Das liest sich alles sehr gut, aber es ist nicht so, dass ich sagen würde, ja, das will ich jetzt sofort benutzen.
Weil es ist ja nicht so richtig so was dabei, was man so richtig benutzen kann, oder?
Ja, kein neues Walrus oder kein Matchcase.
Habt ihr den Match schon mal verwendet?
Ja.
Ja, okay.
Häufig, ja.
Ich finde es cool, aber ich habe noch nichts damit gemacht.
So Pattern-Matching, habe ich gehört, geht damit ganz gut.
So Typing oder Type-Matching, also dann kannst du so Guards bauen und dann kann man halt gucken, ob irgendwie so ein Objekt, das reingegangen ist, auf irgendein Pidentic-Model validiert oder halt nicht.
Und kannst das dann halt direkt weiter nutzen.
Das ist nett.
Ja, wie gesagt, ich finde das total super, aber ich habe einfach irgendwie noch nicht genug damit gemacht.
Wo wir über Pidentic reden, ich glaube, Pidentic 2 hatten wir auch noch nicht in den News, weil wir ewig lang nichts gemacht hatten.
Doch, doch, hatten wir jetzt mal, genau.
Okay.
Aber auch nur, also nur, dass ich damit Probleme hatte, das abzudaten.
Ich habe in der Zwischenzeit ein weiteres meiner Projekte irgendwie updaten müssen, weil jemand auf GitHub ein Issue aufgemacht hat und gesagt hat, ich habe das jetzt gerade mal probiert, es gibt mir diese komische Pidentic-Fehlermeldung, weiß gar nicht, was das ist.
Ja, und genau, so habe ich das dann auch gemerkt, dass das nicht mehr funktioniert.
Und das habe ich jetzt auch umgezogen und es war auch deutlich mehr Arbeit, als ich gedacht hätte.
Und also, ich habe jetzt zwei Projekte umgezogen auf die neue Pidentic-Version und das war beide Male ätzend.
Also, ja, man braucht da schon so ein bisschen Muße, wenn man das irgendwie machen will.
Oder bei mir, ich habe vielleicht das auch einfach falsch gemacht am Anfang und deswegen habe ich da besonders viel Arbeit, aber.
Ganz wahrscheinlich, höchstwahrscheinlich.
Ja, aber gut, jetzt inzwischen habe ich ein bisschen Übung, dann kann ich ganz andere Sachen auch noch umstellen, das ist dann kein Problem mehr hoffentlich.
Wenn du 3.12 benutzt hättest, hättest du vielleicht schon viel bessere Fehlermeldungen bekommen, direkt gesehen, woran es liegt.
Könnte sein, aber ich finde zum Beispiel auch die Pidentic-Fehlermeldung nicht so richtig hilfreich.
Also zum Beispiel die, diese Field Missing-Fehlermeldung, die finde ich ist echt, ich weiß nicht, ob die schon immer so war oder ob die jetzt erst so geworden ist.
Aber die ist halt, genau, das ist hier, ich zeige es dir jetzt mal auf dem Monitor, kann sonst keiner sehen außer uns.
Aber da steht halt irgendwie so, also da steht noch mehr, da ist eine ganze Liste von irgendwie Field Required, Type Missing, Input Value.
Jochen, noch nicht mal, ich kann das lesen vom Sofa aus, was du da auf deinem Rechner machst.
Okay, ist zu klein, ich mache noch ein bisschen größer.
Ja, ich wollte gerade sagen.
So, und dann, wenn man diesen Traceback kriegt, der eigentlich relativ lang ist, sodass man Schwierigkeiten hat, den relevanten Teil zu erfassen.
Ich habe jetzt das hier extra so rausgekattet, dass man es sehen kann.
Aber dann ist das, was ich halt lese, vor allen Dingen das hier.
Da steht dann halt irgendwie Type Missing, Input Value, Database URL und dann komme ich halt, ah, Database URL ist missing.
Das stimmt aber nicht.
Nein, die ist zwar da.
Sondern die ist da.
Aber die Value ist falsch.
DB Engine ist halt missing, was da drüber steht, wo man denkt, das gehört hier noch zu einem anderen Teil.
Was hier gar nicht drinsteht.
Das heißt, dieser Kram, der danach kommt, ist eigentlich völlig irrelevant.
Aber das ist halt, also ich meine, klar, also wenn man jetzt weiß, okay, ach, das Ding hier ist missing.
Okay, dann ist klar.
Aber man überliest es leicht.
Also so wie das bei dir aussieht, könnte auch in der Formatierung, wahrscheinlich hast du es absichtlich so formatiert, dass es in deinem Eintrag so aussieht.
Nein, nein, das sieht wirklich so aus.
Das sieht tatsächlich etwas schräg aus.
Also, die Fehlermeldung ist ein bisschen verhackstöckelt.
Hast du das mal mit 3.12 probiert?
Nein.
War das nicht die 3.12?
Okay, du hattest vorher schon das Problem beim Umziehen.
Ja, ja, ja, also die...
Pydentic ist ja schon eine neue Version seit einigen Monaten.
Vielleicht, aber wäre es anders, wenn 3.12 dabei geholfen hätte noch.
Ist das anders in 3.12, weil das ist doch eine Fehlermeldung von Pydentic.
Ja, ja, genau, genau.
Nee, wahrscheinlich hätte das...
Aber durch diese, ich weiß nicht, ob die verbesserten Fehlermeldungen in 3.12 auch was damit zu tun haben, wie dieser ganze...
Wie dieser Traceback-String gerendert wird.
Genau, weil da sind ja auch verschiedene andere Sachen passiert, die dieses Rendern beeinflussen, weil die F-Strings ja beispielsweise sind auch neu.
Ja, ja, ja, kommen wir gleich noch zu.
Also auf jeden Fall dieses Pydentic-Ding, das hat mich jetzt schon zum zweiten Mal...
Wenn ich das nächste Mal sage, beim dritten Mal, hat es auch wieder Schwierigkeiten gemacht.
Da fliegt es raus, dann liegt es an dir.
Ja, das kann auch sein.
Genau, das ist die Konstante an diesem Experiment.
Ja, genau.
Ja, also genau.
Also jetzt waren wir schon bei den 3.12 Änderungen.
Genau, bessere Fehlermeldungen.
Also das Einzige, was ich mir davon gemerkt habe, also es gibt ein paar Dinge, die da geändert wurden, aber die einzige, die ich mir gemerkt habe,
weil sie mich an die...
an die Pi-Pi-Episode erinnert hat, war, dass jetzt, wenn man irgendwie eine Variable verwendet und die nicht definiert ist sozusagen in einer Methode,
dann sagt einem jetzt der Traceback so, sag mal, kann es sein, dass du Self-Dot irgendwie vorher vergessen hast?
Ja.
Und Pi-Pi konnte das halt schon einige Zeit, und ich glaube, das ist halt, das haben sie sich dann von Pi-Pi abgeguckt, diese Geschichte.
Und es gibt halt noch so ein paar andere Dinge, ich weiß gar nicht genau, wisst ihr das?
An der richtigen Stelle.
Ja, genau, solche Sachen. Also da ist noch ein bisschen was passiert.
Ich weiß es nicht, weil ich sehe nie Fehlermeldungen.
Du machst einfach, kennt ihr das Modul, als wollt ihr eigentlich mal so einen Pick, ne?
Fuck it, du machst einfach Pippen-Style, fuck it, und dann schreibst du einfach add fuck it oben drüber oder whiz fuck it und dann gibt es keine Fehlermeldungen mehr, sind weg.
Ja, dann eine andere Geschichte, etwas, also F-Strings haben irgendwie ordentliche Überarbeitung erfahren.
Ja, genau, davon musste man ziemlich viel umbauen.
Ja, also das mutet so ein wenig nach Detail an, dass man jetzt sagt, okay, du kannst jetzt auch Quotes innerhalb von F-Strings haben.
Genau, zwar dieselben Quotes wie der String eigentlich.
Genau, das hat mir tatsächlich aufgefallen schon, dass man da nicht die gleichen Quotes verwendet.
Genau, und das beschränkt natürlich die Tiefe, in der du F-Strings vernesten kannst, also ineinander schachteln kannst, halt auf die Anzahl unterschiedlicher Arten zu quoten.
Wie tief würdet ihr denn empfehlen, so F-Strings ineinander zu quoten?
Aber was zum Beispiel echt nervt.
Wichtig war, dass du zum Beispiel in Multiline-F-Strings keine Kommentare hinter so einen F-String machen mehr konntest.
Ja, und Multiline-F-Strings gehen natürlich schon, wenn du das halt so machst, wie man das mit Multiline-Strings halt so macht, aber was jetzt auch zusätzlich geht, ist, dass du quasi New-Lines in F-Strings haben kannst.
Das geht nämlich jetzt auch, das ging vorher auch nicht.
Genau, Backslash war vorher auch gebannt.
Genau, geht jetzt auch.
Also das wirkt so ein bisschen wie Details, aber nein, das ist, dafür haben sie den Tokensatz.
Organizer komplett neu geschrieben.
Der ist jetzt rein in C implementiert und ist halt auch ein gutes Stück schneller, ist irgendwie 60% schneller als vorher und ja, das hat jetzt zur Folge, dass man F-Strings halt auch beliebig nesten kann und ja, all diese anderen Details jetzt auch gehen.
Zeit, dass zum Beispiel Logging oder sowas mal umsteigt und auch mal F-Strings verwendet.
Ja, da habe ich schon unterschiedliche Meinungen darüber gehört.
Ja, also genau. Also ich auch, aber ich verstehe es noch nicht so genau.
Also meine Meinung macht das Logging nicht, weil das nicht evaluiert wird.
Ja, das, also der Haupteinwand, den ich da gehört habe, der kommt von Sentry und Sentry macht ja Log Aggregation oder Error Log Aggregation und wenn du jetzt quasi eine Fehlermeldung loggst und da deine Fehlerobjekte mit reinschreibst, dann ist das ja ein anderer String bei jeder dieser Fehlermeldungen.
Das heißt, du kriegst keine Aggregation.
Wenn du aber normale Template Strings.
benutzt, dann schickst du ja den Template String und die Argumente, die da reinkommen.
Das heißt, du kriegst dann eine Aggregation anhand des Template Strings und kriegst dann innerhalb dieser aggregierten Sache gesagt, hier sind, die sind mit folgenden Attributen aufgetreten, X, Y und Z.
Ja, okay, aber man könnte ja auch erst irgendwie Sentry erklären, dass sie das bitte anders aggregieren sollen und das da wieder rauspopeln soll.
Ah gut, aber dann bist du jetzt schon wieder so bei Sprachsachen, dass du sagst, ja, da musst du doch ausfinden, wo die F-Attribute drin waren.
Das ist eh einigermaßen furchtbar mit Camel Case und sowas, das ist alles eh bäh, bäh.
Ja, das mag ja schon sein, aber gerade diese F-Strings, die zerstören halt, dass du siehst, wo da die Templates stehen.
Okay, also das einzige valide Argument, was ich gehört habe halt, ist, dass halt je nach Log Level die gar nicht evaluiert werden sollen und dass, wenn du das halt als F-String da reinschreiben würdest, dann würdest du halt jedes Mal immer.
Ja, jedes Mal.
Ja, keine Ahnung.
Ja, gut, okay, also Geschmacksfragen.
Ich weiß es nicht.
Ja, genau.
Ach so, was auch.
Wofür?
Ich glaube, das ist jetzt auch eine doofe Idee, es gibt ja für, das hatte auch der, na, wie heißt er noch, Thomas Güttler, der hier war, wegen HTMLX immer gesagt, also es gibt ja in Python, gibt es also nicht sowas wie Template Literal Strings in JavaScript oder so, wo man halt Partials da relativ gut handeln kann und das geht halt mit F-Strings nicht so richtig und das geht jetzt vielleicht schon.
Also das könnte man eventuell, naja, auch nur bei einfachen Template Ersetzungen wahrscheinlich.
Ob das Sinn macht.
Weiß ich auch nicht.
Du hast irgendwas von Partials gerade gesagt?
Django Template Partials, damit geht das halt auch ganz gut eigentlich.
Das sind, genau, das sind aber jetzt so ein paar Module, die waren in einer der letzten Folgen von, weiß ich mehr was, DjangoCast oder was?
Django Chat meinst du, den Podcast, ja, das war da auch drin, ja.
Ja, genau, da war irgendwie eine nette Folge, wo die Leute genau diese Templating Sachen, Partials mitgebrucht haben, die waren schön, weil man kann man schöne Sachen mit einzelnen Templates machen, die sonst so nicht einfach so modular.
Ja, ich hab das.
Ich hab das jetzt auch schon ein paar Mal verwendet und das ist echt tatsächlich ziemlich gut.
Kommt wahrscheinlich auch in Django 5.1 mit rein, ja.
Ah, ja, schön.
Genau, dann, es gab so ein paar Performance-Geschichten, genau, bei F-Strings, die sind ein bisschen schneller geworden.
Es gibt jetzt irgendwie Comprehension Inlining.
Und was ist das?
Ehrlich gesagt, was es genau macht, weiß ich nicht, aber List Set Comprehensions werden jetzt ungefähr zweimal schneller.
Das nimmt man doch mit, oder?
Ja, das ist gut.
Gut, ja.
Und dann natürlich die GIL-Aufteilung.
Das habe ich mit Interesse gelesen.
Ja, das ist ein sehr interessanter...
Erklär doch mal, Jonas, was ist denn die GIL-Aufteilung?
Ja, es gibt ja das globale Interpreter-Log.
Das ist ein großes Log und das sorgt dafür, dass Python sehr schlecht ist bei Multithread-Anwendungen, weil immer nur ein Thread Python-Code ausführen kann.
Und das ist natürlich so ein bisschen bescheuert, weil dann bringt es ja nichts mehr.
Doch, doch, das bringt ja durchaus schon was.
Ja, es kommt darauf an, wie deine Threads sind.
Aber wenn du lauter Python-Threads laufen hast, also du kannst nicht mehr als eine CPU verwenden.
Nee, genau, nicht mehr als eine CPU, aber du kannst schon, wenn du mehrere Threads machst, machst du halt viel mehr I.O. möglicherweise.
Genau, für I.O. bringt es was, aber nicht für Compute, also nicht für CPU.
Ist aber das Argument, warum Python so einen GIL hat, ist halt, dass das für den Single-Threaded-Case einfach die beste Lösung ist.
Ja, weil du keine komplizierten Logs einbauen musst, weil es einfach schnell ist, weil du gar nichts hast.
Weil du halt nicht gucken musst, ist das irgendwie ein Log, muss das frei werden?
Genau.
Wie ist denn das?
Genau, ist einfach ein Interpreter und fertig.
Und es gibt ja schon lange Bestrebungen und viele Bestrebungen, diesen GIL loszuwerden, zum Beispiel PyPy oder auch Unladen Swallow, falls ihr euch da noch dran erinnert.
Die haben versucht, das loszuwerden.
Bitte was? Bitte wer?
Das war so eine Initiative, ich glaube, von Google, von Google-Angestellten, die versucht haben, eben den Python-Interpreter neu zu schreiben, ohne das Global Interpreter-Log.
Und es kommt alle paar Jahre wieder, weil es einfach ein großes Ärgernis ist, dass der Multi-Threaded-Programm mal schreibt.
Aber trotzdem nicht mehr CPU kriegst.
Genau, Unladen Swallow, weil sie schneller fliegen kann.
Und jetzt wandert es auch so langsam, beziehungsweise es ist ja schon lange unterwegs, dass man das schneller macht und den GIL so ein bisschen wegbekommt.
Und da gab es jetzt eben diese eine Bewegung, dass es keinen globalen, kein globales Global Interpreter-Log mehr gibt, sondern eben eins für Sub-Interpreter.
Das heißt, die Python...
Die Python-Runtime, der CPython, die CPython-VM kann jetzt Sub-Interpreter starten, die dann ihr eigenes Global Interpreter-Log haben.
Aber ich weiß nicht, wie man da dran kommt, Jochen, weißt du, wie man das macht?
Ja, über die, also momentan nur in C-Code kann man das halt, kann man halt sich halt einen neuen Interpreter erzeugen und da irgendwelche Dinge mitmachen.
In 3.13 soll es dann eine API geben, die halt auch innerhalb von Python-Code verfügbar ist, wo man dann einfach sagt, hallo, mach mir mal einen neuen Interpreter und dem gibt man dann einen String.
Und dieser String wird dann...
Als Python-Code da drin ausgewertet.
Ah, okay.
Da kann man sich dann natürlich auch irgendwie hübschere Abstraktionen noch drum rum bauen, keine Ahnung.
Ja, also ich meine, ich finde das auch so ein bisschen so ein spezielles...
Also das mag schon Anwendungsfälle geben, wo das sinnvoll ist, aber ich meine, das wird schon sehr speziell, weil ich meine, für viele Sachen, wo man so was, wo man denken würde, oh, das kann ich gut brauchen, warum macht man dann nicht einfach einen zweiten Prozess auf?
Also kann man ja auch machen.
Einen zweiten Interpreter und dann muss man halt schon...
Hast du halt dann diese Prozessgrenze.
Ja, hast du halt, dass die Kommunikation langsam wird.
Musst du halt irgendwie...
Entweder die Daten von einem Prozess zum anderen übergeben und in vielen Fällen, denke ich, ist das wahrscheinlich kein so großes Problem, weil...
Wie macht man das denn am besten?
Ja, ja, also es kommt halt kein Hängherd von den Daten ab.
Hast du halt Queues oder irgendwelches?
Ja, aber du gibst, also oft übergibst du halt einfach nur eine URL zu einem Bucket oder sowas.
Ja, das kommt natürlich auf den Anwendungsfall an.
Genau.
Also ich meine, da gibt es auch Anwendungsfälle, wo du...
Wenn man viele Daten übergeben muss...
Viel Kommunikation und viel Compute.
Dann ist schlecht.
Dann muss ich die immer serialisieren oder muss ich den irgendwie in den Speicher irgendwo reinschreiben oder irgendwie...
Genau, du kannst natürlich per Pickel einfach serialisieren oder irgendwie übergeben oder über den Pipe schicken oder sowas.
Also auch ein Standardweg, wie man das macht, ist dann halt einfach Shared Memory verwenden, sodass halt alle Prozesse, die man erzeugt, halt auf den gleichen Speicher zugreifen.
Das geht auch.
Wie geht denn das mit Preisen?
Aber dann hast du ja wieder das Locking-Problem.
Als Elevator?
Naja, solange du nur liest, ist es kein Problem.
Ja, solange du nur liest, ist das nie ein Problem.
Aber nur lesen hilft ja.
Du kannst ja immer so vielleicht sonst neue Keys schreiben.
Vielleicht geht das gleichzeitig oder geht das nicht auf einen Dick gleichzeitig neue Keys schreiben?
Nee, das ist nicht das Problem.
Das geht halt alles nicht.
Das geht alles nicht.
Also oft lässt sich das schon darauf abbilden, dass man sagt, man liest das halt und dann macht man irgendeine Berechnung und dann hast du ein Ergebnis von der Berechnung und das führt man halt wieder zusammen.
So quasi so ein Map-Reduce-Schritt, wo du das halt viele Wörter rausmapst.
Das könntest du ja tatsächlich jetzt schon machen, oder?
Das kannst du auch jetzt schon machen, gar kein Problem.
Multi-Processing.
Genau, und das für viele Anwendungsfälle, denke ich, ist es wahrscheinlich genau das Richtige, was man machen sollte.
Und dann gibt es vielleicht so ein paar, bei denen geht das aus irgendwelchen Gründen nicht so gut und dann macht das mit den Sub-Interpretern.
Aber du machst irgendwie so ein Map-Reduce-Ding, um die Computation auseinanderzudröseln und dann zusammenzuführen und wo schreibst du dann wieder was rein und wenn du sagst, du...
Ja, du kriegst es halt wieder zurück.
Und dann je nachdem, wie groß das ist, was du zurückbekommst von der Berechnung, kannst du es halt einfach auch wieder irgendwie serialisieren und in deinem Master-Prozess sozusagen wieder deserialisieren.
Und wenn das zu groß wird, dann schreibst du das halt in den Prozess.
Und von wo derealisiert du das denn?
Also von dem Shared Memory oder was sagst du mit der Pipe, was meinst du damit?
Nein, es geht ja nur darum, dass du in diesem Modell, was der Jochen vorstellt, nur zwei Synchronisationspunkte hast.
Nämlich ganz am Anfang, wenn du es verteilst und ganz am Ende, wenn du es zusammenbringst.
Und das bedeutet, dass es nicht so wichtig ist, wie schnell die Kommunikation ist, weil du die nicht die ganze Zeit verwendest, sondern du verwendest die nur einmal en bloc.
Genau.
Wenn du jetzt aber so ein System hast, wo du zwölf Threads hast, die alle zehn Millisekunden miteinander kommunizieren, die irgendeine Nachricht schicken oder die Queues schicken, sowas wie das Actor-Modell.
Wenn du in Erlang sagst, jede Funktion ist ein Thread und du schickst jedes Mal bei jedem...
Im Funktionsaufruf schickst du eine Message rüber.
Dann geht das nicht mehr, weil du dann eben über diese Prozessgrenze irgendwas haben musst, was innerhalb des Betriebssystems über die Prozessgrenze drüber geht und das ist üblicherweise langsam.
Egal, welche Technik du verwendest, ob es Pipes sind oder Shared Memory oder was weiß ich.
Es ist egal, es geht gar nicht anders, weil du hast ja automatisch irgendwie Kontext-Switches dabei, wo es halt langsam wird.
Aber die Frage ist halt, passiert das in der Praxis häufig?
Weil ich würde sagen, du hast üblicherweise einen von beiden Fällen, du hast halt entweder den Fall, du musst halt viel...
...I.O. machen, aber du brauchst eigentlich keine CPU.
Also wenn du jetzt sowas hast wie eben so eine Web-Anwendung oder irgendwie eine Anwendung, die irgendwie so, weiß ich nicht, selbst sowas wie ein irgendwie massiv paralleler Chat-Server oder sowas.
Der rechnet ja nichts aus, also der schiebt ja nur irgendwie Bits und Bytes hin und her.
Da brauchst du die mehreren CPUs eigentlich nicht.
Oder du kannst halt dann mehrere Prozesse starten, die dann halt alle, auf die du dann Load-Balanced, die dann halt alle auf einer CPU hocken, aber die sich nicht miteinander unterhalten müssen.
Oder du hast halt den Fall, wo du Number-Crunching machen willst.
Aber da brauchst du dann eigentlich diese Kommunikation nicht mehr.
Das heißt, Number-Crunching meinst du, du lässt dann doch auf jedem Kern irgendwie einen Python-Prozess laufen und...
Du willst halt ein Array von einem Petabyte irgendwie Zahlen sortieren oder sowas.
Klassische Anwendung.
Ja, ich weiß, das ist immer das, womit man dann demonstriert irgendwie, dass man irgendwas parallelisieren kann oder so.
Ja, aber dafür brauchst du normalerweise keine Kommunikation zwischen den Dingern.
Und ja, also dass man den Fall hat.
Dass man gleichzeitig Kommunikation viel hat und gleichzeitig irgendwie ganz viel Prozessor braucht.
Also, der ist aus meiner Perspektive schon ein ziemlicher Nischen-Anwendungsfall.
Ich meine, das wäre natürlich schön, wenn das einfach so gehen würde, aber...
Vielleicht, weil es nicht geht, Jochen.
Ja, vielleicht auch, weil es nicht geht.
Wenn es einfacher gehen würde, würden wir das alle machen.
Ja, vielleicht.
Ich weiß es nicht.
Ja gut, auf jeden Fall gibt es Bestrebungen in die Richtung und das ist doch schön.
Genau.
Also, wie heißt das jetzt nochmal bei 312, du hast gesagt, Teil-Gil?
Also, Sub-Interpreter.
Ja, genau, der Sub-Interpreter macht dann mal seinen eigenen Gil.
Sub-Interpreter.
Dann, was haben wir denn noch?
Ja, es gibt jetzt so ein paar Typing-Verbesserungen.
Also, ich finde das ehrlich gesagt, da sagen immer alle Leute so, ah, das ist so toll, weil jetzt geht das noch einfacher als vorher.
Und ich denke mir so, wie bitte, das war vorher einfach?
Also, mit dem Type war Type alias.
Jetzt geht es noch einfacher.
Ja, also, wenn man sich da anguckt, wie die Signaturen von Funktionen aussehen, das sieht schon, also du definierst hier zuerst so ein, mit Type war irgendwie den Namen für einen generischen Type und dann setzt du den noch irgendwie da ein und dann, also es ist schon, also du hast auf jeden Fall ganz viele Klammern und ganz viele Doppelpunkte und komische Dinge.
Ich muss auch sagen, ich habe den Fehler gemacht, ich habe jetzt meinen Editor umgestellt auf die neue Linting-Variante mit komplett MyPi auch drin und so.
Also, normalerweise habe ich das immer nur beim Committen drüber laufen lassen, aber jetzt, es ist so ein bisschen nervig.
Ja, sozusagen, verwendest du dann MyPiD oder bist du dann MyPiD immer gefragt?
Genau, die MyPi, der läuft halt dann so einen MyPi-Server und dann kann er mal fragen und mit den ganzen anderen Linting-Sachen halt auch und ja, es ist mehr gekringelt, als ich dachte, weil vorher war das immer schön sauber und aufgeräumt und ich finde es tatsächlich auch ein bisschen, also,
wenn man halt Module benutzt, die zum Beispiel falsch typen oder sowas, ja, also in Anführungszeichen, dann meckert MyPi direkt und du musst halt einfach nebenschreiben, dass er es ignorieren soll, weil es kommt halt aus dem Modul und es ist ja falsch, das kann ich jetzt ja nicht ändern oder ich kann halt den Type-In davon dann neu machen oder sowas, also, oder eine Julien draus machen, was ja aber dann eigentlich auch falsch ist, weil, ja, was soll das?
Ja, da müssen wir, glaube ich, mal eine Episode drüber machen, oder?
Ja, Typing-Episode müssen wir mal.
Ja, nicht nur eine, glaube ich, da sind so ein paar.
Das wird eine sehr lange Episode.
Ja, also, gerade so bei generischen Types und so.
Und ich finde, das ist alles wild.
Also, und da muss man halt echt, und, ja.
Oder Junko-Stubs oder sowas und, äh.
Ja, jetzt ist es auf jeden Fall besser geworden, aber.
Was ist denn genau besser geworden?
Ach so, es ist jetzt besser geworden.
Man kann ja zum Beispiel sowas sagen, also, wenn man jetzt irgendwie irgendwo sagen will, Stern, Stern, KW-Arcs oder so, was man ja manchmal machen möchte, dann ist das ja irgendwie nicht gut zu typen.
Any.
Ja, kann man natürlich auch sagen, String Any, Addict, String Any, ja, aber machen ja auch viele.
Aber das natürlich, dann geht halt auch irgendwie so ein bisschen der Nutzen verloren.
Also, was man jetzt tun kann, ist, sagt, man sagt KW-Arcs, Doppelpunkt, Unpack und dann zum Beispiel Ecke-Klammer auf und dann gibt man den Namen von einem Type-Dict an.
Und dann in dem Type-Dict definiert man dann sozusagen für jede, für jedes Keyword-Argument quasi den, den genauen Type.
Oh, da könnte man auch eine Dataclass reingeben oder sowas.
Aber warum?
Ja, sieht ziemlich genauso aus wie eine Dataclass, ja.
Warum definiert man die denn nicht direkt?
Was ist dann noch der Sinn von Quark?
Wie willst du den hinschreiben?
Kannst du nicht.
Du kannst dann halt.
Jedes einzelne KW hinschreiben.
Ja, gut, das kannst du natürlich auch machen, ja.
Du kannst da einfach die ganzen Keyword-Argumente hin, wenn es halt ganz viele sind.
Dann sind da aber zu viele Argumente.
Irgendwo hast du sie halt getypt dann, ne?
Ja, und du kannst es halt auch nicht wiederverwenden.
Hast du sie hingeschrieben.
Aber ja, es ist auch.
Und bei dir kannst du es nicht machen.
Ja, es ist schon ein Nischenfall.
Ja, ja.
Und genau, bei den, bei den Generic-Type-Geschichten muss man jetzt auch nicht mehr irgendwie Type-Wahr- und Type-Alias davor schreiben, sondern man kann halt irgendwie einfach.
Man kann einfach Type nehmen als Keyword, also als Statement und dann irgendwie den Kram dahinter schreiben und muss auch nicht mehr den ganzen Kram importieren.
Das funktioniert einfach so.
Ja, also wenn man, wenn man drauf steht, dann ist das wahrscheinlich eine deutliche Verbesserung.
Aber ich weiß nicht.
Ja, Type ist schon so ein bisschen Bloatware, oder?
So Typing manchmal.
Ja, ich glaube, da müssen wir mal eine Episode machen.
Wir müssen nochmal länger, weil können wir jetzt, das können wir jetzt nicht leisten.
Das können wir beliebig vertiefen.
Ja, es ist halt wirklich nützlich.
Ich würde sagen, kollegatives Arbeiten, gerade mit Leuten, die das.
Noch nicht so wissen, was da passiert, ist das echt hilfreich, um denen so zu zeigen, welche ich machen sollte.
Ich habe auch Meinungen dazu, ja.
Also nein.
Ja, was haben wir noch?
Ah, coole, kleine Verbesserungen, die aber.
Achso, genau, auch noch zum Typing, weil das gehört auch noch zum Typing dazu.
Es gibt jetzt einen Override-Dekorator.
Override?
Ja, wo man halt über eine Methode schreiben kann, at Override.
Und dann damit dem.
Einen Type-Checker sagen kann, also das hier überschreibt übrigens eine Methode in der Superklasse.
Weil das Problem, das man bisher hat, ist halt, wenn man jetzt Methoden überschreibt in der Unterklasse,
dann kann die ja komplett korrekt getypt sein und so.
Und der statische Type-Checker, und jetzt nennt jemand irgendwie die Methode in der Oberklasse,
aber refactored die und benennt die um.
Dann merkt der statische Type-Checker davon überhaupt gar nichts und alles stimmt.
Das Verhalten ändert sich aber.
Weil ja jetzt plötzlich irgendwie das nicht mehr überschrieben wird.
Und ja, dann ist natürlich schlecht.
Und das heißt, du sagst explizit, hey, ich überschreibe hier eine Methode.
Genau, und sobald jemand in der Oberklasse das Ding umbenennt, dann sagt dir der Type-Checker,
sagt dir der statische Type-Checker, das ist überhaupt keine, das überschreibt überhaupt keine Methode mehr.
Hier ist irgendwas kaputt, was vielleicht schon hilfreich ist.
Ja, das tatsächlich findet man ein, zwei Wachs.
Typing-Zeugs dann durch.
Genau.
Zu Dekoratoren.
Ah, habt ihr das schon mal verwendet?
Cached Property?
Ja.
Ich hab das mal in Jungle gesucht.
Ich hab das auch schon häufiger verwendet, genau.
Ja, das ist weg.
Warum?
Es war kaputt.
Das Problem ist irgendwie, das hat so, es hat irgendwie massiv viele Logs gemacht und
hat irgendwie nicht auf Instance-Ebene geloggt und das ist schrecklich.
Und die Leute haben es gemessen und festgestellt, oh, es ist viel langsamer damit als vorher.
Ich hab's nie überprüft.
Ich hab immer so, oh, Cached Property.
Hashtag Cached Property, voll gut.
Nee, war scheiße.
Und, ähm, ja.
Das heißt, du machst einfach Cache und Methodenaufruf, oder?
Ja, also ich hab's eben für solche Dinge benutzt, wo halt dann irgendeine Berechnung stattfindet
und dann, äh, genau.
Also wenn die Berechnung sehr lang ist, gut, vielleicht ist es dann auch noch irgendwie
tatsächlich effizienter, aber so generell war es oft eher langsamer mit dem Cached-Dekorator
drüber als ohne.
Naja, man kann jetzt dann die Kalkulation cachen und dann eine andere Sache machen, wo
der Property drinter ist.
Ja, also auf jeden Fall, irgendwie hat sich wohl, hat sich jemand, hat sich das genauer
angeguckt, dabei hat sich herausgestellt, dass, so wie das gedacht ist, das geht das
alles gar nicht.
Und daher haben sie es jetzt entfernt, weil, äh, ja.
Das heißt, du musst das jetzt selber bauen.
Also du kannst, machst ja zwei Methoden, die eine Methode ist eine Property und die eine
Methode ist eine Methoden.
Es ist nicht so schlimm.
Also man kann das relativ leicht, sowas, sich sowas bauen.
Wenn du keine Logs brauchst.
Ja.
Ja, aber wenn man Logs braucht, dann ist man eh schon in so einem Drachen, äh, so einem
Drachenterritorium.
Das ist halt, ja, muss man eh gucken.
Ja.
Äh, genau.
Dann, ähm.
Drachenterritorium.
Ja.
Wo die wilden Tiere wohnen.
Genau.
Bronze Drachen.
Parslip, etwas, was mich immer, also das ist, das ist, das ist so ein Nervpunkt.
Also, dass es in Python halt mehrere Module gibt, die sich irgendwie mit sowas wie Files
und so Zorgs beschäftigen, ist halt einfach nervtötend.
Hat historische Gründe, aber ist halt einfach, es gibt halt Parslip, so als das aktuellste.
Und OSPAR.
Es gibt OS, ja.
Es gibt irgendwie dann noch SH-Util und es gibt noch irgendwie so ein paar andere.
Und je nachdem, was man machen möchte, muss man halt eins von denen verwenden.
Und es gibt keins, wo man alle verwenden kann.
Auch Parslip hat natürlich auch schon diverse, also Parslip, da wird immer rumkritisiert,
ein bisschen zu Recht, dass es ultra langsam ist.
Vielleicht hat sich das jetzt auch gebessert, das weiß ich nicht genau.
Auf jeden Fall, äh, wofür man früher immer noch mit OS häufig verwenden musste, war
halt OS-Walk.
Also, wenn man halt so ein Dateisystem im Baum einfach mal so rekursiv durchgehen möchte.
Und in Parslip gab's nichts dafür.
Also, und jetzt gibt's halt, äh, ein Walk in, in Parslip.
Das musst du machen.
Etatieren musstest du machen und dann immer rekursiv deine Funktion selber aufrufen.
Ja, aber das willst du vielleicht nicht selber schreiben.
Und gleichzeitig Iter-Files und das ist, äh, Arbeit und keine schöne Arbeit und leicht
falsch zu machen Arbeit.
Also, ich meine, das hast du nur für, machst du irgendwas anderes und dann willst du jetzt
mal nur kurz irgendwie über alle Files in deinem Dateisystem rumgehen und dann fängst
du da an, mit Rekursionen zu machen, äh, Dinge zu tun und so, wo viel schiefgehen kann.
Ah, ich weiß nicht.
Also, äh, da will man doch eigentlich eine Funktion einfach nehmen und die dann.
Einfach ein Walk.
Generell alles, was mit Dateien zu tun hat.
Ist so, dass man eigentlich da lieber Funktionen dazu hat, die sich schon mal jemand ausgedacht
hat, der was davon versteht.
Ja.
Weil die sind deceptively simple, wie man so sagt.
Die sind ganz einfach zu schreiben und gehen dann auf überraschend beeindruckende Art
und Weise kaputt.
An vielen verschiedenen Stellen.
Wenn du welche Permissions in die Runden steigen oder so was.
Ja, Permissions oder Cycles.
Bitte was?
Ja, du kannst ja Cycles in deinem Verzeichnis haben.
Du kannst ja links zum, zu einem gut darüberliegenden Verzeichnis und dann hast du eine Kurve drin
und dann hast du schon.
Schon einmal.
Der Ding zu da, der Ding zu da, da, da, da, da, da.
Und dann kommt der Beachball.
Wenn du dich in dieses Rabbit Hole eingreifst, dann wird das, was du eigentlich machen wolltest,
nicht mehr fertig, sondern dann bist du irgendwie verschwunden.
Erstmal für die Zeit.
Oder wenn man mit dem Cycle klingt, das könnte man dann mit lustige Sachen machen.
Ja.
Ja, schon.
Oder andere Devices und dann von den anderen Devices wieder das andere Device eingebunden
und.
Ah, alles ist dann frei.
Cycle über Devices.
Und so schnell kommt man.
Habe ich letztens irgendwo sehr schön, hat das jemand, äh, beschrieben, äh, ich weiß
nicht, ob es auf Mastodon war oder statt, keine Ahnung.
So, ja, also das, das coole, die coole Innovation von Unix ist ja, dass irgendwie in Unix einfach
alles ein Pfeil ist.
Es gibt ein kleines Problem mit dieser, äh, mit dieser Philosophie, nämlich, äh, irgendwie,
dass eigentlich so gut wie gar nichts ein Pfeil tatsächlich ist.
Ansonsten war es eine super Idee, aber es ist, ja, ist was dran.
Den Witz musst du jetzt nochmal genau erklären.
Das war jetzt so ein Insider.
Ja, also.
Also die Philosophie von Unix ist ja, alles ist ein Pfeil.
Du kannst, äh, da gibt's, äh, Files, wo du die CPU-Auslastung auslesen kannst.
Aber das heißt, du machst eine, äh, eine Händler auf, der zeigt an irgendeiner Stelle
und dann.
Ja, du musst halt den richtigen Dateinamen wissen.
Alles ist ein Pfeil.
Tatsächlich, fast alles ist ein Pfeil.
Aber was, was bedeutet das denn?
Vielleicht willst du erkennen.
Also, du hast so eine Zeiger draufhin und kannst von da aus losrennen.
Nee, du hast.
Nee, das ist ein Pfadnamen halt.
Das ist ein Pfadnamen und dann öffnest du dir die Datei und anstatt, dass du da Dateien,
dass du Daten von der Festplatte liest, kriegst du halt Daten von irgendwoher anders geliefert.
Zum Beispiel CPU-Auslastung oder zum Beispiel Netzwerksockets oder zum Beispiel sonst irgendwas.
Das ist zumindest die Idee, ja.
Dass wenn du halt den richtigen Pfad auf eine bestimmte, auf eine bestimmte Datei hast,
ja, das ist gar keine Datei, sondern ein Socket an irgendeinem.
Also Netzwerkverbindungen
sind auch nur Files, irgendwie Geräte
sind auch nur Files.
So eins der
ersten Unix-Dinge, die man so macht, wenn
Leute das nicht kennen, ist, man nimmt halt irgendwie die
Shell, zum Beispiel Bash, sagt halt Cat
bin Bash oder nach
größter Zeichen
Dev Audio. Ja, und dann
kann man irgendwie in dem Programm aus dem
Lautsprechertröpfeln zuhören.
Und solche Dinge.
Weil das ist auch nur eine Datei.
Ja, also unter Windows
oder MS-DOS war das halt, das ist halt
irgendwie, weil das war zu aufwendig.
Also das ist ja auch von Unix
inspiriert, aber das haben sie halt nicht so richtig implementiert,
sondern dann haben sie da so komische Dinge gemacht
wie Laufwerksbuchstaben oder
Device-Buchstaben. Ja, und so
reservierte Namen. Du darfst keine Datei haben,
die COM1 heißt. Auch unter Windows 11 noch nicht.
Ja. Und das ist
natürlich eigentlich total schrecklich.
Aber
ja gut, wenn man das nicht anders
kennt, dann fällt einem das vielleicht gar nicht so
auf, aber genau.
Ja, nur, genau. Also diese
Philosophie, dass halt alles ein Pfeil ist und man alles gleich
behandeln kann, ist eigentlich schon sehr cool.
Und ist eigentlich auch immer so ein Beispiel für
eine sehr gelungene API, weil man halt fast,
also ganz, ganz viel kann man damit erschlagen.
Und die API ist
gleichzeitig einerseits sehr schmal oben.
Also sozusagen, es gibt nur wenige Dinge,
die man drauf machen kann. Lesen, Schreiben,
bestimmte Stelle spulen.
Man kann
aber wahnsinnig viel damit machen. Die ist halt
total tief. Also die ist halt schmal und tief.
Das ist aber gut für eine API.
Schlechte APIs,
ah, worüber reden wir gleich noch?
Breit und flach.
Was könnte ein Beispiel für eine sehr breite
und sehr flache API sein?
Weiß ich nicht. Zum Beispiel Java-APIs
irgendwie für Pfeil lesen,
die sind halt scheiße. Die sind halt irgendwie, du musst halt
tausend Klassen kennen und die
konfigurieren und die ineinander stöpseln
und willst eigentlich nur ein Pfeil lesen.
Und das ist halt irgendwie, ach.
Und ja.
Genau. Sozusagen, also
das ist halt, also Leute
sagen mal,
das ist wirklich schön, das ist eine schöne
Abstraktion, das hat super funktioniert.
Genau. Man kann halt sagen, aber ein kleines
Problem, es gibt ein kleines, kleines Detail, das nicht so richtig
gut funktioniert, nämlich die meisten Sachen sind kein Pfeil und verhalten
sich auch nicht so und
daher
Wie kriegt man das Problem? Du musst das da irgendwie
reinstopfen oder so eine Spule
bauen oder? Ne, das ist halt so ein bisschen
ja, das ist
das stimmt auch irgendwo. Also es ist halt einfach
ja, es gibt halt, alles ist halt furchtbar.
Was habe ich letztens, ich habe
letztens ein Essay gelesen auf einer sehr schönen
Domain. Die Domain heißt irgendwie
stilldrinking.com
und da steht irgendwie
Programming Sucks oder so und da ist
sehr schön aufgelistet, was alles
so schief geht und warum eigentlich nie
irgendwas funktioniert und warum wir alle keine schönen Dinge haben können.
Kann man ja mal lesen.
Ich glaube, ich verlege das mal in den Schrauben. Ja, bitte, bitte.
Den kenne ich auch noch nicht.
Ja, der ist schon relativ alt
inzwischen, der ist von 2014 oder so.
Aber ja, ist immer noch genauso wahr
wie damals. Er wird sich wahrscheinlich auch nie
ändern.
Ja.
Und das mit dem Audio muss ich auch mal ausprobieren.
Ja. Das kann ich auch nicht.
Redirect von
Bash auf Audio. Genau, was
auch, C-Python
benutzt jetzt auch Precommit.
Auch nett. Precommit sind die Hooks,
die den Code automatisch
blinden oder
Ja, also du kannst halt mit Precommit
irgendwie diverse Regeln aufstellen,
die halt erfüllt sein sollen, damit
ob jetzt. Also zum Beispiel Black-kompatibel
oder ich weiß nicht, bei C-Python ist das jetzt eher
NC, also irgendwie. Jammel-Syntax
gecheckt wird oder das andere. Ja, okay. Weiß ich nicht,
falls zu groß sind oder. Weniger
Bugs. Fühlst du weniger Bugs?
Vielleicht.
Naja, du kannst damit auch zumindest irgendwie
relativ hart sicherstellen, dass
bestimmte Regeln eingehalten werden.
Machst du Precommit bei deinen Projekten? Ja.
Auch mit MyPy?
Ja.
Aber, ja.
Mach ich auch. Also ich mach Rough und
MyPy und IceHorse und Black
und PyUpgrade und sowas.
Ja, mach ich auch. Also
bis auf Rough, das benutze ich
nicht, weil ehrlich gesagt, wenn man
MyPy verwendet, ist es so langsam, dass alles
an den Regalen ist.
Aber catcht MyPy nicht nach dem
ersten Durchlauf? Ja,
mag sein. Ich weiß nicht, ich hab immer die Erfahrung,
dass wenn ich mir denke, so
ich hab doch jetzt auf diesen Knopf gedrückt. Doofes
PyCharm. Warum reagiert dieser Knopf
ist ausgegraut und irgendwas tut es und dann gucke ich
hoch, sondern sehe ich, ah, CPU-Auslastung ist hoch.
Hm, denk ich mir so. PyCharm.
Und dann denk ich mir, nein,
MyPy.
Und es dauert einfach lange und, ja.
Also MyPy muss man ja irgendwie, wenn man das
konfiguriert, die ganzen Dependencies irgendwie mit angeben.
Das ist fürchterlich alles.
Ja, weil das halt in einem eigenen Virtual
End alles stattfindet. Ja, aber warum
kann das das nicht selber raffen aus
der PyProject-Hummel oder sowas, wo man seine Dependencies
hat oder wo auch immer die liegen oder, also ich
finde es auch. Tja, wo auch immer die liegen.
Ja, da kann man doch sagen, deine Dependencies
liegen hier. Guck mal nach, das Formal kennst du
bestimmt. Nimm sie und bau da was mit.
Ja, vielleicht. Ich weiß es nicht. Aber es ist auf jeden Fall
nicht so einfach. Aber C-Python
benutzt es jetzt. Also es erhöht
die Wahrscheinlichkeit, dass es nicht weggeht. Das ist gut.
Ja, also
dass sich jemand findet, der das dann halt weiter maintaint.
Was auch noch schön ist, ist, oh, das ist
total super. Ich weiß nicht, das habe ich in jedem
Projekt gehabt und jetzt ist es,
ach so, jetzt ist es
halt quasi hoffentlich
gelöst. Ich habe in jedem Projekt
irgendwie eine kleine Funktion, die ich dann auch immer von
Projekt zu Projekt kopiere, weil es ist einfach zu
wenig, um daraus irgendwie ein eigenes
Paket zu machen oder so. Aber ich brauche
es halt irgendwie, tatsächlich, in jedem Projekt brauche ich halt
irgendwie so ein Ding, dass mir
wenn so eine lange Liste
oder irgendwie ein langes
Interable kommt, was mir das halt so in
Badges zerlegt, wo ich dann mit den Badges
irgendwas mache. Brauche ich immer.
Also das heißt da, wo du am Ende wieder zusammenfügst
oder so. Nee, einfach
in Stücke hacken. In vierer Blöcke, in achter
Blöcke, in zwölfer Blöcke. Genau, weil du willst
halt zum Beispiel irgendwie alle, willst
immer hundert Dinger gleichzeitig in die Datenbank
oder immer in hunderter Blöcke in die Datenbank schreiben
oder ausgeben oder sonst irgendwie was
machen. Aber du willst es halt nicht jedes Mal machen, sondern halt
so. Genau, also ich brauche das irgendwie
immer und
habe dann irgendwie, bei mir heißt diese Funktion
meistens so chunked oder sowas.
Und jetzt gibt es eine in
Intertools, die heißt Batched und
die macht genau das. Aber ist die
neu? Die ist neu. Ja?
Okay, ich dachte, da gäbe es sowas ähnliches.
Hab ich auch schon mal gehört. Gab es da? Also man kann auch
mit Zip oder
mit Eisleis kann man das bauen. Ja, gut, so Zip-Hacks
kannst du dir bauen, ja. Ja, aber
meine Batched ist neu.
Ich habe irgendwie letztes Jahr beim
vielleicht habe ich auch immer eine geschrieben. Advent of Code
Varianten irgendwie sowas.
Jeder hat
sowas schon mal geschrieben. Ja, also
da ich das irgendwie immer brauche, ist es gut,
wenn das jetzt in der Standardbibliothek ist. Hast du das reingebracht,
Jochen? Nein.
Aber
irgendwie, ja, ist ganz in meinem
Sinne. Ja, das glaube ich.
Dann genau, ich habe es wie gesagt schon
installiert und ich hatte auch so ein bisschen Probleme.
Ja, also
ich weiß nicht so ganz genau, woran diese Probleme liegen.
Ist ja auch noch alles sehr frisch. Ich habe sie bloß,
ich stehe noch unter dem Eindruck, sie erfahren
zu haben. Also halt sowas
wie zum Beispiel, also bei
Projekten, die ich dann auf 3.12 umgestellt habe,
das ging halt
irgendwie nicht. Also irgendwie das Installieren
von dem ganzen Virtual End funktioniert nicht, weil
es sagt halt so, ich kann dieses Wheel nicht
bauen von irgendeiner
Abhängigkeit. Und
dann habe ich versucht reingeguckt, ja, warum kann es das nicht bauen?
Ja, weil irgendwie,
Dist-Utils vielleicht fehlen
manchmal, weil
Dist-Utils sind Displicated, aber
wenn man Setup-Tools installiert, dann kommen die alten
Dist-Utils quasi mit und dann geht es wieder.
Und
genau,
ach so, und früher wurde das automatisch
in VNF, wenn man per
VNF irgendwie ein Virtual End
erzeugt hat, dann wurden die Setup-Tools direkt mit installiert.
Und das passiert nicht mehr. Also
das ist auch nicht mehr drin. Also auf jeden Fall,
da an der Stelle ist es halt bei mir irgendwie zuverlässig
gebrochen.
Und wo es auch gebrochen ist, das fand ich etwas
überraschend, und ich habe keine Ahnung, ob das irgendwie so
beabsichtigt war, ist, dass bei vielen
Abhängigkeiten, die
halt nur noch eine Pi-Project-Tommel
mitbringen, aus der dann
sozusagen steuert, wie dem Wheel erzeugt
wird, das geht nur
noch, wenn Pi-ZMQ installiert
ist. Keine Ahnung, warum.
Was ist denn Pi-ZMQ?
Irgendwas mit einer
dieser, irgend so ein Messaging-Queue.
Okay.
Hätte ich jetzt nicht mit Wheels
in Verbindung gebracht. Ja, ich auch nicht. Deswegen hat es mich
gewundert. Und zwar auch in einer relativ neuen Version.
Und wenn man das halt nicht installiert hat, also ich muss
jetzt eine Reihe von Projekten das Ding als
Core-Abhängigkeit mit hinzufügen,
weil ansonsten konnte man
irgendwie die ganzen Abhängigkeiten nicht mehr installieren.
In 3.12, in 3.11 geht's noch.
Also keine Ahnung, was da genau das Problem ist,
aber naja.
Vielleicht installiert das irgendwie eine Subdependency
auf die irgendwie hin.
Klingt auf jeden Fall gut.
Genau weiß ich jetzt nicht, aber das ist halt etwas,
worüber ich gestolpert bin und worüber ich auch gestolpert bin,
aber das kann sein, dass das jetzt ein sehr spezifisches
Mac-Problem ist. Es ist halt, auf dem M1
findet, wenn man Python
kompiliert mit Homebrew,
das statt
der aktuellen OpenSSL-Version
die OpenSSL-Version 1.1, wenn sie installiert ist.
Und das geht dann schief,
weil, ja, zu alt.
Wahrscheinlich ist das irgendein Fehler im
Configure-Skript oder so.
Und wenn man
dann OpenSSL 1.1 entfernt und
dann geht's.
Ja. Das möchte man ja eigentlich.
Ja. Habe ich jetzt auch.
Ich dachte dann, wenn man sagt, ah, entfernt's mal,
dann hat's mir gesagt, irgendwie ganz viele Pakete,
die drauf basieren, unter anderem sowas wie
TMAX und so und
diverse andere Geschichten,
ImageMagick, LibHive,
so Sachen, wo man sagt, das kann ich nicht deinstallieren.
Das ist da, da
wiederum dependet zu viel anderes Zeugs drauf.
Wenn man das alles deinstalliert, dann
OpenSSL 1.1 entfernt und
dann das nochmal installiert, dann
linkt das halt gegen die richtige
OpenSSL-Version.
OpenSSL. Ja, gut. Also wahrscheinlich
ist da auch wieder ein Fehler in irgendwelchen Configure-Skripten.
Das ist doch ein Mac-Problem, oder? Kauft euch mal
einen richtigen Secure-Skript. Ja,
kann schon sein.
Genau, ja. Jetzt haben wir
aber tatsächlich so ein bisschen News, also nur von 3.3.12
gemacht und ich glaube,
wir müssen
eine neue Folge sonst irgendwie aufmachen
mit News von Python 3.12. Wir machen
das nächste Mal mehr News.
Also eigentlich wollten wir ja über
Kubernetes reden und ich glaube, wir hatten jetzt so eine neue
Markierung und haben
die ganzen News jetzt, wenn ihr noch dran seid und
Kubernetes tun wollt. Oder übersprungen habt.
3.3.12 ist schon auch relevant.
Ja, das stimmt natürlich. Ja, also die anderen News
dann später. Wir haben immer noch,
ja, haben wir noch welche? Nee.
Nee, gut. Ich nicht. Gut, dann
sprechen wir jetzt über Kubernetes.
Spannend. So ganz am Einstieg,
was ist denn das?
Das ist schwer zu sagen.
Es ist schwer zu beschreiben, was Kubernetes eigentlich ist.
In wenigen Worten zusammengefasst
würde ich sagen, das ist eine verteilte
Runtime für Docker
VMs. Also sowas, das
irgendwie so ein paar Boote auf
einem See beaufsichtigt.
Nee.
Doch.
Also es ist so ein bisschen das, also ich glaube,
wenn man sich das so vorstellt,
dann laufen halt so bestimmte Boote,
also Pots, so
Container halt.
Containerschiff sozusagen. Genau, auf so einem, ja,
vielleicht sind das einfach so kleine Nussschalen
oder sowas auf so einem See rum.
Und irgendwer guckt halt, dass die
in der richtigen Reihenfolge da laufen und dass
man damit Dinge anstellen kann.
Also das ist ein Bild,
was ich nicht
in den Kopf kriege, aber
man kann es sicherlich so betrachten.
Was ich auch schon mal,
du sagst verteilte Runtime für, man könnte
auch sagen, vielleicht ein Betriebssystem für eine Gruppe von
Rechnern irgendwie.
Die kann man dann wie ein
Ding ansprechen, obwohl es halt viele Rechner
sind. Ja, also das finde ich
tatsächlich gar nicht so wichtig da dran, sondern das Wichtige
daran finde ich eigentlich, dass das
weggeht von dem imperativen Modell,
was man ja so bei den, also wenn man Ansible macht,
dann sagst du, auf diesem Server soll
jetzt das hier ausgeführt werden und auf diesem
Server soll das hier ausgeführt werden.
Das ist sehr imperativ, ja, du gibst an, was
passieren soll. Und
Kubernetes geht hin
zu so einem
deklarativen Modell. Du sagst gar nicht mehr
auf dem Computer soll das passieren,
sondern du sagst, es soll drei Instanzen
von dieser VM geben.
Also das ist vielleicht auch noch so einer der Zwecke,
wie Kubernetes am meisten irgendwie verwendet wird, dass du
halt irgendwie so ein Load-Balancing machen kannst
und halt skalieren kannst.
Genau, dass du so skalieren kannst in horizontale
Richtung, wenn du mehr Last kriegst oder sowas.
Oder dass du vielleicht so Releases machen kannst,
die rollend sind oder so.
Das ist ein Aspekt davon, dass du
so Skalierungsthemen hast. Finde ich jetzt aber gar
nicht tatsächlich so wichtig, sondern für mich ist eher
wichtig, dass du so eine Abstraktion hast zwischen
was ist das Substrat,
also die Computer, die du hast,
und was ist die Workload?
Also die Sachen, die du ausführen möchtest.
Und so ein bisschen wie bei einer Datenbank.
Bei einer Datenbank ist das Substrat die
Festplatte und die Workload
sind die Daten, die du drin hast. Und ich will
eigentlich gar nicht selber entscheiden müssen,
welche Daten wo liegen und wie die
aufgebaut sind. Und deshalb nehme ich
eine SQL-Datenbank, weil da sage ich einfach nur, hier sind
die Daten und die haben folgende Eigenschaften,
sorgt dafür, dass die gut sind.
Und bei Kubernetes ist es genauso.
Da sage ich, ich habe hier meine
Nodes, das sind die Computer, die ich habe
und nimm die mal
und dann
komme ich von der anderen Seite und sage, hier ist meine
Workload. Ich brauche jetzt zwei VMs von
der Sorte und fünf von der Sorte und sieben von der
Sorte und die müssen so und so miteinander
kommunizieren können. Sorg mal dafür.
Also zweimal eine Datenbank, fünfmal eine Anwendung.
Genau. Und die müssen folgende Ports
offen haben und die müssen folgenden Speicherplatz haben
und die müssen miteinander kommunizieren können und die
müssen so und so exposed sein und
sorg mal dafür, dass das passiert.
Ja, da steckt man halt quasi so ein bisschen
Lego zusammen.
Jein.
Du steckst es nicht selber zusammen, sondern du
sagst hier, so soll das Lego-Modell
am Ende aussehen. Schreibst eine Bauanleitung für ein Lego.
Bau mal.
Und das ist das, was mich da eigentlich
dran reizt,
dass du eben nicht mehr sagst, es soll etwas
passieren, sondern du sagst, es soll ein Zustand erreicht
werden. Ja. Und
das beschreibt auch so ein bisschen das
System, ja. Das
beschreibt so ein bisschen, was Kubernetes überhaupt ist.
Das ist eine Engine, die dafür sorgt, dass
ein Zustand von VMs
erreicht wird,
mit den gegebenen Ressourcen.
Und
das ist was Sinnvolles, das ist was Nützliches.
Das ist nicht dann nützlich, wenn du eine VM
ausführst oder wenn du einen Rechner hast.
Das ist dann nützlich, wenn du 100 Rechner
hast und 1000 VMs ausführen musst.
Weil dann, wenn du das manuell machen
möchtest, dann fängst du halt an.
Dann musst du
irgendwelche Node-Gruppen machen und musst
irgendwelche Verteilungsdinge
machen und Affinitäten und Netzwerk,
was weiß ich.
Mit Kubernetes sagst du halt einfach,
ja, das ist jetzt in Anführungsstrichen
gesetzt, sagst du einfach, hier sind
deine Nodes und dann kommst
du von der anderen Seite an die AP ran und sagst, so,
ich hab jetzt hier Workloads und zwar diese hier
und diese hier und diese hier und diese hier und jetzt mach mal.
Und idealerweise
sorgt dann das System dafür, dass die
Workloads, also die Images, die du laufen
möchtest, auf diesen Knoten, die du hast,
verteilt werden, sodass die
alle ihre Anforderungen erfüllen und dass die Knoten
trotzdem alle gut ausgelastet
sind und gut verteilt sind. Und
was weiß ich nicht, was man da alles noch einteilen
kann.
Aber im Endeffekt ist es,
wenn man das, also aus
Anwendersicht, ja, aus Workload-
Betreiber-Sicht,
ist das schon was relativ Simples.
Du sagst halt, du beschreibst halt,
wie deine
Workloads aussehen sollen und was
du gerne am Laufen haben möchtest. Und auch
wie viele, ja.
Also wenn du so ein System hast, wo du 100
Nodes hast oder 1000 Nodes, ja, dann ist es
leicht zu sagen, ich brauche jetzt 100 von diesen vor
oder 200 von diesen. Oder da ist
jetzt gerade Last drauf, also mach die bitte hoch
oder wieder runter.
Naja, das klingt
erstmal sehr charmant,
wenn man das einfach so, wenn man sagen kann, okay, ich abstrahiere
von den konkreten
Maschinen irgendwie. Da können unten
Leute immer neue
Maschinen in Racks
stecken und mein Cluster wird halt
größer. Wenn wir das drauf installieren und den
als Node deklarieren. Genau, und ich muss
das alles gar nicht wissen.
Und auch von den Operationen. Du gehst weg von den
Operationen. Also eine Node braucht
tatsächlich nichts anderes als ein installiertes
System mit einem Kubernetes.
Das weiß ich nicht genau, wie das
eingerichtet wird, weil die
diese Operations-Seite habe ich noch nicht
selber erlebt. Wir benutzen überall
nur Managed Kubernetes.
Weil auch, wenn du, also
das Lustige ist ja, ja,
das Argument gibt es ganz oft, Google
macht das, also machen wir das auch.
Und das stimmt
aber so nicht, weil Google hat halt bestimmte
Anforderungen und andere Firmen
oder Projekte oder Teams haben halt andere
Anforderungen. Wir haben ja bestimmt zwei Applikationen, dafür brauchen wir
ein Kubernetes-Cluster. Ja, genau. Also wir haben
hier zwei Server, dann mach doch mal ein
Kubernetes-Cluster auf. Wir wollen da vier
VMs laufen lassen, mach doch mal ein Kubernetes-Cluster auf.
Nee, das brauchst du nicht.
Dafür brauchst du einen Server und da kann
jeder Docker-VMs starten oder
andere VMs, ja.
Das brauchst du dann, wenn du tausend Rechner
hast und 30 Teams, die
5000 VMs da drauf betreiben
wollen. Weil dann willst du da nicht mehr händisch reingehen,
und sagen, ihr kriegt jetzt diese
Server und ihr kriegt diese Server und ihr kriegt diese
Server, sondern dann sagst du einfach,
hier ist euer Quoter und hier ist euer Quoter und hier ist
euer Quoter. Ja. Und
ihr dürft da drauf starten, was ihr wollt, solange
ihr in eurem Quoter bleibt. Kurz, was ist
ein Quoter? Also ein Anteil von Rechenkapazität?
Genau, also du kannst
Accounts, also es ist natürlich
alles viel komplizierter, als es sich anhört, weil
genau wie bei Datenbanken, eine Datei
auf die Festplatte speichern ist easy, eine Datenbank
betreiben ist nicht so easy.
Und das kommt auch mit der Scale dazu.
Ja, wenn du so eine gewisse
Größe erreicht hast, wenn du halt mehr als 5
Teams hast oder mehr als 10 Teams hast, dann musst
du da irgendwie Autorisierung drin haben.
Und dann musst du auch dafür sorgen, dass sich die Teams
nicht gegenseitig zu sehr auf die Füße treten
können. Oder abschießen können. Oder abschießen können, genau.
Das heißt, du musst verhindern, dass ein Team
sagt, so, wir brauchen jetzt 100.000 VMs mit
jeweils einem Gigabyte Speicher und dann ist dein
ganzer Knoten nur noch von diesen kaputten
Sachen. Ich hatte so ein bisschen
Gefühl, so meiner Erfahrung nach,
ich hatte nicht so das Gefühl, dass man das wirklich
dafür sorgt, dass mir niemand auf die Füße tritt, sondern eher
so, dass ich die auf mir, also ich hatte
immer noch die Schmerzen, als ob mir jemand auf die Füße getreten
hätte. Aber ich kann die
nicht mehr sehen, die das waren.
Ja, genau. Eine andere Administrationsgruppe.
Keine Operation. Es gibt eine Administrationsgruppe,
die dann trotzdem alles da, die Geisterkundin hat,
die das putzen und sauber machen. Aber normalerweise,
also um zu dem Normalzustand
zurückzukehren, ja, normalerweise hast du halt dann da deine Teams
drauf, die irgendwelche Accounts auf diesem Kubernetes
System haben. Und diese Accounts haben ein Quota. Das heißt,
die dürfen eine bestimmte Menge CPU
anfordern und eine bestimmte Menge RAM anfordern.
Und mehr,
äh, starten,
mehr VMs starten kannst du halt nicht.
Du kannst dem System sagen, starte bitte mehr VMs
und dann sagt das System, nee, ich kann nicht mehr
VMs starten, weil dein Quota aufgebraucht ist.
Und ja,
auch das kann zu Schmerzen führen,
dass du halt sagst, okay, wir brauchen aber mehr
und es geht nicht mehr. Nur
das Problem hattest du vorher auch, ja, wenn du hier
die drei Server hattest und die sind halt voll.
Ja, aber es gibt auch
höchstens noch selber dran. Es gibt schon
Probleme, die man kriegt,
die ich so sonst nicht kenne.
Also, die ich halt ohne Kubernetes
nicht habe.
Weil diese Abstraktion halt doch
irgendwie leaky ist. Ich meine, wie alle Abstraktionen
so ein bisschen. Also zum Beispiel etwas, was
halt irgendwie,
ich meine, keine Ahnung, vielleicht gibt es auch irgendwie eine tolle
Lösung für, aber was es halt, was ich halt schon
irgendwie ätzend fand, ist halt, dass
du eben, wenn du jetzt viel Zeug
betreibst, dann kannst du ja
nicht irgendwie allen Sachen
irgendwie ganz viel Ressourcen geben, weil sonst sagt der
Klasse dir so, äh,
du hast jetzt hier schon so einen Dicke,
das geht nicht.
Das heißt, du überlegst dir dann so, okay,
naja, also eigentlich braucht
ja dieser Kante, das braucht ja gar nicht so viel.
Dann setzt man die Ressourcen
darunter. Ja, da hast du zu wenig
Ressourcen gehabt, da war dein Quota zu niedrig.
Ja, und dann
passieren aber im Betrieb so Dinge, wo man
dann halt mal kurzfristig ein bisschen mehr braucht.
Und dann, zum Beispiel Hauptspeicher,
und dann killt es das einfach weg.
Das ist halt
nicht so nett irgendwie. Das ist dann tatsächlich
das Interessante, was da passiert,
weil das System
äh,
reduziert genug ist, findest du auf einmal
die Ecken und Kanten. Also zum Beispiel,
dass du, äh, dass du zwei Limits hast.
Ja, du hast ein Requests-Limit und
ein Limit-Limit.
Du forderst, äh, du brauchst mindestens so
viel RAM und aber
auf keinen Fall mehr als so viel.
Und manchmal brauchst du es halt aber doch.
Und diese Worte bedeuten auch nicht das, was sie
bedeuten, sondern dieses Requests,
wenn du zwischen dem Requests und dem Limit
bist, dann heißt es, dass der,
das Kubernetes diese
vor allem abschalten darf.
Mhm.
Weil du ja über dem Requests drüber bist.
Du bist über das, was du angefordert hast.
Die, diese Worte bedeuten
halt nur, wenn du übers Request gehst,
darf Kubernetes deinen,
deinen, deinen VAM-Schalter abschalten.
Beim Limit muss es die VAM
abschalten. Und das heißt, es darf halt dann,
wenn andere anfragen, ob sie neue Ressourcen
haben können und es keiner freien mehr findet.
Ja, beziehungsweise, wenn
du über dein, über dein, also es gibt
zwei wichtige Kenngrößen, ja,
CPU und, äh, Memory.
Mhm. Und, äh, für
jede der beiden kannst du angeben, wie viel du
requestest, also wie viel du anforderst
und wie viel
du maximal benutzen wirst,
also wie viel du am Limit hast.
Und, ähm, das,
das Scheduling, also die Zuweisung,
welche
Arbeitslasten auf welchem System,
auf welchem Knoten laufen, die gehen über
das Requests.
Das heißt, wenn du sagst, meine Anwendung
verbraucht 500 Megabyte Hauptspeicher
und
maximal 1000, dann kannst du auf einen
Rechner gesetzt werden, auf einen Knoten gesetzt werden,
wo 500 Megabyte frei sind.
Weil dann ist deine Anforderung erfüllt.
Ja, du hast gesagt, ich brauche 500 Megabyte
Hauptspeicher. Wenn du drüber
gehst, dann kann das halt sein, dass es,
dass es nicht geht. Du kannst nicht mehr Speicher
reservieren oder es kann sein, dass du, äh,
abgeschossen wirst, weil jemand anderes
auch gerade 500 Megabyte
angefordert hat und du halt
aber mehr als deine 500 Megabyte verbraucht hast,
weil du zwischen Requests und Limit bist.
Die, die pragmatische Lösung, die sich
bei uns in diesem Projekt ergeben,
ist, dass du Request-Gleich-Limit setzt.
Das heißt, du forderst einfach so viel
an, wie du denkst, dass du maximal brauchst
und Spitzen hast, darfst du dann halt
nicht haben, beziehungsweise Spitzen hast du halt dadurch
abgedeckt, dass du sie... Das kenne ich auch,
aber das Problem ist halt, tatsächlich hat man
aber oft irgendwie Spitzen.
Ja, und ist auch nicht schlau, ja. Eigentlich willst du ja,
dass sich diese Wellen so ergänzen.
Und wenn ich jetzt einfach auf einem normalen
Rechner sozusagen deploye und ich habe jetzt halt irgendwie
sagen wir mal 10 Projekte, die alle unterschiedliche
Last haben und so, und ab und zu brauche ich
halt mal so einen Gigabyte Hauptspeicher oder
zwei.
Zwei für irgendwas,
weil sie halt irgendwie zum Beispiel
im Fall, an dem ich mich gut erinnere, wo das halt
echt Kopfschmerzen breitet
hat, manchmal startest
du und du kannst es auch nicht, hast es nicht unter Kontrolle.
Bei Python hast du es halt oft unter Kontrolle.
Da kann man schon irgendwas machen,
aber zum Beispiel für manche Sachen,
wenn man dann so ein externes Binary
startet, wie zum Beispiel FFmpeg.
FFmpeg, du kannst nicht...
Der isst einfach alles auf.
Naja, also es kann auf jeden Fall passieren.
Du hast halt, also normalerweise
passiert nichts.
Und dann, aber du hast halt FFmpeg mit
irgendwie so, weiß ich nicht,
200 Zeichen irgendwie komischen Optionen
hintendran und meistens passiert gar nichts. Und in
komischen Fällen manchmal braucht das dann halt zwei
Gigabyte Hauptspeicher. Ist halt so.
Ja, aber solltest du das dann nicht abschießen in dem Fall?
Nein. Solltest du das nicht verbieten in diesem Fall?
Ja, und es ist halt dummerweise sinnvoll.
Und das braucht es halt wirklich. Und jetzt kann man
natürlich dann irgendwie, keine Ahnung, FFmpeg
irgendwie sich angucken und schauen, wo ist denn da das Problem?
Aber, äh, ja.
Aber wie geht man denn mit so einem Fall um?
Also, wenn ich einfach auf eine normale Maschine
deploye,
dann, das gleicht sich alles aus.
Das ist kein Problem. Wenn dann mal ein Prozess
mit ein bisschen mehr Hauptspeicher läuft,
ist nicht schlimm. Ja, das dauert auch
nicht so lange. Dann ist es wieder gut.
Weil Kubernetes hat mir das echt,
das macht dann echt Kopfschmerzen. Es geht so weit, dass dann
Leute dann hingehen und neue Maschinen kaufen, weil
man das irgendwie nicht in den Griff kriegt sonst.
Und das ist halt schon irgendwie so. Ja, das ist doch gut für die Hersteller.
Ja, genau. Aber dann denke ich mir so, also irgendwie
kann das doch nicht die Lösung sein, oder? Also,
ja. Weil man braucht es ja
tatsächlich eigentlich nicht. Also, es ist halt
nicht so, dass man, also,
er muss da eigene Pods
starten mit FFmpeg drin.
Ja, ja, genau. Das kann man natürlich dann auch
machen. Du kannst dann halt irgendwie so
dir spezielle, oder das Problem
hast du natürlich auch, wenn du spezielle Hardware hast,
sowas wie GPUs oder sowas. Ja, gut, klar.
Aber dann geht auch so ein bisschen der ganze
Vorteil irgendwie so ein bisschen wieder verloren, weil
dann muss sich ja doch wieder um die ganze
Ja, klar. Die
Annahme ist halt, dass du viele
sage ich mal gleichpräige
Arbeitslasten hast,
die du
wo es nur darum geht, die irgendwie so
mehr oder weniger gleichmäßig zu verteilen.
Und dann ist das großartig.
Aber
das Interessante, was
als ich Kubernetes gelernt habe,
war, dass sich da so die Denke
so ein bisschen verändert. Genauso wie wenn man SQL lernt.
Beim SQL lernen, wenn du anfängst, SQL
zu lernen, dann ist die Frage oft so,
wie sorge ich denn dafür, dass
er das aus der Tabelle holt?
Und die Antwort ist,
gar nicht. Du sorgst da gar nicht dafür, sondern du sagst,
naja, ich brauche was aus der Tabelle und dann
sorgt er schon selber dafür, dass es
aus der Tabelle kommt.
Und so Situationen
gibt es bei Kubernetes auch ganz
viele, weil du eben zu diesem deklarativen Modell
hingehst. Zum Beispiel, eine
der schönsten ersten Lernerfahrungen war,
wie sorge ich denn dafür, dass diese Maschine
neu gestartet wird? Und die Antwort
ist, gar nicht. Du löscht
dir einfach. Du machst einfach die, die
jetzt gerade existiert, weg und
Kubernetes bemerkt, oh Moment, da fehlt ja eine
und startet eine neue.
Und das ist
am Anfang manchmal etwas unintuitiv,
auf diese
Operationen zu kommen, wenn du irgendwas erreichen
möchtest, wie du das deklarativ machst.
Und deklarativ ist halt, diese Maschine soll
jetzt bitte entfernt werden.
Ja.
Das sind auch so ein paar Probleme.
Was das halt auch ist, ist irgendwie so
Rolling Release dann halt irgendwie. Du hast halt mehrere
Versionen von einer Software, die dann
live ist, weil die halt einfach...
Wundervolle Sache.
Also du hast keinerlei Verzug mehr
zwischen neuer Version, also gefühlt,
und 10% laufen noch auf der alten Version
oder schon auf der neuen, und dann schalten die
ab, wenn die Prozesse irgendwie fertig sind, alte Maschinen
ab und neu halt irgendwie rein.
Aber das ist auch irgendwie ein bisschen
blöd an verschiedenen Stellen.
Ja, aber es ist doch eine großartige Sache.
Es gab einen super Artikel zu Blue-Green-Deployments
mit Django, da hast du halt...
Von Marius Flissiak.
Genau. Wird in den
Shownotes erscheinen.
Wo du halt ganz arg drauf achten musst,
dass du deine Datenbank-Migration
so machst, dass du quasi bei jedem
Übergang beide Versionen betreiben
kannst. Ja, das ist ja genau das Problem.
Was machst du in Migration, in Django?
Und dann ist irgendwie ein Feld in der Tabelle
auf einmal neu. Ja gut, also ich meine, es steht dir ja frei,
das anzuhalten und dann die Migration zu
machen und dann neu zu starten. Das darfst
du ja machen. Ja, aber neu ist ja
kein Problem. Also Problem ist
halt eher, wenn ein Zweck fällt oder so.
Aber wie gesagt, dieser Mechanismus
kannst du ja immer noch machen. Du kannst ja alle anhalten und
Migration machen und alle neu starten.
Das ist ja kein Ding.
Nur, was die jetzt auch noch machen,
kannst, ist eben diese, ja zum
Beispiel ein Rolling Release oder ein Blue-Green Deployment.
Rolling Release,
ich glaube, wir müssen das erklären, ja? Ich wusste
diese Worte auch nicht.
Rolling Release heißt, dass
wenn du zum Beispiel fünf VMs in
einer bestimmten Version laufen hast, dass
du das Kubernetes-System anweisen kannst,
ich möchte jetzt auf eine andere Version, auf eine höhere
Version, und zwar Rolling.
Das heißt, er wird
die VMs nach und nach
abschalten und nach und nach die neuen zuschalten.
Das ist halt immer eine gewisse Lasse.
Dann eine neue hochfahren. Und erst, wenn die neue
hochgefahren ist, wird die nächste alte gestoppt.
Das heißt, du hast
keine Situation, wo du
keine Availability hast.
Ja, genau, aber das kann man ja, so ein Problem, wenn
PostQuesta einen Gipfel aufkriegt mit einem neuen Feld oder so.
Ja, gut, klar. Das muss halt deine
Software dann können. Und das ist nicht
immer so einfach.
Ja, also, aber das kannst du auch
mit Ensemble machen, weil dieses Problem hast du natürlich sowieso
auch. Ich würde nur sagen, also...
Das ist natürlich schwierig, weil es ist schon eine komplizierte Operation.
Ja, aber, aber,
na gut, ich weiß nicht, ob man das halt so
einfach automatisieren kann, weil es gibt
halt sehr unterschiedliche Arten von, also es gibt
halt die Dinge, wo man halt ein Rolling-Update
machen kann, wo das halt gar kein Problem ist,
wo man sozusagen nur irgendwie
die alten rausnimmt und die neuen
im Loadbalancer mit hinzufügt. Aber dann gibt es
halt auch Dinge, wo das halt nicht geht, sondern wo du
alle auf einmal umschalten musst.
Weil das sonst
deine Datenbank kaputt macht, zum Beispiel.
Ja, oder du musst halt
zu deiner alten Datenbank eine neue Datenbank gleichzeitig
hochfahren und dann erst die neuen
Daten einmal spiegeln, dann rüberfahren
und dann irgendwie aufsammeln, das, was
in der Zwischenzeit noch in die alten Daten geschrieben wird
und dann auch so eine Liste machen,
die du dann in die neuen Datenbank migrierst und
das aber dann rollen. Das heißt, während
du die migrierst immer länger, bis du dann irgendwann
abschalten kannst, dann kannst du nur noch die neuen, das danach fliegen
und dann hast du vielleicht nicht mehr ganz klare Daten, weil
welche kamen jetzt zuerst und...
Also es eignet sich sicherlich nicht für jede
Situation, sagen wir es mal so.
Aber wenn du zum Beispiel irgendwo nur Konfigurationsänderungen
machst oder nur, keine Ahnung,
irgendwelche harmlosen Features live
schaltest, dann ist das schon irgendwie schön, weil du dann
halt Zero-Downtime hast. Ja, aber das hast du doch
sonst auch.
Also wenn ich bei mir irgendwie
ein neues Deployment mache, habe ich
Zero-Downtime. Du machst halt den
neuen Server auch... Ich habe eine Sekunde Downtime in der Mitte.
Du machst ja den einen...
altes System läuft. Dann fährst du das neue System
hoch. Ja gut, das ist ja Blue-Green. Und dann zeigst du
aber dem Loadbalancer einfach
aufs neue System. Ja genau, das ist Blue-Green-Deployment, was ihr da
beschreibt. Das heißt, du hast ein System
im Background laufen, was Blue ist, also
was den Status Blue hat
und sagst dem Loadbalancer, bitte allen Traffic
auf Blue. Und dann startest du ein System,
ein komplettes, was Green hat als Status
und wenn das fertig da ist, sagst du dem Loadbalancer
jetzt umschalten auf Green.
Diese Technik, die ihr beschreibt, heißt Blue-Green-Deployment.
Auf die ist es relativ leicht mit
Kubernetes umzusetzen.
Die eigentliche Frage,
die sich für mich stellt, ist, braucht
man überhaupt Zero-Downtime-Deployments?
Ja, das ist auch so eine Frage.
Die machen ja ungeheuer viel Arbeit und die machen ungeheuer viele
Probleme. Also dieser Django-Artikel
über Blue-Green-Deployments, der ist wunderbar
zu lesen und ist auch sehr schön, aber
es sind halt einfach acht Arbeitsschritte
mehr, als wenn du sagst, okay, wir halten
kurz an, dann sind wir für eine Minute da und dann machen wir
die Migration und dann starten wir es
einfach wieder. Das gibt da noch ganz viele schöne Reihensachen.
Weil wenn du sowas in so einer CI-CD-Chain
drin hast, wo man, um
zu testen, ob das überhaupt funktioniert, noch einen
Staging-Prozess zwischendurch hat, der
dann aber sowas macht, wie erstmal die
alte Version auschecken und dann darauf ein Update
fahren, damit halt klar ist, dass das Update
geht und er nicht direkt neue Sachen baut,
dann kann ja sein, dass das neue Version
bauen anders ist, als auf ein altes System Update
setzen. Und dann musst du halt erst alte bauen und dann
das neue Updaten. Und wenn man dann sowas macht, wie
neue Environments oder Secrets dazu und
die es beim Anfang noch nicht gibt, aber am Ende
dann schon, dann musst du halt quasi, oder
halt welche entfernt halt, größeres Problem,
dann sind die halt auf einmal weg.
Das sind ein paar Sachen, die so problematisch sind, weil dann musst du
zwei Releases machen, um so Sachen rauszukriegen
zum Beispiel. Ja, das ist
diese Krankheit. Google macht das, also machen wir das
auch. Wieso, also die
allermeisten Projekte
und Teams und Unternehmen können doch
auf, können auch eine Minute Downtime
hinnehmen. Ist doch egal.
Ja, aber wenn du Service-Level-Agreements
hast, wo 5,9,
das hast du so 99,999%.
Also das können ja alle haben.
Das macht dann nur 9,5.
Das ist mein Service-Level-Agreement, ich garantiere.
Mindestens 55,55555%
Abteil.
Hauptsache viele Zahlen.
Hauptsache viele Significantages.
Nee, das ist eben die Sache, das ist diese Krankheit.
Man kann das machen,
aber muss man das
machen. Und bloß, weil das,
und klar, das ist so vom Engineering her, ist das schon cool.
Hast du eine Woche
Arbeit reingesteckt, um ein Update zu machen
und dafür hast du
100% Availability.
Großartig. Aber lohnt sich das?
Ja, genau. Es gibt Fälle, wo das so ist.
Ja, klar, es gibt Fälle, in denen das so ist.
Aber, also ich meine, wie viele
Engineering-Stunden
sind eine Minute Downtime wert?
Oder zwei Minuten? Oder fünf Minuten? Oder zehn Minuten?
Ja.
Das ist eine
Frage, die man sich stellen muss. Und bloß, weil man
das kann und weil die Techniker das machen
wollen, ich zähle mich da ja auch dazu.
Ich möchte auch gerne so ein cooles Deployment-System
bauen, wo du Zero Downtime hast und
100% Uptime und dann geht's
aber leider doch nicht, weil du irgendwo WebSocket verbindest.
Ich hatte ja auch mit dem Operativen
Teil von so größeren Systemen schon irgendwie
intensiveren Kontakt irgendwie
vor langer Zeit. Aber...
Damals. Damals. Ja, als wir noch jung
waren. Aber, also
sozusagen mein Bauchgefühl aus der
Zeit würde sagen, es gibt
so viele unterschiedliche Arten von Dingen,
die man tun muss. Das kann man
unmöglich irgendwie abstrahieren.
Und das ist halt von der Hardware auch abhängig, die
darunter liegt. Das ist halt, dass man das wegabstrahieren
kann. Aber Jochen, Google macht das doch auch.
Und wir könnten einfach ein Managed Kubernetes-Cluster
kaufen und dann kannst du einfach zwei Pots hochschreiben und
die, da kannst du so einen Schieberegler
in deinem Webinterface einstellen, der sagt dann
sieben Pots von acht bis zehn
Uhr und danach...
Oder Load Balanced auch, wenn die
CPU-Auslastung über 50%
steigt, dann skalierst du hoch.
Geil. Okay, es kann sein, dass man das heutzutage alles
nicht mehr braucht. Aber was wir zum Beispiel damals hatten,
so auch bei diesen Load Balancing-Geschichten
ist halt sowas. Was ist denn jetzt, wenn
dein Netzwerk-Konnektivität
asymmetrisch ist?
Und du kannst halt...
Ja, genau. Jetzt muss dann halt...
Du musst ja alle gleich behandeln können. Jetzt musst du erst mal
bitte wieder kurz erklären, was das denn bitte
asymmetrische Netzwerke ist. So eine natürliche
Asymmetrie in dem Verhältnis
von wie viel Daten kommen rein, wie viel gehen raus
bei Web. Weil es kommt halt
einfach viel weniger rein, als raus geht.
Ja.
Also ein Request ist viel kleiner als die
Antwort auf ein Request. Antwort auf ein Request ist viel größer.
Üblicherweise ja.
So, das heißt
genau, dieses...
Deswegen haben bis bei DSL,
also wenn man halt sich überlegt, okay, wie kann ich denn jetzt
das halt
noch okay aussehen lassen, obwohl es eigentlich nur Klingeldraht
ist, dann macht man das halt so asymmetrisch.
Und auf der anderen Seite
hat man diese Asymmetrie aber auch.
Und das kann man dann jetzt
dann halt zum Beispiel so nutzen, dass man
dass man halt
irgendwie das rausgehende Interface
ist halt einfach viel dicker als das reinkommende.
Weil reinkommen tut ja nicht so viel.
Und dann kannst du zum Beispiel auch... Also wenn du jetzt so viel
Traffic hast, dass du den eigentlich gar nicht mehr loadbalancen
könntest, weil das ist zu viel
für... Damals war das halt
ein Gigabit oder so. Mehr
kriegte man halt nicht hin.
Und ja,
so, heute geht wahrscheinlich ein bisschen mehr, aber
so, das geht halt nicht.
Dann ist es aber kein Problem, weil ich muss ja nur
den reinkommenden Traffic loadbalancen können.
Und der rausgehende Traffic, der
geht halt dann über so ein Fake
Interface
raus und das landet dann halt alles
irgendwie... Und das kann halt dann deutlich dicker sein.
Das ist dann kein Problem.
Also sowas geht dann ja alles schon nicht mehr.
Das kannst du gar nicht mehr machen, weil...
Also du musst ja dann alle gleich behandeln können.
Und der Loadbalancen geht ja auch nur so,
also es kann ja nicht so sein, dass beim Loadbalancing
oder ich denke mal, so in Kubernetes
kann es ja nicht sein, dass die Pakete über den einen
Weg rein und auch über den anderen Weg rausgehen oder sowas,
was man ja an der Stelle gerne halt...
Das wirst du ja vielleicht über
Netzwerk-Policies schon irgendwie hinkriegen.
Ich weiß es nicht, aber mir scheint das so, als ob das
irgendwie da implizit mit drin wäre,
dass das irgendwie alles schon egal ist,
wenn das über das Netzwerk geht. Das ist kein Problem.
Ja, Netzwerk hast du ja immer genug.
Ja, genau. Das glaube ich nicht.
Also, dass das keinen Unterschied macht,
ja, also
okay, ich weiß es nicht, aber ich habe
so den Verdacht, dass das dann doch vielleicht irgendwann liegt.
Ja, aber...
Es tropft und abölt und...
Eine sehr schöne Sache ist halt, dass du wirklich
diese Trennung hast zwischen...
Also aus...
Ich bin ja als Softwareentwickler,
bin ich ein Anwender von dem System.
Und ich kann einfach
den Betrieb des Systems wegdelegieren.
Und ich kann sagen,
hier, ich gehe zu Amazon und kaufe mir
einen Managed...
Kubernetes-Cluster. Oder ich gehe zu
Azure und kaufe mir einen Managed-Kubernetes-Cluster.
Und dann ist es sehr einfach.
Ich kann dann einfach sagen, hier sind meine Workloads
und sorg bitte dafür, dass das läuft.
Und brauche mich darum einfach nicht mehr kümmern.
Und klar, bezahle ich da zu viel.
Das ist bei Amazon immer so, ja.
Ja, ja, aber gut, okay, verstehe ich auch,
dass das Sinn machen kann, weil...
Aber es macht mir einfach eine Sache weg.
Wenn mein Business halt viel Geld umsetzt
und ich dafür gar nicht so viel IT brauche
und ich damit keine Schmerzen haben möchte
und sage, okay...
Ja, oder auch eine Trennung.
Okay.
Du kannst eine Trennung machen
zwischen den Leuten, die die Computer betreiben,
die sich um so unangenehme Sachen
wie Strom und Wärme kümmern müssen
und wer da dran darf.
Und du hast die Entwickler,
die eigentlich das als abstrakte
Computergrößen sehen und wie viele
Milli-CPUs du da brauchst.
Ja.
Das ist schon für...
Aber wieder, ja, wieder für ein Unternehmen
einer gewissen Größe.
Ja, ja, klar.
Und ich möchte nicht zu Hause
auf meinem Raspberry Pi
oder auf meinen Raspberry Pis
einen Computer kümmern,
weil ich einen Kubernetes-Cluster betreiben müssen,
bloß weil ich da ein Power-VM starten möchte.
Das mache ich halt händisch, ja.
Oder mit irgendwelchen Tools,
die dann dafür geeignet sind.
Und das ist eigentlich so,
das finde ich so das Problem
an diesen ganzen Enterprise-Sachen.
Ja, ja.
Lohnt sich das überhaupt für diese Situation?
Und es gibt viele Situationen,
in denen Kubernetes eingesetzt wird,
in denen es sich einfach nicht lohnt,
weil die Last nicht groß genug ist,
weil die...
Weil die Inhomogenität nicht groß genug ist.
Wenn du tausend identische Maschinen starten möchtest,
gibt es einfachere Wege.
Wenn du 50 Maschinen starten möchtest,
gibt es einfachere Wege.
Du musst kurz so einen kleinen Elevator machen.
Warum?
Ja, es gibt ja ganz viele Workloads,
die sehr computer-heavy sind.
Wir hatten mal so ein...
Ich war mal in so einem Projekt in Norwegen,
wo wir einfach eine Berechnung durchführen mussten
und wir hatten nicht viel Zeit
und wir hatten aber terabyteweise Daten.
Und eine Möglichkeit, die du da hast,
ist halt, das zu verteilen.
Du sagst, okay, wir nehmen halt mehr Computer,
weil du mehr CPUs brauchst.
Und diese Arbeitslast
oder diese Dinge, die wir berechnet haben,
die waren auf jedem Computer gleich.
Das heißt, das ist dann sehr einfach,
in Ansible zu gehen oder in Salt
oder in Terraform oder in sonst was
und halt nicht nur eine Host-Adresse zu hinterlegen,
sondern 100.
Und dann auf diesen 100 Hosts
oder 1000 IP-Adressen,
1000 IP-Adressen zu hinterlegen, ja.
Und zu sagen, starte bitte auf allen diesen Rechnern,
in diesem Inventory, diese Workload.
Da brauche ich keinen Kubernetes dafür.
Ja, aber die müssen ja trotzdem irgendwie das I.O. kümmern.
Also wo kommt das halt her?
Ja, gut, klar, das musst du dann immer noch managen.
Aber das ist dann bei allen gleich.
Und das ist das, worauf ich raus möchte.
Wenn du 1000 identische Dinge hast,
dann reicht ein Ansible.
Und das ist auch nicht mal kompliziert,
weil die alle gleich konfiguriert sind.
Das...
Kubernetes hat einen bestimmten Anwendungsfall
und der ist, du hast viele verschiedene Workloads,
die aber alle Compute-ähnlich sind
auf vielen verschiedenen Maschinen,
die aber Compute-ähnlich sind.
Das muss man noch mal genau erklären.
Auf vielen verschiedenen Leuten.
Also vielleicht so ein reales Beispiel.
Und am besten, am besten...
Also auch das, würde ich denken, geht eigentlich noch sehr gut.
Es sei denn, du hast jetzt noch...
Die Software läuft auf sehr unterschiedlichen Betriebssystemen,
in sehr unterschiedlichen Alterungs...
Ja, von vielen verschiedenen Teams.
...Verwesungsstufen auf verschiedenen Teams,
weil dann, sodass du halt nicht sagen kannst,
ah, ich deploye das jetzt auf eine homogene Geschichte,
sondern man sagen muss, das geht nur mit Docker,
das geht nicht anders, weil das halt einfach zu unterschiedlich ist.
Ja, aber das machen Entwickler sowieso.
Ja, das machen wir nach Docker, nur du willst das nicht.
Na gut.
Ja, aber dann verstehe ich das.
Also wenn man sagt, okay, ich mache hier auf der einen Seite
irgendwie, keine Ahnung, ein Headless-QT
in einer sehr alten Version,
weil ich das für irgendwas sehr Spezielles brauche.
Und hier habe ich jetzt irgendwie, keine Ahnung,
ein aktuelles Nix-OS und da habe ich hier ein Debian
und das muss ich aber alles gleich auf dem gleichen Klasse.
Und Java 17 und 18 und 21 und 8 und 2.
Ja, und für alte Sachen, weil da sind alle Programmierer schon gestorben,
da muss ich das, muss ich aber weiter betreiben.
Deine Kobo-Docker-VM.
Ja, ja, okay, okay.
Dann, ja.
Eine AS400-Docker-VM.
Ja.
Ja, also das ist...
Also nochmal, Anwendungsfall bitte noch einmal.
Du wolltest das kurz nochmal erläutern.
Also was denn da...
Ganz heterogen sind.
Okay, aber...
Ja, also zum Beispiel Google, ja.
Google betreibt 35.000 verschiedene Services
auf ihren 8 Millionen Computern oder was weiß ich.
Und dann ist das großartig,
weil dann kannst du einfach sagen,
okay, es gibt jetzt eine Mannschaft,
eine große Mannschaft, die sorgt dafür,
dass diese Computer laufen und ans Netzwerk angeschlossen sind
und dass die in den Kubernetes-Cluster eingeordnet sind
und das ist deren Spezialität.
Und auf der anderen Seite hast du eine Mannschaft von Softwareentwicklern,
die halt auf diesem einen großen Computer,
diesen Kubernetes-Computer-Workloads starten dürfen.
Also die da VMs starten dürfen.
Und zwar egal, welche sie wollen, ja.
Und klar, wenn du 5.000 verschiedene Teams hast,
die eben diese 5.000 verschiedenen Sachen starten,
dann ist das großartig.
Dann willst du nicht mehr jedem einzelnen Entwickler sagen müssen,
okay, du kriegst jetzt die VM und du kriegst die VM
und du kriegst die VM.
Sondern du willst einfach sagen...
Wir machen einfach einen großen Computer-Mischmasch
und einen großen Kubernetes-Cluster
und hier ist dein Quota
und innerhalb des Quotas darfst du machen,
was du willst.
Bist du verantwortlich.
Das heißt, du hast einfach diese Trennung
zwischen den Computern, die das betreiben
und der Software, die da laufen soll.
Und wo die dann läuft,
das kannst du ja meistens gar nicht sagen.
Du kannst meistens gar nicht sagen,
ich habe jetzt hier einen Pod,
also eine Docker-VM,
die hier laufen soll.
Du kannst vielleicht sagen,
die soll in einer bestimmten Zone laufen
oder in einem bestimmten Cluster
oder in einem bestimmten Datacenter.
Aber manchmal nicht mehr das, ja.
Wenn du einen Kubernetes-Cluster hast,
der über viele Datacenter verteilt ist,
dann...
Kannst du höchstens noch sagen,
du willst, dass die möglichst weit voneinander entfernt sind
oder du willst, dass sie möglichst nah aneinander dran sind.
Aber wo die dann laufen...
Ich hätte gern mehr...
Das ist diesen Schalter,
den muss doch...
Ich hätte gern mehr Netzwerk-Latenz.
Das ist doch immer gut.
Größere Zahlen besser,
mehr Netzwerk-Latenz hinter meinen Microservices.
Das muss einfach...
Das muss doch Spaß machen.
Und ganz ehrlich,
für mich als Anwendungsentwickler
ist es auch völlig egal, wo das läuft.
Solange das halt läuft.
Ja, ja.
Na, also ich weiß nicht.
Ich habe halt doch...
Von der Erfahrung her würde ich...
Es gibt halt Infrastruktur,
die gut funktioniert.
Und es gibt halt Infrastruktur,
die nicht gut funktioniert.
Und das hat,
meiner Erfahrung nach,
weniger damit zu tun,
ob man jetzt Kubernetes verwendet
oder, keine Ahnung,
irgendwas anderes,
sondern eher damit,
welche Leute die betreiben.
Ich sage zum Beispiel...
Oh Gott, das hört sich so an wie...
Ihr seid alle blöd
und ihr könnt es nicht.
Ja, aber mit dem Alter...
Also das ist halt auch sowas.
Ich weiß nicht,
vielleicht werde ich auch einfach alt.
Das kann auch sein.
Aber früher hätte ich gedacht...
Oh je, du willst wissen,
wo deine Programme laufen.
Nee, ja.
Also früher hätte ich gedacht,
also Prozesse,
beim Softwareentwickeln Prozesse,
ganz wichtig.
Und das total...
Wenn man es richtig macht,
dann ist das voll gut.
Und wenn man es falsch macht,
dann ist alles eine Katastrophe.
Und irgendwie Engineering total super,
wenn man da halt nur die richtigen Tools verwendet.
Und dann geht alles super.
Und wenn man halt das Falsche macht...
Und heute denke ich mir eher so,
ja gut,
die Sachen, die ich gesehen habe,
die wirklich gut funktioniert haben,
teilweise war das Engineering sehr grottig.
Möglicherweise auch deswegen,
also einfach von der Zeit her geschuldet,
weil man hatte nichts Besseres.
Also ich, wie gesagt...
Wir hatten ja damals nichts anderes.
Wir hatten, also ich kann mich noch erinnern,
ich sage vielleicht besser nicht bei wem,
aber da lief die ganze Operations-Geschichte
halt über Shell-Skripte,
die von einem gemeinsam gemounteten
NFS-Ding halt liefen und so.
Wo man sich sagt,
oh mein Gott,
das ist ja alles total schrecklich.
Aber das war es nicht.
Es war ziemlich cool.
Das hat richtig gut funktioniert.
Das hat richtig gut funktioniert alles.
Es hat richtig,
auch mit richtig vielen...
Da habe ich selber ein Proto-Kubernetes gebaut.
Ja, das war kein Kubernetes.
Das war irgendwie...
Und die Shell-Skripte waren auch teilweise ein bisschen...
Aber es war...
Das hat richtig gut funktioniert.
Und ich habe auch schon Kubernetes gesehen.
Auch große Infrastruktur,
großes Unternehmen mit groß viel...
Und das war scheußlich,
weil man hatte...
Also dieses Versprechen wurde nicht eingelöst,
dass halt man sich nicht mehr darum kümmern muss,
sondern ein größerer Anteil der Zeit,
als ich das gemacht habe,
als ich mir oft hätte,
muss ich mich damit verbringen,
warum der Kram denn jetzt nicht so funktioniert,
wie ich mir das denke
und was denn da jetzt das Problem ist
und warum ich das nicht sehen kann,
was da das Problem ist,
weil ich es nicht darf.
Da musst du so ein bisschen ranchern oder so.
Ja, genau, weil du es nicht darfst.
Weil du es nicht sollst
und deshalb darfst du es auch nicht.
Ja, und dann versuchen wir mit den Leuten zu reden,
die verantwortlich sind
und dann denkt man sich so...
Und Performance und Latenz sind auch so Sachen,
wo du halt einfach plötzlich viel weniger Einblick reinhörst.
Ja, genau.
Man sieht einfach viel weniger,
was ja kann ja ein Feature sein,
aber...
Ja, klar.
In vielen großen Organisationen ist es ja ein Feature.
Du willst die Leute nicht zu nah
an die gefährlichen Dinge ranlassen.
Also lieber schlecht betrieben,
als gar nicht betrieben.
Ja, aber...
Operation ist Schlüssel.
Also es wäre einfach so,
es ist halt,
wenn das Leute sind,
die das betreiben,
die das halt irgendwie,
denen das Spaß macht,
die da Interesse dran haben,
die das irgendwie auch versuchen zu optimieren,
die sich da reinfuchsen oder so,
dann kann es sein,
dass die halt auch,
keine Ahnung,
mit einem Stock und einem Feuerstein
irgendwie den Raum warmen.
Kriegen, ja?
Während halt irgendwie,
also keine Ahnung,
dann irgendwie,
weil es gibt halt Leute,
die nehmen halt den Schaufelradbagger
und baggern halt das falsche Dorf weg.
Ja, das ist halt irgendwie so,
das muss nicht unbedingt dann besser sein,
wenn man ein besseres Tool hat,
wenn man halt,
wenn die falschen Leute das steuern.
Das ist halt, ja.
Das ist aber so ein bisschen eine Tautologie,
oder Jochen?
Also die guten Leute kriegen Dinge gut hin
und die schlechten Leute kriegen Dinge schlecht hin.
Ja, aber ich glaube,
aus so einer 10.000 Fuß irgendwie,
weiß ich nicht,
Übersichtsperspektive,
sieht das halt zu einfach aus.
Das sieht halt so aus,
wie wir machen das,
was alle machen
und das funktioniert dann schon.
Wir haben auch viel Geld ausgegeben jetzt.
Ja.
Dann muss das auch gut sein.
Ja, aber vielleicht funktioniert es auch nicht.
Und zwar aus anderen Gründen,
als man jetzt sagte.
Also ich muss sagen,
aus Anwendungsentwicklersicht,
ich finde es sehr angenehm,
weil ich einfach nur noch sagen muss,
hier ist ein Docker-Image,
sorgt dafür, dass das läuft.
Ja.
Und dann.
Der Rest ist dir egal.
Der Rest ist mir egal, ja.
Du hast einen Passierschein unterschrieben.
Irgendjemand anders ist dafür verantwortlich.
Ja, aber was passiert denn,
wenn das nicht,
also funktioniert das dann tatsächlich auch?
Also ich meine,
dann wäre das ja wahrscheinlich ein Fall für,
das betreiben dann halt auch Leute,
die sich da irgendwie.
Ja, Amazon, AWS.
Ja, aber okay.
Ja, die können das wahrscheinlich sogar.
Azure, ja, ist genauso.
Ja, da habe ich dann schon häufiger gehört,
dass das vielleicht dann.
Kriegt man bei Google Compute
oder bei Google Cloud,
kriegt man da auch Kubernetes-Kluster?
Ja, ja.
Kriegt man da auch Kubernetes-Kluster mit?
Okay.
Ja.
Wäre ich mir jetzt aber nicht so sicher,
ob die gut sind.
Weiß ich auch nicht.
Also bei Azure habe ich auch schon gehört,
dass da waren Leute auch nicht so,
so etwas unter.
Ja, gut.
Dann bezahlst du halt bei dem großen A,
zahlst halt auch den Premium-Preis.
Ja, das ist schon alles nicht günstig.
Aber es ist halt die Frage,
wenn man das eh bezahlen kann.
Egal.
Ja, genau.
Möchtest du vielleicht noch einen Manager haben,
der vielleicht nicht so technisch affin ist,
der aber dann so ein Load-Binding-Scene
mal kurz in einem Web-Interface hochschieben kann,
weil der gerade eine Spitze am Wochenende erwartet oder so?
Ja, das ist aber so ein bisschen der Trend, oder?
Dass du weggehst von den eigenen Data-Centern
und hin in die Cloud.
Ja, das ist ja das Versprechen der Cloud,
dass das jemand anders für dich besser managt.
Ich.
Ich unterschreibe das nicht immer so.
Und ich glaube auch nicht,
dass das immer eine gute Idee ist,
in die Cloud zu gehen.
Und ich glaube auch nicht,
dass es immer billiger ist,
in die Cloud zu gehen.
Ganz im Gegenteil.
Ja.
Aber es ist der Trend gerade.
Es ist der Trend weg vom eigenen Data-Center hin zu.
Das Hauptproblem ist halt,
wenn du eine Konzernstruktur hast
mit einer sehr heterogenen Infrastruktur-Welt,
dann ermöglicht dir halt dieser Weg in die Cloud
eine Homogenisierung deines ganzen Geschäfts.
Ja, aber für Geld.
Ja, natürlich für Geld.
Und danach kannst du vielleicht wieder hingehen
und kannst es wieder machen.
Und kannst es wieder lokal machen.
Aber diese Fortentwicklung quasi,
dass halt diese ganzen heterogenen Teams
alle abgelöst werden müssen durch was Neues,
da verlierst du natürlich Know-how.
Es ist vielleicht auch.
Aber du kannst halt so Prozesse,
Skaleneffekte erzeugen irgendwie.
Und dann vielleicht doch merken,
wo du halt was nicht mehr so brauchst.
Ja, ich weiß nicht.
Also dieses Skaleneffekte erzeugen klingt ganz falsch.
Ja, das hört sich immer gut an.
Also ja, das klingt gut.
Das hört sich in so Business-Präsentationen immer gut an.
Aber funktioniert das wirklich?
Also da habe ich so meine...
Ich glaube tatsächlich,
dass das so eine Cost-Center-Frage ist.
Naja, aber ich glaube,
du kriegst halt die Leute dazu,
dass sie dann das alles Gleiche machen müssen.
Du fährst halt dann vier Hunden runter,
was du halt vorgemacht hast,
selbst wenn es gut war, möglicherweise, ja.
Aber du hast alle auf dem gleichen Stand.
Also du würdest sagen,
der kleinste gemeinsame Nenner ist immer noch besser,
als wenn du...
Nein, das würde ich nicht sagen.
Das kann notwendig sein für bestimmte Dinge halt.
Also auch für eine Bewegung.
Weil das Problem ist ja,
dass du gerade in so Konsensusstunden
oft so Silos hast, die sich halt bilden,
die politisch sind
und die sich nicht mehr aufbrechen lassen,
außer mit Gewalt.
Und das ist halt eine der Methoden...
Ja, soziale Probleme mit Technik lösen.
Wertes Prinzip funktioniert immer super.
Ganz einfach.
Ja, aber du hast diese Silos halt tatsächlich aufgebrochen
und du brauchst halt dann tatsächlich,
musst du halt wieder von vorne anfangen.
Du kannst das wieder neu bauen, ne?
Ja, es kommt wahrscheinlich drauf an.
Aber ich würde auch,
ich würde immer dazu sagen,
also klar, okay,
das mag sein, dass das alles super ist
und es kann sein,
dass das, wenn man das an AWS oder sonst wen gibt,
dass es dann besser ist,
als das, was vorher da war
und dass man diese...
Ja, vielleicht.
Kann alles sein.
Vielleicht ist das dann auch super viel besser als vorher.
Und wenn du so Spitzen hast,
kann es ja auch sein,
dass du da mehr machen kannst,
als du vorher machen kannst.
Ja, weil du halt einfach
ungeheuer viel Kapazität jetzt kurz...
Aber ich würde immer mit dazu sagen wollen,
dass es halt auch so Dinge gibt,
wie eben Stack Overflow zum Beispiel,
die das halt in einem halben Rack machen.
Ja.
Und einer der Gründe,
warum sie das können,
ist halt,
dass da jemand irgendwie
ein totaler Switch-Nerd ist
und sich halt mit dem Netzwerk-Kram auskennt.
Und das wäre...
Das kannst du nie...
Dieses System kannst du in keine Cloud deployen,
weil die hat halt die Hardware nicht.
Und die haben auch nicht die Kenntnisse
über das, was man da...
Die können das nicht.
Willst du damit sagen,
die können das nicht?
Ja, bei bestimmten Sachen,
die man da so in den Spannungsnäht,
wenn die irgendwie so ein Redis
irgendwie im Nisch dahin hängen,
dann müssen die manuell hingehen
und dann musst du eine halbe Stunde warten,
weil irgendjemand da runter rennt
und das Rack reinschiebt oder so, ja.
Ja, das ist dann vielleicht noch viel schlechter.
Ja, man muss ja planen vorher.
Ich glaube auch,
Stack Overflow ist inzwischen tatsächlich
irgendwie irgendwo hin in eine Cloud umgezogen.
Insofern kann ich das auch vielleicht
nicht mehr als Beispiel...
Nicht mehr das beste Beispiel.
Aber sagen wir so,
für viele, die halt unterhalb
der Google-Größe sind
oder, weiß ich nicht,
konzernpolitische Probleme haben.
Gibt es so kleine?
Könnte sein,
dass manchmal vielleicht der eine oder andere
hat schon mal sowas gesehen.
Was mich ja auch noch interessiert,
also ich meine,
hey, dann haben wir jetzt
so ein Managed Criminalist Cluster
irgendwie gemietet,
aber wie kriege ich denn vom Entwickler
den Pod dahin?
Ja, da gibt es verschiedene Möglichkeiten.
Ah ja, Moment,
aber jetzt sind wir ja irgendwie
wieder bei so einem anderen Thema.
Das müssen wir irgendwie
so eine Kette haben,
so eine CI,
die das dann baut
oder das dahin deployt
oder auf dem Branch.
Nee, da gibt es wieder
verschiedene Möglichkeiten.
Also ich meine,
du kannst es natürlich
prinzipiell manuell machen.
Yay.
Großartig.
Ist auch genau der Verwendungszweck.
Ja, genau.
Von so einem völlig
automatisierten System.
Ey, einmal bitte hier
diesen Pod bitte neu.
Dann musst du halt einmal starten.
Oder du hast ein CI-System,
ja, was das dann halt irgendwie
einen Push.
Oder du hast ein Jenkins-System
oder du hast ein was-weiß-ich-System.
Wo kriegt man dieses CI-System her?
Das kannst du auch mieten.
Ja, ach so.
Automatisch.
Du betreibst es
auf deinem Kubernetes-Cluster.
Aha.
Ach so, das ist ein Drone.
Habe ich tatsächlich gesehen.
Also ich meine,
dass du Jenkins
auf einem Kubernetes-Cluster startest.
Oder ein Drone-CI oder sowas?
Ja, oder irgendein CI.
Ja, da gibt es halt tausende.
Egal, genau.
Da gibt es ganz viele.
Also das ist dann,
also nochmal,
ein CI ist noch wie
so ein anderer Server,
auf dem eigentlich
nichts anderes passiert.
Also irgendwie sind so
Diplom-Skript-Ablaufen oder?
Ja, das kommt drauf an.
Also ich meine,
kann man auf verschiedene Arten
und Weisen verwenden.
Das Erste, was du machst,
ist ja Continuous Integration.
Ja.
Das heißt,
da hast du auf jeden Fall
deine Tests laufen
und deine Checks.
Und dann musst du eigentlich
noch irgendwie.
Also die Integration heißt ja nur,
dass du immer
eine getestete Version hast.
Und der nächste Schritt
ist dann Continuous Deployment.
Delivery, oder?
Delivery oder Deployment.
Ich meine Delivery.
Irgendwas mit D halt.
CD, C-I-C-D.
Dass du eben diese
Continuous Delivery
oder Deployment machst.
Wo du halt sagst,
gut, jedes Mal,
wenn eine fertig gebaut ist
und korrekt,
korrekt getestet,
dann kannst du ja auch
gleich ausrollen.
Aber ich frage jetzt halt,
wer sagt denn genau,
korrekt getestet?
Sind das nur die automatischen Tests,
die durchlaufen müssen
oder muss noch irgendwie
mal das abnehmen?
Ja gut, es kommt drauf an.
Kommt drauf an.
Aber muss noch jemand
auf den grünen Knopf drücken
oder nicht?
Okay, aber das ist genau der Punkt,
da muss halt so verschiedene Systeme
dann gebaut werden.
Das muss ja dann
irgendwer dann wieder übernehmen
und das muss halt dann eigentlich,
wie das halt gestartet wird.
Also ich würde sagen,
ideal wäre es,
du hast einen Production Branch
irgendwie und du pushst dann irgendwie
und dann gibt es eine Action
auf deinem GitHub
oder auf deinem GitLab,
die dann das Ding anspricht.
Ja, das ist ja schon
sehr spezifisch.
Das ist viel zu spezifisch
für deine Umgebung.
Da gibt es viele,
da kann ich mir viele
verschiedene Umgebungen vorstellen,
wo das sowas nicht geht.
Oder wo du es auch
nicht machen darfst
oder wo du es auch
nicht machen kannst.
Oh, wie machen wir das denn dann?
Ja, mit anderen Prozessen.
Ja, aber davon hat doch
vorhin geschrieben drüber,
dass du Prozesse haben musst
und dass das dann,
wenn du genügend Prozesse hast.
Ja, aber das ist ja genau der Punkt,
da muss er sich irgendwie
dann umkümmern,
da muss er ja dann was machen,
da brauchst du ja wieder
Also, sag mal so,
das kann auch
ein Entwicklungsteam machen.
So ist es ja nicht.
Ja, aber du brauchst halt
ein Team, genau.
Und du brauchst halt jemanden,
der sich damit auskennt.
Auf jeden Fall muss das
ein Entwicklungsteam sein.
Wenn das aber jemand
sich damit nicht auskennt,
dieser ganze Quatsch
irgendwie gar nicht da ist,
wie, ja, dann hast du
das Problem.
Ja, gut, also wie gesagt,
alleine möchte ich das
nicht betreiben müssen
und alleine möchte ich es
mir auch nicht ausdenken müssen.
Aber als Entwickler
in einem großen Konzern
ist das doch bequem,
weil da gibt es ja die Leute
schon, die das machen.
Ach, da gibt es die schon?
Ja, klar.
Oh ja, wirklich?
Außer du bist in der Abteilung,
die das macht.
Dann kannst du noch nicht.
Ja, DevOps.
Aber dann ist es besser auch,
irgendwas, was du kannst.
Irgendwer kann bestimmt
DevOps oder so.
Nee, das ist ja tatsächlich
mehr Ops.
Das ist ja nicht DevOps.
Nicht DevOps, nur Ops.
Das ist ja nur Ops, genau.
Du sorgst ja nur dafür,
dass der Cluster da ist
und auch funktioniert.
Die DevOps-Schicht
ist ja eine oben drüber.
Ja, aber das CICD
ist DevOps, oder?
Ja, genau.
Aber das ist ja
in den Anwendungsteams,
weil die entscheiden müssen,
was zu ihnen passt.
Aber wenn du jetzt
nur Devs hast,
die kein Ops können,
dann ...
Ja, gut.
Aber das musst du
auf der Scale,
wo du so einen Cluster einsetzt,
musst du davon ausgehen,
dass du dann halt auch
das machen musst.
Ja, genau.
Aber das ist genau der Punkt.
Ich glaube,
das ist bei vielen so.
Die denken halt,
hey, ich kaufe mir jetzt
so einen Managed Kubernetes Cluster
und dann habe ich ...
Ja, muss ich gar nichts mehr machen.
Genau.
Und dann die Arbeit,
das passt schon irgendwie.
Und die vergessen diesen ...
Ja, gut.
Das kann auch gut
und schlecht sein, ja.
Also das,
was ich vorhin meinte
mit dieser Cost-Center-Mentalität,
dass du halt sagst,
okay, früher haben wir
ein Data-Center betrieben
und es war so teuer
und heute betreiben wir Cloud
und dann ist das verteilt
auf die Teams
und jedes hat seinen Quota
und dann muss jedes Team
die Kosten tragen
und ist selber verantwortlich.
Und die Kosten sind aber
immer noch da
und die sind höher.
Nur hast du sie jetzt
anders verteilt,
sodass du sie nicht mehr
in einer Spalte siehst,
sondern halt im Team
auf die Teams
oder auf die Anwendung
oder wie auch immer du es spielst.
Ja, aber dann hast du
im Controlling
die Aggregationsspalte vergessen.
Ja, genau.
Beziehungsweise die ist halt
jetzt woanders.
Die ist nicht mehr
im Data-Center-Kosten-Center,
sondern im Development-Center.
Das ist halt da möglicherweise
eine ganz andere Seite
der Bilanz halt.
Ja, aber das ist ja eigentlich
vom Controlling ja eher so Fail,
weil eigentlich müssen ja auch
Tickets und das hier
irgendwie erlöst werden.
Ja, aber das ist real.
Ja, ja, ich glaube auch,
solche Fails haben
reale Konsequenzen.
Also ob du das jetzt,
also genau,
es kann sein,
dass auf der einen Seite
Am Ende des Tages
bezahlst du es ja auch immer noch.
Du zahlst halt irgendwie
einen guten Teil
deines Umsatzes
an Amazon
oder an Microsoft
oder so
und du zahlst halt
und das wird verbucht
als Investition,
die halt,
wo irgendwie Geld zurückkommt,
was falsch ist.
Ist ja auch so.
Also vielleicht, ja.
Beziehungsweise du könntest
dir weniger investieren
und könntest trotzdem
genauso viel umsetzen.
Und auf der anderen Seite
sieht das so aus wie,
oh, das ist halt,
das sind halt bloß Kosten,
die da rausgehen und
Da brauchst du Leute,
die da hingehen
und ein Gebäude,
das ist ja sowieso tote Kosten
und dann brauchst du Hardware
und was machst du mit der
nach zwei Jahren,
wenn du die nicht mehr
verkaufen kannst?
Strom und Kühlung
und diese ganzen Kosten,
die der da hat.
Du musst halt irgendwie
einen Teil
Das ist doch der klassische
Kauf versus Mieten.
Ja, genau,
aber wo findest du genau
das intern?
Also du bist jetzt mal
ein Konzern, ne?
Du hast jetzt von Tech
keine Ahnung.
Die verkaufen ihr Zeugs
und mieten es zurück
zu einem teureren Preis.
Ja, aber du hast
von Tech keine Ahnung.
Du machst halt irgendwas
anderes und dann musst du
eigentlich so ein,
brauchst du irgendwas
mit Cloud.
Dann hast du überlegt,
okay, du musst jetzt
irgendwie Anwendung,
wir sind jetzt irgendwie
so ein globaler Konzern.
Ja, ja, genau.
Irgendwas mit Cloud.
Das ist ja Buzzword,
Cloud, KI und so,
dies, das.
Und dann sagst du,
ja, okay, dann müssen
jetzt aber schon alle
so modern sein
und ein bisschen Cloud machen
und wenn wir jetzt
aber unser eigenes
Datacenter irgendwie betreiben,
das müssen wir dann
irgendwie offshoren
und das funktioniert
aber auch nicht so richtig,
weil da die guten Leute
irgendwie dann doch
irgendwie nur ja
und dann baust du dann
irgendwie so ein Datacenter
und merkst dann irgendwie so,
ja, wenn wir jetzt
irgendwie in Deutschland
irgendwie sowas bauen,
was ja irgendwie total gut ist,
ist aber schon teuer
und das festigt sich dann
da alles
und könnt ihr jetzt
globaler es betreiben
und die kennen ja
die ganzen Sachen nicht
und wie bieten die das
jetzt für Services
in Brasilien an und so
und dann könnt ihr ja
gar nicht mit denen
und gar nicht kommunizieren
und warum machen wir das
dann nicht alles in der Cloud
und das ist ja total einfach,
einfaches Interface
für alle gleich
und benutzen das dann einfach
und dann haben wir
dieses Controlling-Problem,
dann, ja, brauchst du halt
diese ganzen Sachen nicht mehr,
aber das ist ja tatsächlich,
du musst das nicht
selber vorhalten die ganze Zeit,
du brauchst nicht
das ganze Team vor Ort
an der gleichen Stelle,
das diese ganzen Sachen managt
und irgendwelche Schnittstellen
nach außen anbietet, oder?
Ja, das ist operativ
sicherlich wesentlich einfacher
von Amazon Services zu mieten,
anstatt ein eigenes
Datacenter zu betreiben,
nur ab einer gewissen Größe,
ich meine, es gibt ja auch
Schritte dazwischen,
es gibt ja auch Co-Location
und es gibt ja auch so
Meet-Racks und so weiter,
aber ab einer gewissen Größe
lohnt es sich halt
und ich, und ganz ehrlich,
ich sehe die Vorteile
von vielen von diesen
Cloud-Diensten nicht,
die sind sehr teuer
und die haben viele
so fiktive Vorteile,
ja, aber du kannst
die hochskalieren so viel wie du willst,
ja, gut, okay,
aber ich habe 12 Visitor im Monat
und ich muss niemals
etwas hochskalieren,
ich würde es gerne,
dann machst du Serverless,
noch weiter,
ja, genau, mache ich Serverless,
das kann ich,
die für die gleiche,
die gleiche Latenz
wie vorher,
nur für einen höheren Preis,
voll gut.
Ja, aber da musst du
jetzt nicht die ganze Zeit an sein,
du bezahlst ja nur
für die genutzte Minute.
Ja, gut,
aber dafür muss ich auch
das Ein- und Ausschalten mitbezahlen
und wenn dann mal 100.000 kommen,
dann muss ich auf einmal
alles bezahlen.
Nee, das will ich gar nicht.
Also,
das ist so eine,
ja, da wird ja viel
Buzzword-Bingo gespielt,
ja, und gerade auch so.
Ich verstehe zum Beispiel gar nicht,
warum Amazon,
Entschuldigung,
dass ich nicht gerade noch spreche,
aber nicht einfach so eine
tolle Strategie fährt,
wie zu sagen,
hey, wir könnten
unseren Umsatz hochbekommen,
wir gucken einfach mal
bei allen unseren Kunden,
dann stellen wir irgendwelche
Server in Russland auf
und machen einfach
ganz klasse viele Requests
auf die ganzen Servers,
dass die per Alarm
da angeboten sind oder so
und hauen einfach da mal
so die Quotas so massiv hoch,
weil wir benutzen das alles
einfach mal.
Wenn die mal Geld brauchen,
machen die das vielleicht.
Ja, aber bisher brauchen sie
das noch gar nicht.
Voll einfach.
Du kannst einfach dann dadurch
so deinen Umsatz voll hoch.
Das ist eine gute Idee.
Sie können auch einfach
die Preise erhöhen oder so,
aber das braucht jetzt auch so.
Voll viele Leute nutzen
unsere Sachen.
Und dann merken sie, oh, der kommt ja kein Umsatz mehr raus, oder?
Es gab vor einer Weile so einen Artikel,
ich kann den auch für die Shownotes wieder raussuchen,
dass Amazon Prime,
dieses Video-Hosting, die sind umgestiegen
von Serverless
auf
quasi reservierte Instanzen.
Weil die halt auch so
FFM-Pack-Lasten haben, ja?
Und weil die da auch so Transcoding machen und
das über dieses
Serverless-Verteilte total cool ist, weil
jede einzelne Komponente
des Systems kann einzeln skalieren.
Aber brauchst du gar nicht, weil du hast nur eine in der Mitte,
die halt dick Rechenkraft verbraucht
und dann außen so ein bisschen Gewürz
außenrum.
Aber auch die Abstraktionsleder, die da tolle,
brauchst du eigentlich gar nicht mehr.
Die haben irgendwie ihr Budget um 90% gesenkt und
die Latenzen auch.
Und
das finde ich so ein bisschen gruselig, ja?
Wenn so die Amazon-internen Teams sagen,
also wir wollen das nicht benutzen,
dann ist da doch
schon was im Argen. Aber klar,
also ich meine, das ist ja das Problem bei
diesen ganzen Technologien. Die sind cool und
neu und man will die mal ausprobieren
und auch im Unternehmensumfeld ist es ja so,
die sind cool und neu und man will die mal ausprobieren.
Genau wie bei Kubernetes auch,
ja? Das ist auch cool und neu
und damit kannst du alles das machen, was
Google auch macht.
Aber brauchst du es wirklich?
Ja, also meistens so dieses
wie du sagtest, dieses Deklarative
hat halt was für sich. Man schreibt zwei, drei
Konfigurationsdateien und wenn man sich jetzt ein
Minikube auf dem Server deployt, dann ist auch das relativ
einfach. Da muss man auch dazu sagen, ehrlicherweise
ist es Jammer, was man schreiben muss an
Konfigurationsdateien.
Naja, ist das schlimm?
Ich weiß nicht, ich muss ja immer
an dieses Meme-Bild denken
von dem Typen, der halt irgendwie
vor einem Haufen Soldaten
steht und
die dann
sagen, ja, schieß den oder so
und der so, hey, aber ich kann irgendwie
Kubernetes, oder ich kann
mit Computern Dinge machen
und
dann sagen die, ja, kannst du auch Jammer
für Kubernetes schreiben und dann so, äh, schieß mich
bitte.
Da gibt's auch dieses Bild mit der Schlange
und der Maus,
wo die Maus sagt, bitte friss mich nicht und die Schlange
sagt, nee, ich will dich gar nicht fressen.
Dann sagt die Maus, okay, was willst du denn stattdessen?
Dann sagt die Schlange, kannst du nicht Kubernetes-Engineer
bei uns werden? Dann sagt die Maus, bitte friss mich.
Also,
ich glaube
mit Schlange und Maus, ich glaube, dass das mal ein
Python, eine Python-Metalle
Tafel war.
Jason, genau das, wie man es eigentlich
jetzt machen sollte? Nee, auch nicht.
Ja, ach, alles.
Ist alles nicht so schön. Tommel.
Tommel ist auch nicht schön.
Ist auch nicht schön, aber ist der beste Kandidat vielleicht.
Ihr ist vielleicht nochmal, erklärt bitte kurz den
Unterschied zwischen Jammel und Tommel.
Jammel ist yet another Markup Language
und Tommel ist Toms Markup Language.
Also, die Probleme
bei Jammel sind halt, dass, wenn man da nicht vorsichtig
ist, dann bedeutet halt eine Jammel-Dateiparsen
halt Code ausführen, was
vielleicht für die Leute nicht so klar ist.
Ja, auch so Ambiguitäten, ja, das Norwegen-Problem.
Oh, das tolle
Norwegen-Problem, jetzt musst du noch unterzeichnen, was das Norwegen-Problem ist.
Tops versus Spaces. No, no, no.
Das Norway-Problem. Das No.
Wenn man
eine Liste von Ländern
speichern möchte und dann
dazu die ISO-Länder-Codes verwendet,
dann sind das ja zwei buchstabige
Länder-Codes und das geht bei den allermeisten
Ländern sehr gut, außer bei Norwegen,
weil der norwegische Länder-Code ist
NO und das
von Jammel als FALSE geparst,
weil NO ist ja ein Synonym für FALSE.
Das heißt, du hast dann so eine Liste von Ländern,
Deutschland,
Dänemark, Schweden,
Nein.
Das kann einem auch echt das Deployment kaputt machen,
wenn man das Held da drin hat.
Ja, oder auch
Tops versus Spaces, ja, und generell
so Significant White Space, das ist ja
generell abzulehnen,
gerade in der Python-Welt.
Ja, das ist halt,
Jammel-Problem.
Ja, das ist halt, Jammel-Problem.
Jammel ist halt so eine,
ja, das krankt halt an den
an den gleichen Problemen, die
viele solche Datenbeschreibungssprachen
haben, dass, wenn man
genügend Daten da durchschickt oder wenn
genügend Leute damit arbeiten, dann siehst du ja alle
Ecken und Kanten.
Und wenn die nur so ein kleines
Loch haben, ja, wo sie nicht genügend spezifiziert
sind, dann fallen dir da
gigabyteweise die Daten raus.
Und das ist bei allen
Sprachen so, das ist bei Jason so,
Jason hat seine Probleme, ja,
und auch seine, seine
Ungereimtheiten, ja, es gibt nur Floats.
Ja, es gibt überhaupt
nur so vier Dat-Typen, ne, das ist vielleicht
mancher, also es ist einfach
elegant, oder halt auch
irgendwie. Ja, und auch die Wiederholung,
ja, du kannst nicht, wenn du irgendwie
eine Million gleiche Objekte hast,
dann die alle 10 Byte
benutzen, aber die Keys, die du da halt reinschmeißt,
die sind alle diesen gigabyteweise
Keys reingeschrieben.
Das Komma, keine Kommentare.
Und auch die Pausen-Geschwindigkeit.
Komma und...
Jason Pausen geht inzwischen
quasi schneller, als du
von der Platte lesen kannst. Also da,
ich lese ja mal das Blog von
Daniel
Lemire, ich weiß nicht genau,
wie man das ausspricht, kanadischer
Computer Science.
Ich habe das auch in meinem
RSS-Reel drin, dieses Blog,
aber der schreibt so viele gute Sachen.
Ja, das muss man auch irgendwie mal lesen.
Der war letztens
in irgendeinem, war das in einer
von dem IEEE-Podcast
Software Engineering Radio oder so,
wo er auch drüber geschrieben hat,
geredet hat.
Der hat
SIMD-Jason, glaube ich, geschrieben.
Und wie man
das halt machen kann und wo man aufpassen muss
und man kann Jason
Pausen quasi beliebig schnell hinbekommen.
Also sie waren über mehrere
Gigabyte pro Sekunde und...
Ja gut, aber mehrere Gigabyte pro Sekunde
impliziert ja immer noch, dass du mehrere Gigabyte hast.
Ja, ja, klar.
Und wenn du dann stattdessen Protobuff hast
und nur 100 Megabyte hast, dann ist das natürlich
weniger. Gut, aber sei es drum.
Die eigentliche Aussage
ist ja, jede von diesen Beschreibungssprachen
hat Vor- und Nachteile und jede hat
ihre Krankheiten. Und Tommel ist da nichts anderes.
Tommel ist halt eine relativ
simple Sprache,
so ein bisschen an INI angelehnt,
damit man auch das schön im Texteditor
haben kann und damit du auch schön so
auf quasi Dateiebene das machen kannst.
Aber Jochen, würdest du tatsächlich irgendwo
eine Schnittstelle machen, die Tommel verwendet?
Also würdest du Tommel irgendwo
schreiben?
Ich habe das Gefühl, dass
Tommel sowas ist, so eine Konfigurationssprache ist.
Die wird manuell geschrieben und maschinell ausgelesen.
Ich weiß
nicht, ob ich auf die Idee käme, Tommel maschinell
zu schreiben. Nee, wahrscheinlich nicht.
Message-Spec oder sowas mit Python
und dann eine genaue...
Für automatische Sachen würde ich
eher tatsächlich sowas wie JSON nehmen.
Aber für Menschen
ist JSON halt nicht so toll.
Als die Default-Wahl ist.
Ja.
Und wenn es für Menschen nicht so toll ist,
dann kannst du auch...
XML nehmen.
Ach, Dominik.
Nein, Protobuf oder Message-Spec.
Das würde ich gerne noch...
Wir sind jetzt auch schon ein bisschen dran,
aber das würde ich gerne noch...
Das habe ich versucht zu sagen und habe es
irgendwie 20 Minuten lang nicht hingekriegt.
Und das hat mich irgendwie dann noch verfolgt.
Also XML,
ja, warum das halt...
Also alle jammern immer drüber,
aber warum das
halt unter Umständen eine schlechte Idee ist
oder was überhaupt.
Das ist auch wieder ein schönes Beispiel für...
Das hat mir ja auch schon ein paar Mal...
Warum Abstraktion ist immer so Fluch und Segen.
Das ist immer so schwierig.
Und XML hat halt auch so fiese Probleme.
Warum jammern da Leute immer so?
Und ich habe dann irgendwie gesagt so,
ja, CSV gefällt mir viel besser als XML,
weil ich war ja lange
in diesem Datenexport-Import-Geschäft tätig.
Und nach viel Schmerzen
wurde jedem,
der halt irgendwie an diesem Datenaufbau
Austauschpunkt teilnehmen wollte,
geraten von den Kundenberatern halt immer so,
nimm CSV, nimm nicht XML.
Wir können XML, klar.
Du kannst uns auch XML geben, das geht.
Mach es nicht.
Nimm CSV.
Und ich dachte auch nur so,
ja, ich würde immer CSV vorziehen
gegenüber XML.
Wieso das denn?
CSV ist ja noch viel schrecklicher.
Da ist ja gar nichts definiert und so.
Denn auf Python,
Readability counts?
Nee, das ist gar nicht so der Punkt.
Sondern der Punkt ist eher
dieses Abstraktionsding aus meiner Perspektive
jetzt sozusagen.
Also es gibt möglicherweise auch Anwendungen,
es gibt auch Anwendungen,
nicht möglicherweise, ganz sicher,
wo XML viel besser ist
und wo CSV schrecklich ist.
Aber...
Jochen, du verkaufst gerade alle Zuhörer.
Das ist ganz schlimm, dir zuzuhören.
Haben wir jetzt noch welche jetzt gerade?
CSV ist besser, XML ist besser.
Nein, nein, aber vielleicht schon interessant,
wo dann so Probleme passieren.
Weil oft hast du halt kaputte Prozesse
innerhalb von Unternehmer.
Das hatten wir auch schon.
Und wenn du jetzt XML erzeugst
und das irgendwo hinschiebst,
dann bist du ja gezwungen.
Zum Beispiel, wenn du das auch
gegen eine DTD validierst oder so.
Das musst du überhaupt irgendwie...
Die meisten XML-Schreibbibliotheken
weigern sich halt einfach,
irgendwie was rauszuschreiben,
was halt nicht okay ist als XML.
Das heißt, wenn du irgendwie Mist machst
und dann aber was rausschreiben willst,
dann funktioniert das halt nicht.
Und dann kann es sein,
dass die Probleme,
dass es halt aus einem kleinen Fehler
ein großer Fehler wird.
Und das ist halt das eigentlich üble Problem.
Also sozusagen das praktische Beispiel,
was immer und immer wieder passiert,
ist halt oft sowas wie,
wir kriegen CSV
und dann passieren da so Dinge drin wie,
naja, also ein Teil der Zeilen
ist halt UTF-8 irgendwie encoding verwendet,
ein Teil der Zeilen irgendwie Windows,
ein Teil der Zeilen Latin One.
Großartig.
Großartig kann man sagen,
ja so, naja, das nehme ich nicht.
Das geht nicht.
Das ist irgendwie kaputt.
Ja, kann man machen.
Validiert nicht.
Aber ist halt auch Geld,
das dann verloren geht unter Umständen.
Und ehrlich gesagt,
wenn ich jetzt sage,
so, ich passe jetzt diese Zeile
und dann kriege ich halt irgendwie eine Exception
oder ich weiß nicht,
ich merke halt so,
oh, das ist hier was ganz anderes,
das ist kein UTF-8,
dann zu sagen,
na gut, dann probiere ich halt mal Latin One.
Okay, geht.
Ja, oder so.
Das ist nicht so schlimm.
Das geht, das kann man programmieren.
Das geht.
Ich kann jetzt immer noch parsen.
Ja, selbst wenn solche Dinge passieren wie,
ja, das ist halt jetzt nicht mehr Semikolon
der Spalten-Trenner,
sondern Komma oder Tab
oder da gab es auch nicht so ein Zeichen für.
Husky Separated Values.
Das ist mein eigener,
mein eigener Kreuzzug.
Genau.
Das kann ich auch irgendwie erkennen
und dann kann ich damit irgendwie umgehen.
Und wenn man das halt ein paar Jahre macht,
dann hat man halt irgendwie einen Parser.
Da kannst du gegenschmeißen,
was du willst.
Der passt, ist alles egal.
Geht.
So.
Okay, ist Aufwand und ist hässlich
und macht keinen Spaß,
aber es geht irgendwie.
Und die meisten Probleme bei CSV sind so,
dass man die schon irgendwie in den Griff kriegt.
Man muss halt irgendwie wollen,
aber ja, es geht auf jeden Fall.
Man kann sich aus diesem Problem
wieder rausrecovern.
Bei XML ist es oft so,
dass du Probleme,
halt dann siehst,
aus denen du dich überhaupt nicht mehr rausrecovern kannst.
Wie zum Beispiel,
es kommt halt ein syntaktisch korrektes XML,
aber das ist halt leer.
Und jetzt bedeutet halt leer halt zum Beispiel so was wie,
naja, lösche alle Dinge,
die halt vorher da waren.
Was halt ein katastrophaler Fehler sein kann.
Wo dann Rechtsstreit draus wird.
Update oder Lead.
Ja, so die Frage ist,
was machst du denn an der Stelle?
Du siehst halt,
okay, jetzt kommt hier dieses Ding
und dann denkst du dir so,
okay,
was willst du denn jetzt
als Programmlogik machen?
Willst du sagen,
nö, das führe ich jetzt nicht aus,
weil das kommt mir irgendwie komisch vor.
Landest du im Rechtsstreit.
Du führst es aus,
irgendwie viel Geld geht verloren,
du landest in einem Rechtsstreit.
Du hast nur schlechte Optionen.
Du hast nicht die Option so,
okay, wir machen das Encoding
nochmal ein bisschen anders
und dann versuchen wir das irgendwie anders zu parsen,
dann geht's.
Sondern du bist eigentlich nur bei,
eigentlich wahrscheinlich
müsstest du dann irgendwie alarmieren
oder müsstest du jemanden irgendwie anrufen oder so.
Aber das ist halt auch dann einfach,
das ist einfach Kacke, ja.
Das ist einfach.
Und solche Sachen hast du halt bei,
wenn die Fehler nicht mehr,
also die Idee bei XML ist so ein bisschen,
wenn du auf der syntaktischen,
wenn man sagt halt,
ah, wir haben so viele Probleme
mit diesen Syntax und so,
wir machen jetzt ein Format,
wo das validiert ist,
dass das nicht mehr passieren kann.
Ja, und dann hast du halt sozusagen
mit dieser Art Wacky Mole zu spielen,
ja, dann kommt das Ding halt
an einer anderen Stelle wieder hoch
und zwar auf einer semantischen Ebene,
wo du gar nichts mehr machen kannst
oder wo es viel schwerer ist,
damit umzugehen mit dem Fehler.
Und ja,
das ist halt so ein bisschen mein,
mein Problem mit XML
und dass man das halt,
man kriegt die Probleme nicht so einfach weg.
Es ist,
also wenn da,
wenn da Abteilungen sind
und die eben verwenden alle Excel
und dann in unterschiedlichen Formaten,
dann ziehst du das irgendwie zusammen
und versuchst es rauszuschreiben,
dann, ja,
dann besser,
du schreibst es irgendwie raus
und es ist halt falsch
und du kannst es hinterher noch irgendwie wieder fixen,
als da fehlen dann halt bei zwei Abteilungen,
die fehlen die Daten einfach
und du weißt halt nicht,
was passiert ist, ja.
Das ist so ein bisschen die Debatte
zwischen be lenient with what you accept
and strict with what you don't.
Strict with what you create.
Robustness.
Robustness-Principle.
Ja,
versus Programming by Contract
und wenn du das nicht 100% erfüllst,
dann ist es halt weg.
Ja,
also.
Ja,
schmeiße ich alles weg,
wenn ich halt irgendwie Mist bekomme
auf meiner API,
sage ich harte Begegnungen.
Ja,
oder riskierst du,
dass halt jemand,
die gar nicht benutzen kann,
die API,
weil das ausgründet.
Ja,
vielleicht weiß ich ja noch gar nicht,
was da alles kommen soll.
Vielleicht möchte ich das ja einfach irgendwie
als Zeichenkette konvertieren,
da trotzdem irgendwie reinschreiben
und wieder rausgeben,
wenn da jemand erfragt.
Das heißt,
wenn das irgendwie gar nicht dem entspricht,
was ich eigentlich dachte,
was ich haben brauche.
Das,
das kommt auch so ein bisschen in Wellen,
oder,
dieses Robustness-Principle.
Für eine Weile lang war das total,
ja,
wir akzeptieren alles
und dann hast du so lustige Modibake
in deinem Notepad drin.
Shit in,
shit out,
sagt man ja.
Ja,
ja,
glaube ich.
Internet Explorer zeigt alle auf einmal
alles auf Koreanisch an
und dann schwingt das wieder,
das pendelt wieder in die andere Richtung,
wo alles XML,
XHTML sein muss
und nur wenn das validiert,
kannst du die Webseite auch überhaupt anzeigen
und dann,
dann schwingt es wieder rum
zu HTML5,
wo das so,
ja gut,
wenn da ein HTML5-Teig drin ist,
dann kannst du schon irgendwas draus machen
und,
ja.
Ja,
so,
persönlich ist mir aber das irgendwie,
wir versuchen es irgendwie hinzukriegen,
ist mir sympathischer als,
wir machen jetzt eine Bürokratie
und,
dann fällt uns auch das.
Nein,
der Kunde ist schuld,
der Benutzer ist schuld,
das ist immer die richtige Antwort.
Ja.
Naja.
Ja,
schwierig,
schwierig da auch,
ja.
Wieder wie vorhin,
ja,
es gibt Situationen,
in denen es so ist
und es gibt Situationen,
in denen es so ist.
Ja,
insofern.
Nee,
aber klar,
vor allem,
also ich meine,
viele von diesen Datenschnittstellen
sind ja zwischen,
sag ich mal,
Entitäten,
die mehr oder minder professionell sind
und,
dann ist es halt einfach pragmatisch zu sagen,
okay,
das kann halt sein,
dass die das nicht 100% richtig generieren können
und wie geht man damit um?
Ja.
Und,
ja.
Ja, okay.
Hat jetzt aber nichts mehr
mit Kubernetes zu tun, oder?
Ich wollte gerade sagen,
CubeControl,
nein.
In gewisser Weise,
in gewisser Weise schon,
weil bei Kubernetes
hast du halt auch so eine Abstraktionsschicht,
die dann halt irgendwie,
wo du sagst,
okay,
ich zwinge dich dazu,
dass du sagen kannst,
wie viel Hauptspeicher du denn brauchst,
ne?
Ja, okay, gut.
Und dann kann es sein,
dass du halt ein anderes Problem kriegst,
weil.
Das ist quasi das,
was du vorhin sagen wolltest,
ja?
Genau.
Dass es Situationen gibt,
in denen kannst du gar nicht sagen,
wie viel Hauptspeicher du brauchst.
Also zumindest nicht dauerhaft
oder zumindest nicht so richtig im Voraus.
Oder das,
das ist ein gutes Argument.
ist halt so viel aufwendiger,
als.
Ja, beziehungsweise du überprovisionierst.
Du musst halt einfach quasi
vom Worst Case ausgehen
und der Worst Case ist halt,
alle Menschen auf der Welt
rufen gleichzeitig dieses Video ab
und das.
Das musst du dann auch gehen.
Das musst du jetzt einplanen.
Ja, und das musst du dann halt auch bezahlen.
Ja, genau.
Und das musst du dann auch bezahlen,
weil so viel hast du ja requested.
Also zum Beispiel
so ein Konzertticketanbieter
wäre das vielleicht
ein relevantes Problem.
Ja, oder überall,
wo du es spielst.
Ja, oder überall,
wo du Spitzenspitzen hast.
Es gibt ja überall Saisonalität.
Es gibt ja überall Zeitpunkte,
wo mehr Traffic ist
und wo weniger Traffic ist
und Spannungsspitzen.
Aber das ist ja auch das Versprechen,
das ist ja das Versprechen von Cloud,
dass du diese Spitzen abfangen kannst
für die realen Kosten,
sage ich mal.
Ja.
Weil in dem Moment
mietest du dann halt
mehr Rechenleistung
als in anderen Momenten.
Du mietest ja auf einmal halt
250.000 Rechner,
die du normalerweise brauchst
nur fünf.
Ja, genau.
Aber für das Wochenende,
wo halt dann die Konzertkarten
Genau, wo Taylor Swift
eine Milliarde Dollar
umsetzt,
mit ihren Konzertkarten,
dann bricht dein System
halt trotzdem zusammen.
Weil so war es ja.
Ja gut, aber das,
ja,
das ist so ein bisschen
das eigentlich Frustrierende,
finde ich,
dass man aus technischer Sicht
so viele Sachen sieht,
die man machen könnte
und dann macht aber trotzdem jemand
so viel Geld mit
Shell-Skripten,
die jede Nacht
alles neu starten
und diese Personen,
die sitzen an der richtigen Stelle.
So ärgerlich.
Wir könnten es alles viel besser.
Das war ein Kauf-mich-Vortrag.
Ja, jede Unterhaltung ist,
jedes Gespräch ist ein Kauf-Mich-Vortrag.
Was meinst du,
warum ich immer herkomme, Dominik?
Ach so, natürlich.
Für die ganzen großen Aufträge.
Ja, die ich alle schon
über den Podcast
an Landtag hergezogen habe.
Funktioniert jedes Mal.
Immer.
Also, liebe Zuhörer,
wenn auch Sie Interesse haben
an einem
An einem Pick.
An einem Pick?
Ach so, ein Pick.
Dominik, hast du einen Pick?
Environs.
Kennt ihr das?
Was ist Environs?
Kennt ihr Django Environ
oder kennt ihr
ja,
wie heißt der?
Python.env oder sowas?
Genau.
Das ist was anderes.
Egal.
Also Environ,
ja, nicht ganz.
Environ ist so ein anderes Paket,
wo man halt
Environment-Dateien
lesen kann
oder halt aus der
Environment-Variablen
dann irgendwann
seine Sachen ins Playbook kommt.
Das ist so ein bisschen
anders als Django Environ irgendwie.
Und das macht halt auch sowas,
dass man halt irgendwie,
äh,
quasi
auf das
Environment irgendwie
geordneter Form zugreifen kann.
Genau, also mit
Konvertierung direkt
in die richtigen Datentypen
und sowas.
Ah, okay.
Und ja.
Finde ich ganz nett.
Also, weil Django Environ
habe ich sonst immer benutzt.
Ich versuche gerade alles umzuziehen
und, äh,
ist irgendwie schön.
Ich weiß noch nicht,
ist das einfach, intuitiv
funktionierend?
Du machst ein Env auf
und machst dann Read Env
von den DotFiles,
die du haben willst.
Apropos DotFiles,
wie benutzt ihr es?
Schreibt ihr einfach tatsächlich
Stumpf-Secrets irgendwo rein
oder habt ihr da
irgendwie,
irgendwelche, äh,
Secret-Vaults oder, äh,
es gibt ja noch ganz andere Sachen.
Also man muss ja
irgendwem vertrauen.
Weiß ich nicht,
ob ich das jetzt hier sagen will.
Doch,
und Secrets liegen
auf einem offenen
S3-Packet,
wo nur er
die ID kennt.
Ja.
Nee,
verschlüsselt im Git.
Gut,
das sind zwei
unterschiedliche Probleme, ne?
Einmal,
wie hält man die Secrets,
äh,
vor,
bevor man
deployed hat,
sozusagen?
Äh,
und wie hält man
die Secrets eigentlich,
wenn,
deployed ist,
weil die,
die,
die Applikation,
ja,
irgendwie,
sie kennen muss?
Und dafür können sie ja
nicht mehr verschlüsselt sein.
Ja,
aber das ist doch das DRM-Problem,
oder?
Du kannst eine Nachricht
nicht vor dem Empfänger
verschlüsseln.
Genau,
genau,
genau.
Aber der Empfänger
muss sie auch irgendwie
kriegen,
also wie,
ja.
Ich benutze ja gerade
einen proprietären Service
für,
den ich ganz gut finde.
Aha.
Doppler.
Und,
also natürlich kennen die dann
halt auch die ganzen Sachen,
aber die machen sowas wie
Automatic Rotation
oder sowas,
da musst du nicht mehr
anfassen und du kannst halt
für jeden Entwickler
irgendwie so eigene Sachen
haben,
da musst du einfach nur noch
sagen,
Doppler Lock-In,
Doppler Setup fertig
für so ein Projekt
oder halt Doppler Use
und der schreibt dann,
wenn du willst,
seine Dot-Amps rein
oder so.
Aber,
Moment,
aber da liegen dann
deine Secrets getrennt
von allem anderen,
also auch von deinen
Repositories
und deine Produktionsmaschine
geht halt auch zu Doppler
und zieht da die Secrets
und schreibt sie nochmal
irgendwo lokal hin
oder holt sich die einfach?
Oder zumindest in den Haupt.
Oder du musst auch irgendwie
auf Doppler zugreifen.
Genau,
du musst halt,
du musst,
dieses Secrets
mit dem Token,
das Token,
musst du aber die Applikation
irgendwie kennen.
Das ist dein Master Key.
Ja,
wenn ich den kenne,
dann kann ich
alle deine Secrets abgreifen.
Ja.
Wie schreibst du
dieses Token?
Du machst vorher
ein Hissignor
und schreibst das dann
ins Deployment-Skript.
Du hast ein sekundäres System,
wo dieses Token drin ist.
Genau,
eben,
weil wenn du das schon
ein System hast,
um dieses Secret,
was sehr wichtig ist,
zu deployen,
warum deployst du denn nicht
einfach auch alle anderen Sachen damit?
wo ist jetzt der Vorteil?
also du musst ja,
also du kannst das ja
irgendwie mit,
also ich muss gerade
kurz überlegen,
also wo ist das Problem?
Ja,
also ja,
wie willst du die anderen Sachen
da reinbekommen dann?
Ja.
Also wenn ich jetzt
so ein Deploy-Token hab,
ne,
das halt dann einfach so zugreift
auf die ganzen anderen Keys,
die da irgendwo rumliegen
und die vielleicht
auch rotated sind oder was,
das ist ein Token,
okay,
dann hab ich lesende Zugriff
auf die ganzen Geheimnisse,
aber wenn du die sonst
eh nicht hinschreibst,
weil ich verstehe
den Unterschied nicht,
dann muss ich,
ne,
ich auch nicht,
also mein Punkt wäre halt gerade,
wenn du eine,
dieses Ding muss ja auch geheim bleiben
und wenn du einen Weg haben musst,
wie du dieses Geheimnis
deiner Applikation mitteilst,
warum kannst du diesen Weg,
und geheim hältst,
und geheim,
ja genau,
warum kannst du diesen Weg
nicht benutzen,
um alle anderen Geheimnisse,
die du halt auch hast,
der Applikation auch mitzuteilen,
weil,
ja,
musst du die ja eh haben.
Es ist dieser Weg
oder machst du das einmal
beim Setup?
Manuelle Eingabe einmal
irgendwie mit HIST?
Ja,
man kann sich ja auch
ändern,
also,
also du hast eigentlich
nur die Menge der Secrets,
die du mitgeben möchtest,
verringert.
Ja,
aber,
na,
ich verlege gerade.
Du hast die Secrets komprimiert.
Also du kannst halt zum Beispiel
jetzt GitHub irgendwie sagen,
bei den Secrets steht es drin,
da könntest du aber auch
dann sagen,
du sagst dann halt,
okay,
dann machst du alle bei Secrets,
bei GitHub Secrets.
Ja.
Okay,
ich wollte ja gar nicht,
es ist halt einfach nur so,
es ist ein blödes Problem,
ne,
aber ich,
also was ich tatsächlich mache,
ist ich,
oh doof,
das ist echt doof,
das zu sagen,
ne,
aber.
Don't do it,
erzähl es mir gleich rein,
Geheimnis von später.
Ich habe,
ich habe Sachen oft in,
in Voice drin,
drin liegen und dann,
schreibe ich das halt tatsächlich
in so einen Endfile
und dann hat die Applikation das.
Der Nachteil,
also der Vorteil dabei ist,
es ist eigentlich total einfach,
ich muss mir keine Gedanken machen
über irgendwelche externen Services
oder so,
ich habe auch kein System
neben dem Repository,
es ist alles im Repository drin,
aber halt verschlüsselt.
So,
zack.
Genau,
aber der,
der,
die Nachteile sind,
äh,
tja,
wenn ein Angreifer irgendwie
in meine Applikation reinkommt,
dann.
Ja,
der muss auch da entschlüsseln halt,
einfach dann.
Nein,
nein,
der muss nichts entschlüsseln,
das,
das ist halt das,
was ein Angreifer dann.
In der Applikation ist es ja.
In der Applikation.
Aber das ist ja immer so.
Ja,
aber er hat es halt besonders einfach,
weil,
äh,
er muss einfach nur,
er nimmt einmal
das komplette Environment,
ne,
macht da Jason raus
und schickt es an irgendeinen,
ich hier alle Secrets in,
äh,
alle Environments von allen irgendwie
stormen.
Und dann hinterher guckt er,
ob da vielleicht ein ABS-Key drin war
oder sowas.
Äh,
ja,
aber,
genau,
also,
aber das würde ich sagen,
dass der Nachteil ist,
es ist halt besonders,
also ich,
ich werde,
wenn jemand meine Applikation schafft
aufzumachen,
dann
habe ich ein Problem.
Ja gut,
aber genau.
Er hat ja alle Secrets sofort.
Also Environments macht ja auch nichts anderes
als aus irgendeiner File
oder irgendwie anders die Sachen reinzuschreiben.
Man könnte es ja auch anders machen.
Man könnte ja auch sowas machen wie,
äh,
man packt es in ein
Modul
mit komischem Namen,
äh,
irgendwie
und schreibt das halt als Python-Code
irgendwo hin.
Security by Obscurity.
Und,
äh,
versteht den Kram,
ja,
also,
sag mal so,
wirklich helfen tut es nicht,
weil du kommst immer noch in den Kram ran,
aber die automatischen Dinge,
die halt über irgendwie eine,
es wird eine Sicherheitslücke in Django gefunden
und es,
alle,
es läuft über alle Dinge,
wo man erkennen kann,
oh,
das ist ein Django,
läuft das halt drüber
und holt alle Environments
und damit alle Secrets.
Das ist offensichtlich, ja.
Das wird da nicht funktionieren.
Das ist genauso,
wenn ich den Standard-SSH-Port
auf 2224 ändere,
damit das nicht,
ja,
okay,
es ist Security by Obscurity so ein bisschen.
Was du dann eigentlich machen müsstest,
ist,
dass du irgendwelche Capabilities hast,
also,
dass du die Datenfangverbindung
nicht mehr direkt über Django machst,
wo das Datenbankpasswort drinsteht,
sondern,
dass es da einen getrennten Service gibt,
der ein anderer Benutzer ist,
der eine andere Technologie hat,
den du nicht automatisch mit aufgemacht hast,
der nur von dem Django-System erreichbar ist,
wo du quasi sagen kannst,
ich möchte jetzt eine Datenbankverbindung haben.
Aber,
das ist ja dann auch schon wieder so viel Aufwand.
Ja,
ja,
genau.
Ja,
das ist halt.
Ja,
ich überlege auch noch was.
Andererseits vielleicht fehlt da eine Standardlösung.
Vielleicht fehlt da eine Security-Onion,
um Django außenrum.
Ja,
ich weiß es nicht.
Aber das,
ich überlege immer noch was für diesen
profitären Service spricht,
weil das sind halt verschiedene Sachen,
die halt dann davon getrennt sind,
die vielleicht gar nicht so schlecht sind,
weil,
wenn ich halt aufs Repo zugreifen kann
oder auf die SQL-Server komme,
ich dann trotzdem an die SQLs nicht dran.
Also,
irgendwie,
ja,
ist halt die Frage,
wo liegt denn dieser Key zum
Produktionsdeployment?
Dann kann man ja noch per Netzwerk
irgendwo davon und so.
Na,
ich muss mir nochmal genau überlegen,
was davon der coole Vorteil ist.
Also,
weil alternativ,
die anderen Lösungen finde ich alle
nicht so convenient
und
insbesondere,
also,
es gibt halt diesen
Level von,
ich habe jetzt DevSecrets
für den einen Entwickler,
die anderen als die anderen DevSecrets.
Ich habe noch SessionSecrets,
die stehen alle drin.
Die kannst du einfach mit einem
Kommando aufsetzen,
das funktioniert,
das wird eingetragen
und es ist nutzbar,
es ist übertragbar.
Du kannst einfach,
wenn irgendwie ein Entwickler aussteigt,
kannst du einfach den Account
da rausnehmen oder so.
Das sind alles Sachen,
die ziemlich easy sind
und du kannst automatisch dann halt
so Sachen migrieren und so.
Das ist schon nice.
Und das hast du zum Beispiel
alles bei diesen anderen Walls
nicht mit drin,
da musst du alles selber anfassen.
Ja,
okay.
Okay,
was ist denn dein Pick?
Mein Pick ist ein Artikel
mit dem Titel
An Interactive Intro to CRDTs.
Ich bin ja ein großer Fan von CRDTs,
also Concurrent Replicated Data Types.
Wie sagt ihr dieses Wort?
CRDT.
WTF?
Everpad?
Also ich sage,
keine Ahnung,
Cravities.
Cravities,
ja.
Also,
Conflict-Free Replication,
Resolution-Dependent Data Types,
irgendwie so.
Wo du Datenstrukturen hast,
die sich selbst wieder
in einen synchronen Zustand bringen.
Also sowas wie Etherpad
oder Hedge-Doc
oder Google Documents,
wo zwei Leute gleichzeitig bearbeiten können
und am Ende ist ein Dokument da,
was bei beiden gleichzeitig.
Oh ja,
Google Wave.
Google Wave war großartig.
Live Share.
Ja,
und da gibt es viele Anwendungsfälle dafür
und diese Anwendungsfälle,
und diese Artikel
ist eben eine interaktive Erklärung,
wie diese Datentypen funktionieren
und wie man die umsetzen kann.
Und weil ich CRDTs großartig finde
und jeder sollte die verwenden
und überall
und ich kann es aber auch nicht,
hat mir das sehr weitergeholfen
und ich finde das sehr großartig.
Und es ist auch schön so
mit eben interaktiv.
Also du kannst dann,
hast dann zwei Malfenster
und kannst im einen malen
und kannst im anderen malen
und kannst auch zwischendurch
die Verbindung abschalten
und dann sehen,
wie die sich synchronisieren
und das ist sehr,
sehr schön gemacht
und sehr anschaulich.
Das muss ich unbedingt mal spielen.
Das ist sehr gut.
Das empfehle ich jedem.
Deshalb ist das mein Pick
von dieser Episode.
Ja,
ich hatte ja letztes Mal
etwas gepickt,
was ich in der Episode davor
schon mal gepickt habe.
Du musst jetzt eigentlich zwei.
Es war auch ein sehr leckerer Pick.
Daher dachte ich mir heute,
okay,
mache ich mal etwas,
was ich noch nicht gepickt habe
und etwas,
das absichtlich besonders
unappetitlich und unverdrohlich
daherkommt.
Und das ist,
ich weiß nicht,
ob ihr das kennt.
Man sollte,
man sollte es aber trotzdem
mal konsumieren.
Nämlich
das W-Bock.
Oh,
das Software Engineering
Body of Knowledge.
Genau.
Haben wir doch alle
schon mal konsumiert,
sonst wären wir doch gar
keine Software Engineer.
Also,
ja,
ich habe es mir jetzt auch
irgendwie mal,
es sind auch nicht viele Seiten.
Ich bin eh in der Ticketschubse
Code-Monkey
und da gibt es ja andere noch.
Ja.
Es ist,
es ist ein bisschen kompliziert
reinzukommen.
Man muss halt irgendwie
so ein Formular ausfüllen
und dann kann man,
kriegt man einen Download-Link
geschickt,
aber genau,
und dann kann man,
da steht halt,
da sind halt alle solche,
was ist eigentlich,
wenn man sich diese Fragen,
die wir ja auch schon
öfter diskutiert haben,
was sind eigentlich
die unterschiedlichen Arten
von Tests,
irgendwie Unit Integration
oder sonst irgendwas,
da wird das alles definiert.
Und,
also ob das jetzt stimmt,
Da wird einfach die Wahrheit
festgelegt.
Genau,
aber sozusagen,
um diese Diskussion zu beenden,
kann man immer sagen,
ja,
ich verwende jetzt die Definition
hier aus dem Ding,
sondern auch die ganzen Prozesse
und so,
das ist alles definiert
und was sind die Requirements
und wie funktioniert das
und was gibt es alles für,
weiß ich nicht,
Dinge, die man so tun kann
und welche Version.
Das große Glossary ist das.
Nummer drei,
Version 3.0
ist jetzt die aktuelle,
gerade, ja.
Das ist das große Glossar
für alle Dinge,
die Software entwickelt.
Ja,
die Festlegung der Wahrheit.
Ja.
Die einzig wahre Wahrheit TM.
Die ist hier festgelegt.
Na dann.
Ja,
sehr appetitlich auch
und sehr schön.
Ja,
das war auch schon der Trick,
oder?
Wohl bekommens.
Na gut.
Ja,
dann eine
nicht so Kybernetis-Kybernetis-Folge.
Aha.
Oh,
doch.
Ja,
doch.
Nicht so viel dazu zu sagen.
Ja,
wir haben nicht so viel erklärt,
wie man das benutzt,
aber das müsst ihr selber rausfinden.
Aber wenn ihr wirkliche Dinge wissen wollt,
dann dürft ihr nicht hierher zukommen.
Ja,
es gibt da so ein paar einfache Sachen,
den Golo hatte irgendwie noch.
Vielleicht können wir das auch noch verlinken.
So ein schöner YouTube-Einsteiger-Ding.
Ja,
vielleicht nochmal,
wie du dein Minikube aufgesetzt hast
und was man damit macht.
Ja,
genau.
Also ich habe eigentlich
Golos Tutorial so ein bisschen gemacht.
Ist das dann dein zweiter Pick?
Ist das der Pick,
der Jochens letztwöchige?
Ja,
der Kanal,
der die Woche irgendwie so Sachen macht.
Na gut,
es ist relativ einfach auf Deutsch,
ein bisschen langsamer als wir reden
und es ist ganz nett.
Vielleicht sollte man das am Anfang sagen.
Alles klar?
Okay.
Dann,
ja,
bleibt uns gewogen.
Haltet uns ein,
wann auch immer ihr hört.
Mittags,
morgens,
abends,
nachts.
Einen guten Tag
und gute Zeit.
Bis zum nächsten Mal.
Tschüss Johannes,
bis bald.
Ciao.
Tschö.