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 Jochen.

Hallo Dominik.

Hallo Jonas.

Ja, schön, dass du wieder da bist, Johannes.

Ja, schön, dass ich wieder da sein darf.

Super 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üsst du ja.

Manche von uns müssen.

Ich musste auch schon

Genau, und deswegen wollen wir vielleicht

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 hier 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 Neues in Python

Ja, es ist jetzt immer einmal im Jahr

irgendwie neue Release. Seit

drei Tagen, oder?

Ich weiß gar nicht genau, wann das

Release 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,

das war doch vor ein paar Jahren.

Ja.

Genau, und ja,

also,

verwendet ihr es schon? Nein.

Nein? Nicht runtergeladen.

Habt nur die News gesehen. Also ich

hab gesehen, dass du Probleme hattest, was auf deinem Mac

zu installieren.

Bei mir läuft es,

aber ich

habe mich angewöhnt, bei 1 erstmal

alle Projekte umzuziehen.

Es ist jetzt nicht das Feature dabei, wo ich sage,

das baue 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,

das will ich jetzt sofort benutzen.

Es ist ja nicht so richtig dabei, was man so richtig

benutzen kann, oder?

Ja, kein neues

Walrus

oder kein Matchcase.

Habt ihr den Match schon mal verwendet?

Ja, häufig.

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 Pydantic-Model validiert oder halt nicht.

Und dann kannst du 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 bei Pydantic reden, ich glaube, Pydantic 2 hatten wir auch noch nicht in den Newsroom,

weil wir ewig lange nichts gemacht hatten.

Doch, doch, hatten wir jetzt das letzte Mal

Genau, aber

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

Palentik-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 das war auch

deutlich mehr Arbeit, als ich gedacht hätte

und also ich habe jetzt zwei Projekte

umgezogen auf die neue Python Tech Version

und das war beide Male ätzend.

Also 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.

Wenn du 312 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 PyTentic-Fehlermeldung

nicht so richtig hilfreich. Also zum Beispiel

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.

noch nicht, weil ich kann das lesen vom Sofa aus, was du da dann rechnen kannst.

Ich mache das jetzt 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 ja da.

Sondern die ist da.

Aber die Value ist falsch.

und die B-Engine ist halt missing, was da drüber steht.

Und man denkt, das gehört hier noch zu einem anderen Teil und 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 das 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.

Dass es tatsächlich etwas schräg ist.

Also die Fehlermeldung ist ein bisschen zu verhackstückelt.

Hast du das mal mit 3.12 probiert?

Nein.

Du hast vorher schon das Problem umgezogen.

Ja, ja, ja. Also die

Pydantic ist ja schon eine neue Version

seit einigen Monaten.

Aber wäre es anders, wenn 3.12

dabei geholfen hätte?

Ist das anders in 3.12? Das ist doch eine Fehlermeldung von Pydantic.

Ja, ja, genau.

Aber ich weiß nicht,

ob die verbesserten Fehlermeldungen in 3.12

auch was damit zu tun haben, wie dieser ganze

Traceback-String gerendert wird.

Genau, weil

weil da sind ja auch verschiedene andere Sachen passiert, die dieses Rendern beeinflussen,

weil die App-Strings ja beispielsweise sind auch neu.

Ja, kommen wir gleich noch zu.

Also auf jeden Fall dieses Pydentik-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.

Das liegt raus, das liegt bei mir.

Ja, das kann auch sein.

Genau, was ist die Konstante an diesem Experiment?

Ja, genau.

Jetzt sind wir schon bei den 3.12-Änderungen.

Genau, bessere Fehlermeldung. Das ist 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 PyPy-Episode erinnert hat, war, dass jetzt, wenn man irgendwie eine Variable verwendet und die nicht definiert ist sozusagen in der Methode, dann sagt einem jetzt der Traceback so, sag mal, kann es sein, dass du self.vorher vergessen hast?

und PyPy konnte das halt schon einige Zeit

und ich glaube, das ist halt, das haben sie sich

dann von PyPy 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 unterkringeln und sowas?

Ja, genau, solche Sachen. Also da ist noch ein bisschen

was passiert.

Ich weiß es nicht, weil ich sehe nie Fehlermeldungen.

Ja, so.

Johannes, du machst einfach,

erkennt ihr das Modul, als wollt ihr eigentlich mal so ein Pick, ne?

Fuckit, du machst einfach pip install fuckit und dann schreibst du einfach add fuckit

oder with fuckit und dann gibt es keine Fehlermeldung mehr,

sind weg.

Ja, dann eine

andere Geschichte,

F-Strings haben eine ordentliche

Überarbeitung erfahren.

Ja genau, davon musste man natürlich umbauen, hast du gesagt.

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 die selben Quotes wie der String.

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, auf die

Anzahl unterschiedlicher

Arten zu quoten. Wie tief

würdet ihr denn empfehlen, so F-Strings

in der Quote? Aber was zum Beispiel echt

nervig war, dass du zum Beispiel in Multiline

F-Strings keine Kommentare hinter so

einem 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 Newlines 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

Tokenizer komplett neu geschrieben.

Der ist jetzt rein NC

implementiert und ist halt auch ein gutes Stück

schneller, ist irgendwie 60% schneller als vorher und

ja, das hat jetzt zur Folge,

und wie man F-Strings beliebig nesten kann.

Und all diese anderen Details jetzt auch gehen.

Zeit, dass zum Beispiel Logging oder sowas mal aufsteigt 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 werden soll,

