Transcript: Kubernetes

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.

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.

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.

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,