bevor es, wenn es nicht geloggt wird, auf dem falschen Level.

Ja, 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 deine

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 deine Aggregation

anhand des Template Strings

und kriegst dann innerhalb dieser

aggregierten Sache gesagt, hier 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 sollten.

Ja, gut, aber dann bist du jetzt schon wieder bei

so Sprachsachen, dass du sagst,

da musst du doch rausfinden,

wo die F-Attribute drin sind.

Ja, aber das Login-Modul ist eh einigermaßen furchtbar,

mit CamelCase und sowas, das ist alles eh bäh.

Ah, das mag ja schon sein,

aber gerade diese F-Strings, die zerstören halt,

dass du siehst, wo da die Templates

stehen. Also das einzige

Argument, was ich gehört habe, ist, dass halt je nach

Log-Devel 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, keine Ahnung.

Ich weiß es nicht.

Ja,

genau. Achso,

wofür das vielleicht auch ganz... obwohl ich glaube, das ist jetzt

auch eine

doof 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-Ersatzungen wahrscheinlich, ob das Sinn macht

weiß ich auch nicht. Hast du irgendwas von Partials

gerade gesagt? Django Template Partials, damit geht

Das ist halt auch ganz gut eigentlich.

Genau, das sind aber jetzt so ein paar Module, die waren in einer der letzten

Folgen von, weiß ich mehr was,

DjangoCast?

DjangoChat 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

mitgebruchst, die waren schön,

weil man kann man schöne Sachen mit

einzelnen Templates machen, die sonst so

nicht einfach so modular

Ich habe das auch schon ein paar Mal verwendet

und das ist echt tatsächlich ziemlich gut.

Kommt wahrscheinlich auch in Genro 5.1 mit rein.

Ah, ja.

Genau.

Es gab so ein paar

Performance-Geschichten bei AppStreams, die sind ein bisschen

schneller geworden. Es gibt jetzt

irgendwie Comprehension Inlining.

Was ist das?

Ehrlich gesagt,

was es genau macht, weiß ich nicht, aber

List-Set Comprehensions

werden jetzt ungefähr zweimal schneller.

Das nehmen wir doch mit, oder?

Das ist 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, 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üllen 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.

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.

Das Argument, warum Python so ein

Gill-Hunt ist, dass das für den Single-Threaded-Case

einfach die beste Lösung

ist, weil du keine komplizierten

Logs einbauen musst, weil es

schnell ist, weil du gar nichts hast.

Weil du halt nicht gucken musst, muss das frei werden?

Genau, es ist einfach ein

Interpreter ein 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. Wir 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 du Multithreaded-Programme schreibst,

an Leanswallow, aber trotzdem nicht

mehr CPU kriegst.

Genau, an Leanswallow, weil halt die

schneller fliegen kann.

Und jetzt

wandert es auch so langsam, oder 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 Subinterpreter.

Das heißt,

die Python Runtime, der

CPython

die CPython VM

kann jetzt Subinterpreter starten, die dann

ihr eigenes Global Interpreter lockern

aber ich weiß nicht, wie man da drankommt

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, machen wir mal einen neuen Interpreter

und dem gibt man dann einen String

und dieser String wird dann als Python-Code

darin ausgewertet.

Da kann man sich natürlich auch irgendwie hübschere Abstraktionen

noch drumherum 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

sowas, wo man denken würde, oh, das kann

ich gut brauchen, warum macht man da nicht einfach einen zweiten

Prozess auf? Also kann man ja auch machen.

Einen zweiten Interpreter und

und da muss man halt schon...

Da hast du halt dann diese Prozessgrenze.

Da musst du halt irgendwie

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 dann am Messen?

Ja, also es hängt halt von den Daten ab.

Ja, aber oft übergibst du halt einfach nur

eine URL zu irgendeinem Bucket

oder sowas.

Ja, das kommt natürlich auf den Anwendungsfall an.

Da gibt es auch Anwendungsfälle,

wo man viel Daten übergeben muss.

Viel Kommunikation und viel Compute.

Dann ist schlecht. Dann musst du ihn mal serialisieren

oder musst du ihn 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

Chat-Memory verwenden, sodass halt alle Prozesse,

die man erzeugt, halt auf den gleichen Speicher

zugreifen. Das geht auch.

Wie geht denn das? 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.

über Python.

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 Subinterpretern

halt irgendwie Sinn.

Also du machst irgendwie so ein

Map-Use-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 Masterprozess

sozusagen wieder deserialisieren.

Und wenn das zu groß wird, dann schreibst du das halt

und von wo realisiert

du das denn? Also von dem Chat memory

oder was sagst du mit der Pipe, was meinst du damit?

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. Wenn du jetzt aber so

ein System hast, wo du zwölf Threads

hast, die alle 10 Millisekunden

miteinander kommunizieren, die irgendeine Nachricht

über 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 Funktionsaufruf 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 hören willst.

Ob es Pipes sind oder Shared Memory oder

was weiß ich.

Es ist ganz 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 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 loadbalancest,

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, 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 Nischenanwendungsfall.

Ich meine, das wäre natürlich schön,

wenn das 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.

Weiß ich nicht.

Auf jeden Fall gibt es Begräbungen in die Richtungen

und das ist doch schön.

Genau.

Jetzt hast du nochmal bei 3.12 was gesagt.

Teigel?

Subinterpreter.

Ja, und der Subinterpreter macht immer seinen eigenen

Subinterpreter.

Was haben wir denn noch?

Ja, es gibt jetzt so ein paar

Typing-

Verbesserungen.

und

also ich finde das

ehrlich gesagt, da sagen alle so

das ist so toll, weil jetzt geht das noch einfacher als

vorher. Wie bitte, das war vorher einfach?

Also mit dem Type-Var-Type-Aliases

Jetzt geht es noch einfacher.

Also wenn man

sich da anguckt, wie die Signaturen von Funktionen aussehen,

das sieht schon, also

definierst du ja zuerst so ein

mit Type-Var 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 Doppelfunkte 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

MyPy 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 MyPyD oder

Genau

Genau, die MyPy

Da läuft halt dann so ein MyPy-Server und dann

kann ja mal fragen und mit den ganzen anderen

Sachen halt auch und

ja, es ist mehr gekringelt, als ich dachte.

Weil vorher war das immer schön sauber und aufgeräumt

und schönster lässt sich auch

ein bisschen

also, wenn man halt Module benutzt, die zum Beispiel

falsch typen oder sowas,

also in Anführungszeichen, dann meckert

MyPy 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 TypePint davon dann neu machen oder

sowas. Also, oder eine Julien draus

machen, was ja aber dann eigentlich auch falsch ist, weil

Was soll das?

Ja, da müssen wir glaube ich mal eine Episode drüber machen

Ja, eine Typing-Episode müssen wir machen

Nicht nur eine, glaube ich

Das sind so ein paar lange Episoden

Ja, also

gerade so bei generischen Types und so

die finden das ist alles wild

und da muss man halt echt

Jango-Stubs oder sowas

Ja, jetzt ist es auf jeden Fall

besser geworden

Genau besser geworden

Man kann ja zum Beispiel sowas sagen

wenn man jetzt irgendwo sagen will

Sternstern KW-Args 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, Dict String Any,

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,

man sagt KW-Args

Unpack und dann zum Beispiel

Ecke Klammer auf und dann gibt man den Namen

von einem TypeDict an und dann

definiert man dann sozusagen für jede,

für jedes Keyword-Argument

quasi den genauen Teil. 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 hin.

Ja gut, das kannst du natürlich auch machen, ja. Du kannst dann einfach

die ganzen Keyword-Argumente hin.

Wenn es halt ganz viele sind, dann hast du sie halt getypt.

Ja, und du kannst es halt auch nicht wiederverwenden.

Das hast du schon hingeschrieben.

Und Validierung kannst du nicht machen.

Ja, ist schon ein Nischenfall.

Und genau, 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 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

drauf steht, dann ist das wahrscheinlich eine deutliche

Verbesserung.

aber ich weiß nicht. Ja, Typing ist schon so ein bisschen

Bloatware, oder? So Typing? Manchmal?

Ja, ich glaube,

da müssen wir mal eine Episode machen.

Aber das können wir jetzt

nicht leisten.

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 Dinge es gehen sollte.

Ich habe da 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, addOverride

und dann damit dem

einen TypeChecker 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 Typechecker

und jetzt nennt jemand irgendwie die Methode

in der Oberklasse, aber refactored die

und benennt die um.

Dann merkt der statische Typechecker

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.

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

statische Type-Checker,

das überschreibt überhaupt keine Methode mehr,

hier ist irgendwas kaputt, was vielleicht schon

hilfreich ist. Ja, und das tatsächlich

findet man ein Tramax, ja.

Genau, das

ist mit dem Typ-Typing-Zeugs

dann durch.

Zu Dekoratoren, ah, habt ihr das

schon mal verwendet, Cached-Property?

Ich hab das auch schon häufiger verwendet,

genau. Ja, das weg.

Warum?

Es war kaputt.

Das Problem ist, es hat

massiv viele Logs gemacht und

hat irgendwie nicht auf Instance-Ebene

geloggt und

das ist ganz schrecklich und die Leute haben es gemessen und festgestellt,

es ist viel langsamer damit als vorher.

Ich habe es nie überprüft.

Ich dachte mal so, Cash Property,

voll gut. Nee, war scheiße.

Das heißt, man hat einfach

Cash und Methodenaufruf, oder?

Ja, also ich habe es eben für solche Dinge benutzt,

wo halt dann irgendeine Berechnung stattfindet und dann

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 Cache-Dekorator drüber als ohne.

Naja, man kann ja dann die Kalkulation cachen und dann eine andere Sache machen, wo der Property drin ist.

Ja, also auf jeden Fall, irgendwie hat sich jemand das genauer angeguckt, dabei hat sich herausgestellt, so wie das gedacht ist, geht das alles gar nicht.

Und daher haben sie es jetzt entfernt.

Das heißt, man muss das jetzt selber bauen.

also du kannst Master 2 Methoden, die eine Methode ist

eine Property, die andere Methode ist

Es ist nicht so schlimm, also man kann sich relativ leicht

sowas bauen. Wenn du keine Logs brauchst.

Ja, wenn man Logs braucht, dann

ist man eh schon in so einem

Drachen

Territorium, das ist halt

ja, muss man eh gucken.

Ja, genau, dann

Drachen

Territorium, ja

wo die wilden Tiere wohnen. Genau.

Große Drachen.

Das ist so ein Nervpunkt,

dass es in Python halt mehrere Module gibt,

die sich irgendwie mit sowas wie Files

und so Zeugs beschäftigen, ist halt

einfach nervtötend. Hat historische Gründe,

aber es gibt halt ParseLib,

so als das aktuellste.

Es gibt OS,

es gibt 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 ParseLib hat natürlich auch schon

diverse, also ParseLib, 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, 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 es nichts dafür.

Und jetzt gibt es halt ein Walk

in Parslip.

Das musst du machen, etalieren musst du das so machen

und dann immer rekursiv deine Funktion selber aufrufen.

Ja, aber das willst du vielleicht nicht selber schreiben.

Und gleichzeitig Etalfiles

und das ist

Arbeit und keine schöne Arbeit

und leicht falsch zu machen Arbeit.

Du machst irgendwas anderes und dann willst du jetzt mal

kurz über alle Falschen in dein Dateisystem

umgehen und dann fängst du da an mit Rekursionen

zu machen, Dinge zu tun und so,

wo viel schief gehen kann.

Ich weiß nicht. Also da will man doch

eigentlich eine Funktion einfach nehmen und die

dann einfach...

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

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

An allen Stellen

Oder Cycles

Du kannst ja Cycles in deinem Verzeichnis haben

Und links

zu einem gut darüberliegenden Verzeichnis

und dann hast du eine Kurve drin

und dann hast du schon einmal

Tüdüdüdü

Der Ding zu da, der Ding zu 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.

Oder mit dem Cycle-Klink, das könnte man ja mit lustiger

Sachen machen.

Ja, schon. Oder andere

Devices und dann von den anderen Devices wieder das

andere Device eingebunden und

ein Cycle über Devices.

Habe ich letztens irgendwo

sehr schön, hat das jemand beschrieben,

ich weiß nicht, ob es auf Mastodon war oder

keine Ahnung. Ja, also die

coole Innovation von Unix ist ja,

und wie man das in Unix einfach alles ein File ist.

Es gibt ein kleines Problem mit dieser Philosophie,

nämlich dass eigentlich so gut wie gar nichts ein File tatsächlich ist.

Ansonsten war es eine super Idee.

Ja, ist was dran.

Den Bits musst du jetzt nochmal genau erklären.

Das war jetzt so ein Insider.

Also die Philosophie von Unix ist ja, alles ist ein File.

Da gibt es Files, wo du die CPU-Auslastung auslesen kannst.

Aber das heißt, du machst einen Händler auf, der zeigt an irgendeiner Stelle und dann

Ja, du musst halt den richtigen Dateinamen wissen

Alles ein Pfeil, tatsächlich fast alles ein Pfeil

Aber was bedeutet das denn?

Vielleicht willst du ja erklären

Also du hast ein Pfeil da drauf hin und kannst von da aus losrennen

Nee, du hast

Nee, das ist ein Pfadnamen

Du hast ein Pfadnamen und dann öffnest du die Datei

Und anstatt 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 Part

auf eine bestimmte Datei hast ja das ist gar keine Datei sondern ein Socket an irgendeinem Also Netzwerkverbindungen sind auch nur Files Ger sind auch nur Files

Piles sind auch nur Piles.

Eines 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ößerzeichen DevAudio.

Und dann kann man irgendwie in dem Programm

aus dem Lautsprecher-Tropfen zuhören.

Und solche Dinge.

Weil das ist auch nur eine Datei.

Also unter Windows oder MS-Boss

war das halt, das ist halt irgendwie,

weil das war zu aufwendig.

Das ist ja auch von Unix inspiriert, aber das haben sie

halt nicht so richtig implementiert, sondern da haben sie

da so komische Dinge gemacht wie

Laufwerksbuchstaben oder Device-Buchstaben.

Ja, so reservierte Namen.

Du darfst keine Datei haben, die COM1 heißt.

Auch unter Windows 11 noch nicht.

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, 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

und PyTest.

Genau, also 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? Muss man da irgendwie reinstopfen oder so eine Spule bauen oder...

Nee, das ist halt so ein bisschen, ja,

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, warum wir alle keine schönen Dinge

haben können.

Kann man ja mal lesen. Ja, ich glaube, ich verlege das mal in den Schuhen.

Ja, bitte, bitte.

Den kenne ich auch noch nicht

Ja, der ist schon relativ alt inzwischen

Der ist von 2014 oder so

Aber er ist immer noch genauso wahr wie damals

Er wird sich wahrscheinlich auch nie ändern

Ja

Das mit dem Audio muss ich auch mal ausprobieren

Das kann ich auch nicht

Direct von Bash auf

Def Audio

Genau, was auch

C-Python benutzt jetzt auch Precumit

Auch nett

Precumit sind die Hooks, die den Code automatisch

blinden?

Ja, also du kannst halt mit

Precommit irgendwie diverse

Regeln aufstellen, die halt erfüllt

sein sollen.

Also zum Beispiel Black-kompatibel oder

bei C-Python ist das jetzt in R&C, also irgendwie

Jammer-Syntax gecheckt wird oder

weiß ich nicht, falls sie zu groß sind.

Weniger Bugs? Fühlst du weniger Bugs?

Vielleicht?

Naja, du kannst damit

zumindest irgendwie relativ hart

sicherstellen, dass bestimmte Regeln

eingehalten werden. Machst du Precommit bei deinem Projekt?

auch mit MyPy?

Ja.

Aber, ja.

Mach ich auch, also ich mach

Ruff und MyPy und Icehorde und Black

und PyUpgrade und

sowas. Ja, mach ich auch.

Also bis auf Ruff, 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, so und sehe ich, ah,

CPU-Auslastung ist hoch, dann denke ich mir so,

PyCharm. Und dann denke 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 ja nicht fürchterlich alles.

Ja, weil das halt

in einem eigenen Virtual Env 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.

Tja, wo auch immer

die liegen. Ja, da kann man doch sagen,

deine Dependencies liegen hier. Guck mal nach,

das Format 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.

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

also, 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 Iterable

kommt, was mir das halt so in Batches

zerlegt, wo ich dann mit den Batches irgendwas mache.

Brauche ich immer.

und das ist auch ein Schild.

Nee, einfach

in Stücke hacken, in Viererblöcke, in Achterblöcke,

in Zwölferblöcke. Genau, weil du willst

halt zum Beispiel irgendwie alle,

du willst immer 100 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 das halt nicht jedes Mal machen, sondern halt

so. Genau, also ich brauche das irgendwie

immer und

bei mir heißt diese Funktion

meist so chunked oder sowas

und jetzt gibt es eine in

in Intertools. Die heißt Batched und die macht genau das.

Ist die neu? Die ist neu.

Ich dachte, da gäbe es sowas ähnliches.

Also man kann auch mit Zip

oder mit Icelice bauen.

Aber meine Batched ist neu.

Ich habe irgendwie letztes Jahr beim 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

Das hast du jetzt reingebracht, Jochen

Nein

Aber

irgendwie, ja, 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

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

So was 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-Event funktioniert nicht, weil

es sagt halt so, ich kann dieses Wheel nicht bauen

von irgendeiner Abhängigkeit

und dann habe ich was reingeguckt, warum kann ich das nicht bauen, ja weil irgendwie

Dist-Utils vielleicht fehlen

manchmal, weil Dist-Utils sind

Disintegrated, aber wenn man Setup-Tools installiert

dann kommen die alten Dist-Utils quasi mit und dann geht's wieder

und

genau, achso, und früher wurde das automatisch

in VNF, wenn man per VNF

irgendwie in Visual Nv erzeugt hatte, 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 es bei vielen Abhängigkeiten

die halt nur noch eine PyProject

Hummel mitbringen, aus der dann

sozusagen steuert, wie den

Wheel erzeugt wird

das geht nur noch, wenn PyZMQ

installiert ist, keine Ahnung warum

Was ist denn PyZMQ?

Irgendwas mit einer

diese, irgendein

Messaging Queue

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.

Ja, genau

weiß ich jetzt nicht, aber das ist halt etwas,

wo ich gestolpert bin und wo ich auch gestolpert bin,

aber das kann sein, dass das jetzt ein sehr spezifisches

Mac-Problem ist, 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

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

ja

das möchte man ja eigentlich

ich dachte dann, wenn man sagt

im Fernsmal, dann hat es mir gesagt, ganz viele Pakete,

die darauf basieren, unter anderem sowas wie

TMAX und so und

diverse andere Geschichten,

ImageMagick, LibHive,

so Sachen, wo man sagt, das kann ich nicht deinstallieren.

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.

Ja, gut. Also wahrscheinlich ist da auch

wieder ein Fehler in irgendwelchen Configure-Struppen.

Das ist doch ein Mac-Problem, oder?

Kauft euch mal einen richtigen.

Ja, kann schon sein.

Genau, ja.

Jetzt haben wir aber tatsächlich so ein bisschen News, also nur von

Python 3.12 gemacht und ich glaube,

wir müssen

eine neue Folge

aufmachen mit Python 3.12.

Wir machen chaptermark.

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 benutzen wollt.

oder übersprungen habt.

Python 12 ist schon auch relevant.

Ja, das stimmt natürlich.

Die anderen News dann später.

Haben wir noch welche?

Nee, ich nicht.

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 ich glaube, wenn man sich das so vorstellt, dann laufen halt so bestimmte Boote, also Pots, so Container halt.

So Containerschiff sozusagen.

Genau.

Ja, oder ich weiß nicht, ob das ein Schiff ist.

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 anstehen kann.

Also das ist ein Bild, was ich nicht

in den Kopf kriege, aber

man kann es sicherlich so

betrachten.

Du hast ja auch schon mal gesagt, verteilte Runtime

für, man könnte auch sagen, vielleicht ein Betriebssystem

für eine Gruppe von Rechnern irgendwie.

Ja.

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 da dran 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,

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 wahrscheinlich auch noch so

einer der Tracker, die Kubernetes am meisten irgendwie

verwendet wird, dass du halt irgendwie so ein

Load-Balancing machen kannst und halt

Skalieren kannst,

in horizontale Richtung, wenn du mehr

Last kriegst oder sowas.

Oder dass du vielleicht so Releases machen kannst.

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

und so ein bisschen wie bei einer Datenbank.

Bei einer Datenbank ist das Substrat die Festplatte

und die Workloads 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 nehme 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 die Bauanleitung für Lego

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

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,

das fängt alles 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,

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,

ich habe 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, aus Workload

Betreiber Sicht,

ist es schon was relativ simples.

Du sagst halt, du beschreibst halt,

wie deine

Workloads ausschauen sollen,

was du gerne am Laufen haben möchtest.

Und auch wie viele.

Also wenn du so ein System hast, wo du

100 Nodes hast oder 1000 Nodes,

dann ist es leicht zu sagen, ich brauche jetzt 100 von

diesen Files oder 200 von diesen oder

da ist jetzt gerade Last drauf, also mach die bitte

hoch oder wieder runter.

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 und Racks

stecken und mein Cluster

wird halt größer.

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

diese Operations-Seite

habe ich noch nicht selber erlebt. Wir

benutzen überall nur Managed

Kubernetes.

Das Lustige ist 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.

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.

Das brauchst du dann, wenn du

1000 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 Quota und hier ist euer

Quota und hier ist euer Quota

und ihr dürft da drauf starten,

was ihr wollt, solange ihr in eurem Quota bleibt.

Kurz, was ist ein Quota, 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. Wenn du so eine gewisse

Größe erreicht hast, wenn du halt mehr

als fünf Teams hast oder mehr als zehn 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.

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, so meiner Erfahrung nach,

Ich hatte nicht so das Gefühl, dass mir das wirklich

dafür sorgt, dass mir niemand auf die Füße tritt,

sondern eher so, dass ich die auf mir

also ich hätte mir 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, weil du eine andere Absatzgruppe

Es gibt eine Administrationsgruppe,

die dann trotzdem alles da hat, die Geisterkundin

hat, die das Putzen und Zaubern hat.

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 Rahmen

anfordern und

mehr

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 das geht nicht mehr, nur

das Problem hattest du vorher auch,

wenn du hier die drei Server hattest und

die sind halt voll, dann kannst du

Ich sehe 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.

Ja, natürlich.

Also zum Beispiel etwas, was halt irgendwie

keine Ahnung, vielleicht gibt es auch

eine tolle Lösung für, aber 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 Cluster dir so,

du hast ja viel Schuttland, das geht nicht.

Das heißt, du überlegst dir dann so, okay,

naja, also eigentlich

braucht der, das braucht ja gar nicht so viel.

Dann setzt man

die Ressourcen darunter.

Zu wenig Ressourcen, dann 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,

und das ist dann tatsächlich

das Interessante, was da passiert,

weil das System

kompliziert genug ist, findest du

auf einmal die Ecken und Kanten. Also zum Beispiel,

dass du zwei

Limits hast. Du hast ein Requests-Limit

und ein Limit-Limit.

Du forderst, du brauchst mindestens

so viel RAM,

aber auf keinen Fall mehr als so viel.

Und manchmal brauchst du es halt aber doch.

Und diese Worte bedeuten auch nicht,

dass was sie bedeuten, sondern

dieses Requests, wenn du zwischen dem

Requests und dem Limit bist, dann heißt

es, dass Kubernetes

diese vor allem abschalten darf.

Weil du ja

über dem Request drüber bist. Du bist über

das, was du angefordert hast.

Diese Worte bedeuten halt

nur, wenn du übers Request gehst,

darf Kubernetes

deine VfA abschalten.

Beim Limit muss es die VfA abschalten.

Das heißt, es darf halt dann, wenn andere

anfragen, ob sie neue Ressourcen haben können

und es keine freien mehr findet.

Ja, beziehungsweise, wenn du über

Es gibt zwei wichtige

Kenngrößen, CPU und

Memory.

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

das Scheduling, also die Zuweisung,

welche

Arbeitslasten auf welchem System,

auf welchem Knoten laufen,

die gehen über das Request.

PyTest. Das heißt,

wenn du sagst, meine Anwendung verbraucht

500 MB Hauptspeicher

und maximal

1000, dann kannst du auf einen Rechner gesetzt

werden, auf einen Knoten gesetzt werden, wo 500

MB frei sind.

Weil dann ist deine Anforderung erfüllt. Du hast gesagt,

ich brauche 500 MB Hauptspeicher.

Wenn du drüber gehst, dann

kann es halt sein, dass es nicht geht.

Du kannst nicht mehr Speicher reservieren oder es

kann sein, dass du abgeschossen wirst,

weil jemand anderes auch gerade

500 MB angefordert

hat und du halt aber mehr als deine

500 MB verbraucht hast, weil du zwischen Request

und Limit bist.

Die pragmatische Lösung, die sich bei uns

in diesem Projekt ergeben hat, 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 darfst du dann halt nicht haben.

Beziehungsweise Spitzen hast du dadurch abgedeckt, dass

das... Das kenne ich auch, aber das Problem

ist halt...

Und ist auch

nicht schlau. Eigentlich willst du ja, dass sich diese

Wellen so ergänzen.

Und wenn ich jetzt einfach auf dem normalen Rechner

sozusagen deploye und ich habe jetzt halt irgendwie

sagen wir mal 10 Projekte, die alle unterschiedliche

Last haben und so und ansonsten brauchen die halt

mal so einen Gigabyte Hauptspeicher oder

zwei für irgendwas

weil sie halt irgendwie zum Beispiel

ein Fall, an den 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 aus

Naja, also es kann auf jeden Fall passieren

Du hast halt, also normalerweise passiert

nichts, aber du hast halt FFmpeg mit

irgendwie so, weiß ich nicht

200 Zeichen irgendwie komischen Optionen

hintendran und meistens passiert gar nichts

In komischen Fällen manchmal braucht das dann halt

2 GB Hauptsprecher

Ja, aber solltest du das dann nicht abschießen in dem Fall?

Nein

Und es ist halt dummerweise sinnvoll

und das braucht es halt wirklich.

Und jetzt kann man natürlich dann irgendwie, keine Ahnung,

MPEG irgendwie sich angucken und schauen, wo ist denn

das Problem. Aber

wie geht man denn mit so einem Fall um?

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.

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, wenn ich denke so,

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 ja nicht so, dass man, also,

ja. Ja, man muss ja 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 dann natürlich auch, wenn du

Spezialhardware hast, sowas wie GPUs oder sowas.

Ja, gut, klar, die musst du natürlich. Aber dann

geht auch so ein bisschen der ganze Vorteil irgendwie so ein bisschen

wieder verloren, weil dann musste ich ja doch

wieder um die ganze...

Die Annahme ist halt, dass du

viele

gleichpräige

Arbeitlasten hast,

wo es nur darum geht, die irgendwie

so mehr oder weniger gleichmäßig zu verteilen.

Und dann ist das großartig.

Ja, gut.

Aber das Interessante,

was ich als ich Kubernetes gelernt habe,

war, dass sich da

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?

Ja. Und die Antwort ist

gar nicht. Du sorgst da gar nicht dafür, sondern

du sagst nur, ich brauche was aus der Tabelle

und dann sorgt er schon selber dafür,

dass es aus der Tabelle kommt. Ja.

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 die 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.

Diese Maschine soll jetzt bitte entfernt werden.

Ja.

Das sind auch so ein paar Probleme.

also

was das halt auch kann, ist irgendwie so Rolling Release

dann halt irgendwie, das hat mehrere Versionen

von einer Software, die dann live ist, weil die halt

eine wundervolle Sache oder Blue-Green-Apple

ja genau, also das ist keinerlei

Verzug mehr zwischen neuer Version

also gefühlt und 10%

laufen noch auf der alten Version oder schon auf der neuen

und dann falten die, wenn die Prozesse

irgendwie fertig sind, alte Maschinen ab und

neue halt irgendwie rein

aber das ist auch ein bisschen

Ja, aber ist doch eine großartige

Sache. Es gab einen super

Artikel zu Blue-Green-Deployments mit Django.

Da hast du halt...

Genau.

Wird in den

Shownotes erscheinen.

Wo du halt ganz arg darauf achten musst, dass du

deine Datenbank-Migration so machst,

dass du quasi bei jedem Übergang

beide Versionen betreiben kannst.

Das ist ja genau das Problem. Was machst du in Migration?

In Django?

Und dann fällt die Tabelle auf einmal neu?

Es steht dir ja frei, das anzuhalten

und dann die Migration zu machen und dann

neu zu starten. Das darfst du ja machen.

Neu ist ja kein Problem

Problem ist halt eher, wenn

eins wegfällt oder so

Aber wie gesagt, dieser Mechanismus kannst du ja immer noch machen

Du kannst ja alle anhalten und

Mutation machen und alle neu starten

Das ist ja kein Ding

Nur, was du 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, ich wusste diese Worte auch nicht

Rolling Release heißt

dass wenn du zum Beispiel

5 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,

nach und nach die neuen zu verändern.

Das heißt, eine stoppen, 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

Erreichbarkeit hast.

Ja genau, aber das ist so ein Problem.

wenn die PostgreSQL da ein Gipf draufkriegt mit einem neuen Feld.

Das muss halt deine Software dann können.

Und das ist nicht immer so einfach.

Ja, also

das kannst du auch mit Ensemble machen.

Dieses Problem hast du natürlich sowieso.

Mit Ensemble ist es natürlich schwierig,

weil es ist schon eine komplizierte Operation.

Ja, aber 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 halt einmal spiegeln,

dann rüberfahren und dann irgendwie aufsammeln,

das, was in der Zwischenzeit noch in die alten Datenbank geschrieben wird

und dann auch so eine Liste machen,

die du dann in die neuen Datenbank migrierst

und dann das aber dann rollen.

Das heißt, während du 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

klar Daten, weil welche kamen jetzt zuerst.

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.

Wenn ich bei mir

irgendwie ein neues Deployment

und PyTest zu Downtiming Ich habe eine Sekunde Downtime in der Mitte Du machst den einen alten System dann f du das neue System hoch und dann zeigst du aber den Loadbalancer einfach

aufs neue System. 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

Also ich weiß es gar nicht ganz

Die ist 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

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

down, dann machen wir die Migrationen

und dann starten wir es einfach wieder.

Das gibt da noch ganz viele schöne Reihen.

Wenn du sowas nämlich in so einer CICD-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

neue Versionen bauen anders ist, als auf ein altes

System Update setzen. Und dann musst du halt erst alte

bauen und dann das neue. Und wenn man dann sowas macht,

wie neue Environments oder Sequels dazu

und die es beim Anfang noch nicht gibt,

beim Ende dann schon, dann muss halt quasi,

oder halt welche Entfernteil, größeres Problem,

dann sind die halt auf einmal weg beim

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.

Also die allermeisten

Projekte und Teams und Unternehmen

können doch eine Minute

Downtime hinnehmen. Das ist doch egal.

Ja, aber wenn du Service-Level-

Agreements hast, wo

5.9, das hat so 99,999%

Das sind ja alle haben.

Das sind ja nur 9.5.

Das ist mein Service Level Agreement.

Ich karatiere mindestens 55,555% Abteil.

Hauptsache viele fahren.

Hauptsache viele sind auf dem T-Shirt.

Ne, das ist eben die Sache.

Das ist diese Krankheit.

Man kann das machen,

aber muss man das machen.

Und klar, 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

ja, es gibt Fälle

wo das so ist

ja klar, es gibt Fälle in denen das so ist

aber 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 es 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. Damals.

Damals. Als wir noch jung waren.

Aber 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 da drunter liegt.

Das ist halt, dass man das weg abstrahieren kann.

Aber Jochen, Google macht das doch auch.

Wenn du ein Managed Kubernetes Cluster kaufst, dann kannst du einfach zwei Pods hochschreiben

und da kannst du so einen Schieberegler in deinem Webinterface einstellen.

Der sagt dann sieben Pods von 8 bis 10 Uhr.

Oder Load Balance auch, wenn die CPU-Auslastung über 50% steigt.

Dann skalierst du hoch.

Okay, es kann sein, dass man das heutzutage alles nicht mehr braucht.

und PyTest.

und das ist ein Testframework für Python

über so ein Fake-Interface

raus und das landet dann halt alles irgendwie,

das kann halt dann deutlich dicker sein, das ist dann kein Problem.

Und sowas geht dann ja also schon nicht mehr.

Das kannst du gar nicht mehr machen, weil du musst ja dann alle gleich behandeln können.

Und der Loadbalancing geht ja auch nur so,

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...

in Westen. 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 und 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...

Eine sehr schöne Sache ist halt,

und PyTest.

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.

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.

Du hast eine Trennung.

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.

Das ist schon

für, aber wieder

für ein Unternehmen einer

gewissen Größe.

Und ich möchte nicht zu Hause auf meinem

Raspberry Pi oder auf meinen Raspberry

Pis einen Kubernetes-Cluster betreiben müssen,

bloß weil ich da ein Power-VM starten möchte.

Das mache ich halt händisch.

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. 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

Inhomogenität nicht groß genug ist.

Wenn du tausend identische Maschinen starten

möchtest, gibt es einfache Wege.

Wenn du

Wenn du

50 Maschinen starten möchtest,

gibt es einfachere Wege.

Du musst kurz so einen kleinen Elevator machen.

Warum? Was?

Es gibt ja ganz viele Workloads, die sehr

computer-heavy sind. 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.

Eine Möglichkeit, die du 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 Hostadresse zu hinterlegen, sondern 100.

Und dann auf diesen 100 Hosts oder 1000 IP-Adressen zu hinterlegen und zu sagen,

starte bitte auf allen diesen Rechnern, diesem Inventory diese Workload.

und da brauche ich keinen Kubernetes dafür.

Ja, aber du musst ja trotzdem irgendwie das

I-O-Commando, wo kommt das alles her?

Ja, gut, klar, das musst du dann immer noch merken, aber

das ist dann bei allen gleich.

Und das ist das, worauf ich raus möchte.

Wenn du tausend identische Dinge hast,

dann reicht ein Ansible.

Und das ist auch nicht mal

kompliziert, weil die alle gleich konfiguriert sind.

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 nochmal genau

erklären. Also vielleicht so ein reales

Beispiel. Und 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

Alterungsverordnung

Verwesungsstufen

auf verschiedenen Teams, weil dann

so, dass du halt nicht sagen kannst,

und ich deploye das jetzt auf eine homogene

Geschichte, wo man sagen muss, das geht nur mit

Docker, das geht nicht anders, weil das halt einfach zu

unterschiedlich ist.

Das machen Entwickler sowieso, Jochen.

Das machen ja nach Docker, nur du willst das.

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

NixOS und da habe ich hier ein Debian und das muss ich aber

alles gleich auf dem gleichen Klasse.

Java 17 und 18 und 21 und 8 und 2

Ja und für alte Sachen

sind alle Programmierer schon gestorben,

das muss ich aber weiter betreiben.

Deine Kobo Docker VM

Ja, okay, okay, dann

eine AS400 Docker VM

Ja, also das

Also nochmal, anwenden Sie bitte noch einmal,

du wolltest das nochmal erläutern, also was denn da

Also wir haben jetzt verschiedene Sachen, die

ganz heterogen sind

Okay, aber

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 Kubernetes-Computer

Workloads starten dürfen, also die

VRM starten dürfen. Und zwar egal, welche

sie wollen. Und klar, wenn

du 5000 verschiedenen Teams

hast, die eben diese 5000

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 aber 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 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. 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, dann willst du, dass sie möglichst nah aneinander dran sind, aber wo die dann laufen

Ich hätte gern mehr Netzwerk-Latenz, das ist doch immer gut

Größere Zahlen, mehr Netzwerk-Latenz hinter meinen Microservices, das muss doch Spaß machen

Ganz ehrlich, für mich als Anwendungsentwickler ist es auch völlig egal, wo das läuft

solange das halt läuft

Jaja, na

also ich weiß nicht

ich hab halt doch so

von Erfahrung her würde ich

also ich, es gibt halt

es gibt halt Infrastruktur, die gut

funktioniert, aber es gibt halt Infrastruktur

die nicht gut funktioniert und das hat

meine Erfahrung hat weniger

damit zu tun, ob man jetzt Kubernetes verwendet

oder keine Ahnung, irgendwas anderes

sondern eher damit

welche Leute die betreiben

ich sag zum Beispiel

Oh Gott, das hört sich so an wie, ne, so

Ihr seid alle blöd und ihr könnt es nicht

Ja, aber also mit dem Alter, also das ist halt auch sowas, vielleicht werde ich auch einfach alt, das kann auch sein, aber früher

Oh, du willst wissen, wo deine Programme laufen

Ja, na, nee, ja, ja

Also früher hätte ich gedacht, also Prozesse, ne, beim Softwareentwickeln Prozesse ganz wichtig und das total, wenn man das 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 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.

Wir hatten ja damals nichts anderes.

Ich kann mich da nicht mehr erinnern,

vielleicht besser nicht bei mir, 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.