[SPEAKER_01]: kurze Frage.
[SPEAKER_01]: Wann hast du zum letzten Mal Timeouts definiert?
[SPEAKER_01]: Genau, dachte ich mir eigentlich auch, die vollwarte Reichen doch leicht aus.
[SPEAKER_01]: Und dann kam der Andium-Berke.
[SPEAKER_01]: Die banalen Einstellungen wie Time Art and Free-Trice sind nämlich Heldstück von Resilience Engineering, von Connection, Read und Eidel Time Art bis hin zur Circuit Break-In- und Tock- und Backits.
[SPEAKER_01]: Wir besprechen, was Nullcommer ein Prozent Fehler-Dollaranz für das Design ganz so Software-Architecturen bedeutet.
[SPEAKER_01]: Vor allem, wenn man die berühmte Aussage von AWS-CTO-Werner Vogelsmittengt,
[SPEAKER_01]: Every thing fails all the time.
[SPEAKER_01]: Also los geht's mit einer Episode in der an, die mich wieder einmal überzeugt hat, dass ein einfacher Begriff wie Timeouts eine ganze Episode war.
[SPEAKER_01]: Also an die du bist ja da meist da, der Komplexisierung, komplexisierung, komplexisierung.
[SPEAKER_01]: Von dem einen Komplexe zu machen, als sie offensichtlich eigentlich so sind.
[SPEAKER_01]: Also ich sind ja dann immer so demen, so wie heute, Timeout's Re-Tries, weil wir so dann gehen, haben wir in drei Minuten abgehandelt, du willst eine ganze Episode drüber machen.
[SPEAKER_01]: Warum und warum machst du die demen nicht mal so komplizieren?
[SPEAKER_00]: Ich mache etwas, was man normalerweise nicht machen sollte, eine Frage mit einer Gegenfrage beantworten.
[SPEAKER_00]: Deswegen, wie viel Sachen in der Softwareentwicklung dauern fünf Minuten Wolfgang?
[SPEAKER_00]: Du kennst ja selber schon nicht, dass wird achkommen, mache ich dir in fünf Minuten oder warum dauert das, dass du lange dauert doch in fünf Minuten.
[SPEAKER_00]: Also wie viel Elemente und Aufgaben in der Softwareentwicklung dauern wirklich?
[SPEAKER_00]: Fünf Minuten.
[SPEAKER_00]: Ja, ziemlich wenig, weil eigentlich den Kropilot prompt schreibe deinen zwei Minuten hin.
[SPEAKER_00]: Okay, und wie oft machst du dann Back and forth weibkodig mit dem Fehler und schmeißt das wieder in die ION-Co.
[SPEAKER_00]: Echantic-Codig, ist es mal, kann nicht weibkodig.
[SPEAKER_00]: Aha, schon mal, wenn da komplex zu siehst du grad die ganze thematik, ja?
[SPEAKER_00]: Du sagst nicht, du lässt das Problem von wem anders fixen und nennst das jetzt agentik kodig.
[SPEAKER_00]: Okay, verstehe.
[SPEAKER_00]: Also sind wir doch wieder auf derselben Spur?
[SPEAKER_01]: Aber jetzt erklären wir mal, warum glaubst du, dass es ein wichtiges Thema ist und eine ganze Episode erwartet ist.
[SPEAKER_01]: Weil ein Timeout ist ein Wald irgendwo.
[SPEAKER_01]: Oder das ist sogar ein T-Voltwert meistens, brauchen wir doch gar nicht drum kümmern.
[SPEAKER_00]: Ah, und genau aus diesem Grund, weil du diese Aussage trifft, denke ich, es ist eine Episode der Wert.
[SPEAKER_00]: Weil das ist schon wieder eine komplette Lüge.
[SPEAKER_00]: Also ich hoffe nicht, dass du dich in der Uni, wenn du mal in einer Gastvolllesung in Informatik hältst und sagst, ja immer wenn ihr ein Netzwerk holen macht, seht zu, dass ihr einen Teimout nimmt.
[SPEAKER_00]: Aber abwistert was, da braucht ihr gar nicht darauf achten, denn es ist ein T-Voltwert.
[SPEAKER_00]: Ich hoffe, das sagst du nicht, denn dann würden wir vielleicht nur noch zukünftige Weibkoder erziehen oder leeren, Punkt ist aber.
[SPEAKER_00]: Und jetzt kommen wir mal zu der Antwort zu dann auf Frage.
[SPEAKER_00]: Das ist mal wieder so ein Thema.
[SPEAKER_00]: Da denken ziemlich viele Leute, die haben Licht am Fahrrad.
[SPEAKER_00]: Wenn man da auch mal tiefer rein geht, ist das wieder so eine
[SPEAKER_00]: Exploding hat emoji.
[SPEAKER_00]: Sache.
[SPEAKER_00]: So nach dem Motor, dein Kopf ist auf dein kreieren kommt raus und brennt oder explodiert.
[SPEAKER_00]: Weil die ganze Sache geht nämlich viel tiefer und besonders, wenn wir mal in die Themen Monolith versus Microsoft und Software Design und Achtung, Software Echtektur einsteigen, sind das Kiefragen, um
[SPEAKER_00]: Hinten raus, sehr teure Ausfälle zu vermeiden oder nicht dänne.
[SPEAKER_00]: So wie du, deine Art von Koden inzwischen agentik coding ninst, hab ich auch einen Namen dafür.
[SPEAKER_00]: Heute machen wir mal ein kleinen Teil zum Thema Resilience Engineering.
[SPEAKER_01]: Dann bin ich gespannt, ob mein Kopf explodiert.
[SPEAKER_01]: Ich glaube übrigens bei der Wade, dass Egentikkoding die bessere Time-Outsetzt als ich mir selber, weil die hatte gerade kürzlichen Problemen, dass eben kein Time-Out gesetzt war.
[SPEAKER_01]: Und mir daher die Container immer um die Ongeflogen sind, weil es irgendwelche Offend Prozesse gegeben hat, die nicht sauer eben wegen fehlenden Time-Out.
[SPEAKER_01]: Nicht dann schlussendlich beendet wird.
[SPEAKER_00]: Moment.
[SPEAKER_00]: An dieser Aussage gibt es schon wieder so viel zu, wie sagt man auf Englisch zu Anpacken.
[SPEAKER_00]: Nur weil du ein Timeout hast, heißt das ja nicht, dass deine Prozesse nicht orfe in sein können.
[SPEAKER_00]: Also ein Timeout sagt ja nur, ich höre hier auf.
[SPEAKER_00]: Aber ein Timeout sagt ja nicht, ich breche den kompletten Prozesse da läuft ab.
[SPEAKER_01]: Ja, in dem Fall war es ein Timeout von einem sub-Process.
[SPEAKER_01]: Kommant.
[SPEAKER_01]: Und da brecht es Ding dann durch die sub-Process ist,
[SPEAKER_01]: Ab, aber schlussendlich, warum die Stecken geblieben sind, war wieder ein klassisches Teil mal auf deine Zwecke eben.
[SPEAKER_01]: Aber wie gesagt, man merkt schon, wenn man da nicht genauer draufblickt, das sind immer ganz böse Bugs, die man da entwickelt.
[SPEAKER_00]: Das sind nicht so böse Bugs.
[SPEAKER_00]: Das sind schreckliche Bugs, weil A kann man die Kaketesten.
[SPEAKER_00]: B muss man natürlich auch mal ein bisschen auf acht Wochen möchten, mit dieser Art von Bugs natürlich nicht umgehen.
[SPEAKER_00]: denn hast du jetzt gesagt, man kann sie testen, oder man kann sie nicht testen.
[SPEAKER_00]: Ja, man kann sie testen, man kann immer alles testen, nein, nur die Frage ist nur, wie viel Geld schmeißt du drauf und wie viel Aufwand packst du da rein.
[SPEAKER_00]: Aber es ist sehr, sehr schwer zu testen und warum oder kommen wir gleich zu.
[SPEAKER_00]: Es ist aber auch so, dass die meisten Leute sagen, ja, ich renne immer in den Timeout.
[SPEAKER_00]: Ihr dann ist die Lösung, ja, ich erhöhe den Timeout.
[SPEAKER_00]: Ja, warum das nicht der Fall ist, klären wir gleich.
[SPEAKER_00]: Aber wenn mir doch mal eine Software, die du heutzutage schreiben würdest, die ohne einen Request an ein anderes System auskommt.
[SPEAKER_00]: Und System ist hier definiert als API oder von mir aus auch lokaler Prozess auf dem Server.
[SPEAKER_00]: Also alles, was dein Quellcode selbst verlässt, das ist ein System.
[SPEAKER_00]: Welches System oder welche App die du heutzutage programmieren würdest, kommt ohne einen
[SPEAKER_00]: Kohler-Nandelsystem aus.
[SPEAKER_01]: Ich hätte jetzt gerne gesagt, als Beispiel, Freund von mir hat so ein KI-Fan Glas entwickelt.
[SPEAKER_01]: Das führte automatisch erkennt, wenn man durchblickt.
[SPEAKER_01]: Aber ich vermut, das ist zwar offline, das Ding, aber ich vermut, dass da Internet so viele Teimat ziemlich spielt sind, dass das wahrscheinlich sogar komplex ist, als ihr das andere System.
[SPEAKER_00]: Nimm mit hoher Wahrscheinlichkeit gibt's da ein Prozess, was dann irgendwie so imilschrecognischen macht.
[SPEAKER_00]: Und der hat das Wahrscheinlich nicht in seiner eigenen Software embedded oder ähnliches.
[SPEAKER_00]: Also da fängt's ja dann schon an, genau das meinig.
[SPEAKER_00]: oder wenn du jetzt von auch einem lokalen LLM sprichst, dann wirst du ja mit hoher Wahrscheinlichkeit irgendwo Trainingsdaten haben und du machst dann einen externen Süßkohl oder so aus.
[SPEAKER_01]: Ja, vor allem du hast auch in der Hardware
[SPEAKER_01]: Eben er hast du nur sich deimer als wenn du mit den verschiedenen Komponenten kommunizierst und da hast du nur die ganz viele Protokolle auch mit deimer.
[SPEAKER_00]: Punkt ist, und den habe ich jetzt gerade gemacht.
[SPEAKER_00]: Moderna Cloud Systeme oder Mederna Systeme sind einfach voll von externen Korres.
[SPEAKER_00]: Und somit lassen sich da Ausfälle nicht mehr vermeiden, sondern also Ausfälle sind nicht die Ausnahme, sondern Ausfälle sind normal, wie einer meiner eigentlich Vorbilder.
[SPEAKER_01]: Aber die weiß es, es kommt jetzt weiter vorgeles.
[SPEAKER_00]: Ja, natürlich.
[SPEAKER_00]: Im Thema Resilience Engineering ist der CTO von AWS natürlich ganz vorn dabei mit seinem Famous Quote, everything fails all the time.
[SPEAKER_00]: Und ja, er hat ja recht gefühlt.
[SPEAKER_00]: Lesen wir hier jede Woche auf vegan use das Google-Down, ist versell ist da und glaubt vielleicht es da und was das ich nicht alles.
[SPEAKER_00]: Und das hat natürlich in der Regel damit zu tun, dass im externen Kreuz zu fremden System fehlen.
[SPEAKER_00]: Den, was externe Systeme sind oder warum die fehlen, hat der hat der zehntausend gründe.
[SPEAKER_00]: Das sind Server im Spiel, Netzwerke, Load-Bellenzer, verschiedene Software vielleicht auch selbstgeschriebenes Software.
[SPEAKER_00]: Irgendwächer-operating-Systems vielleicht von Nugs-Ovindos.
[SPEAKER_00]: Wir haben also mit verschiedenen Settings zu kämpfen.
[SPEAKER_00]: Oder ganz simple Ano-L-Fehler von System an Instagram-Torne.
[SPEAKER_00]: Egal, ob die dann Infrastructure-Scode oder Konfiguration-Management mit Anso- und Terror vornehmen, punkt es, wenn da irgendwo einen Fehler drin ist, dann propagiert er sich halt automatisch auch durch.
[SPEAKER_00]: Genau da kommen wir natürlich jetzt zum Thema Achtectur und Design.
[SPEAKER_00]: Ja, Design ist nicht, wir machen den batten Grünen, sondern Achtectur Design und Software Design.
[SPEAKER_00]: Das Ziel sollte halt sein, ein Achtectur oder ein Design zu wählen, welche diese Art von Fehler reduzieren.
[SPEAKER_00]: Da, sprich mal drüber.
[SPEAKER_01]: Es hätte dann natürlich noch eine Frage, weil wir sprechen ja natürlich schon von sehr komplexen Systemen und wir gehen da jetzt auch recht tief dann natürlich rein in die Softwareecke.
[SPEAKER_01]: Wenn du mit einer Software startest, wäre deine Rangensweise sowas schon mitzudenken.
[SPEAKER_01]: Ich spreche jetzt nicht von irgendeinem Riesensystem, wo du mit dreien und leiten dann drei Monate dran arbeitest, sondern mit irgendeinem kleineren Softwareprojekt, deshalb aber dann produktiv laufen soll.
[SPEAKER_01]: Würdest du das so was schon mitdenken oder würdest du es dann eher agil schrittweise machen.
[SPEAKER_01]: Und wenn du dann an die Punkte kommst, vielleicht irgendwo was mitdenken oder vielleicht sogar auf die Tiefoltwerte vertragen.
[SPEAKER_00]: Meine Antwort geht in zwei Richtung.
[SPEAKER_00]: Erstens denke ich nicht, dass wir über komplexes Thema sprechen, sondern wir können auch hier ganz einfach schon über eine klassische Web App sprechen, die eine Konnexel zu einer Datenmarkt hat.
[SPEAKER_00]: Das reicht schon?
[SPEAKER_00]: Kann ja auch komplexes schon sein.
[SPEAKER_00]: Mein Datenbank im Spiel sind sie das immer alles komplex oder?
[SPEAKER_00]: Natürlich, natürlich.
[SPEAKER_00]: Ich habe jetzt eigentlich nur mit komplex mit mehreren Komponenten und Micro-Service- und Serviceorientatische Blaba-Blaht.
[SPEAKER_00]: Aber es kann auch ganz einfach in der Website, die mir in der Datenbank spricht.
[SPEAKER_00]: Das reicht ja schon mal nur aus den Externkoll.
[SPEAKER_00]: Und die zweite thematik bedenke ich so was von Anfang an.
[SPEAKER_00]: Ich würde sagen, denen die Fragestellung im Hinterkopf zu halten ist eine gute Sache.
[SPEAKER_00]: Ich glaube, um Anfang sollte es so eher lichter aufhokussieren, die ganze Sache so schippen und dich auf den, z.B.
[SPEAKER_00]: auf den Default, wird bei Timons verlassen.
[SPEAKER_00]: Und dann später kann sie dich um Resilience kümmern, weil was ist nämlich, wenn du einfach nie in Auto-Chos.
[SPEAKER_00]: Dann kann es auch erstmal sagen, okay, ich investiere jetzt keine zwei Wochen und testen meine Resilience thematik hier aus.
[SPEAKER_00]: So, dann du schippst einfach um Bewegsehe, einfach nach Vorwärts bis zu einem Ausfall hast und dann machst du es.
[SPEAKER_00]: Oder Achtung, falls das Backlock mal leer ist, kann man uns darum kümmern.
[SPEAKER_00]: Das wird natürlich immer passieren, dass das Backlock leer ist.
[SPEAKER_00]: Also, das für mich mal interessieren, geht mal in unser Diskokrühlti, wie oft hatet ihr schon ein leeres Backlock?
[SPEAKER_00]: Also, ich glaube, ich noch nie.
[SPEAKER_01]: Okay, also normalerweise gehen wir ja schon an die Sache ran, alles funktioniert.
[SPEAKER_01]: Und dann kommt man meistens an dem Punkt, wenn man es nicht schon vorher mitgedacht hat, irgendwas funktioniert nicht, oder man sieht irgendwo gibt es Probleme und es knarzt irgendwo bei Konnexions zu anderen Microsoft-Service.
[SPEAKER_01]: Ist das überhaupt ein Problem?
[SPEAKER_01]: Weil dann wird halt die Konnexion nochmal gemacht oder der Request.
[SPEAKER_01]: Halterlage hat eh schon alles Re-Trice eingebaut, also wo sie meine Probleme.
[SPEAKER_00]: Genau dieser Retro ist ja schon da voll hemm oder kann zu einem Problem führen.
[SPEAKER_00]: Also ich mein, ob es ein Problem ist, dass deine App zu der externen Applikation keine Connection aufbauen kann und z.B.
[SPEAKER_00]: einen Time Odden.
[SPEAKER_00]: Das kann ich dir nicht sagen, das kommt natürlich auf den News geht es noch von.
[SPEAKER_00]: Wie weiß er nicht, was du da hast.
[SPEAKER_00]: Aber nehmen wir mal die klassische Web App, die Konnekte zu der Datenbank, die will irgendwelche Daten lesen, kann die Daten nicht lesen und wird mit hoher Wahrscheinlichkeiten für einen Fuhn nach vorne dem User ausgespielt.
[SPEAKER_00]: So in jetzt sagst du jede App hat schon Retry drin, ja das würde ich auch meinen Fragen stellen, weil da kann man nicht leicht zu.
[SPEAKER_00]: Jetzt wird der Retry sofort gemacht, ohne eine Pause dazwischen.
[SPEAKER_00]: Und dann wird die Datenbank gehemmert.
[SPEAKER_00]: Beziehungsweise, die Datenbank kriegt ganz viele Anfragen, retuniert wird ein Fehler.
[SPEAKER_00]: Es wird wieder versucht.
[SPEAKER_00]: Dann ist die nächste Frage, wann hören wir denn mit dem Retry auf?
[SPEAKER_00]: Dann ist die nächste Frage, kann sich die Datenbank den Erholen.
[SPEAKER_00]: Also, ne, wenn man an die Datenbank haten Ausfall.
[SPEAKER_00]: Die Web App können keine Connection zu Datenbank aufbauen.
[SPEAKER_00]: Und zeitleich schalten wir Werbung auf Prozyben.
[SPEAKER_00]: Prozyben dieser Privatfernsehsehsehne.
[SPEAKER_00]: Kennst du noch?
[SPEAKER_00]: Weil davon gehört er.
[SPEAKER_00]: Das bedeutet, ziemlich viele Kleins warten gleichzeitig auf ein Ereignis oder auf einer Ressource und das Sie Datenbank, die er ist er gerade daun.
[SPEAKER_00]: Jetzt kommt die Datenbank wieder hoch, also du als es eben an einem Ressource, machst System CTL Restart My Database.
[SPEAKER_00]: Dann ist die Datenbank wieder verfügbar und alle Kleins, alle Request, schlagen zeitgleich zu.
[SPEAKER_00]: So was nennt man das Sundering-Hurt-Problem.
[SPEAKER_00]: Das bedeutet, ganz viele Kleins wollen die Ressourced auf einmal haben.
[SPEAKER_00]: Was meinst du eigentlich wie gut deine Datenbank damit klar kommt?
[SPEAKER_01]: Ja, starten Bank meines Sagen natürlich ja, wird es die Connections begrenzt.
[SPEAKER_01]: Und dann, wenn einfach keine neuen Connections aufgebaut und es wird gemütlich weitergearbeitet und alle neuen Connections werden nicht mehr erstellt und die Kleins werden ignoriert.
[SPEAKER_00]: Wir haben vor kurzem über deine Zeitprojekte gesprochen.
[SPEAKER_00]: Wie viele davon ist wirklich implementiert worden?
[SPEAKER_00]: Ich glaube, es gibt einen guten Default-Wert von maximale Connections.
[SPEAKER_00]: Aber das war das gerade gesprochen, ab das ist die Realität.
[SPEAKER_00]: Bei Trivago hat mir mal einen Fall.
[SPEAKER_00]: Und zwar in Trivago hat eine ganze Zeit lang, und ich muss zugeme ich weiß nicht, ob das immer noch so ist, weil ich arbeite, dass ich ein paar Jahren nicht mehr.
[SPEAKER_00]: Aber Trivago hat der ganze Zeit lang wirklich, wir waren abhängig von unseren Caches.
[SPEAKER_00]: Wenn alle Caches neu gestartet wurden und die Caches lehr hoch kamen, haben alle Kleinens einen Cache missbekommen.
[SPEAKER_00]: Und wenn die eine Cash-Miss bekommen haben, sind die zu Datenbank geklaufen und haben sich versucht, den Wert zu holen, um ihn dann in eine Cash zu schreiben.
[SPEAKER_00]: Und das war sehr, sehr ähnlich zu dem Sundering-Hurtproblem, was ich gerade beschrieben hab.
[SPEAKER_00]: Die Datenbank hat dann einmal so ein riesen Traffic-Börs oder ein Traffic-Spike bekommen, hat einmal hüp.
[SPEAKER_00]: gemacht, ja.
[SPEAKER_00]: Und dann mussten wir Glück haben oder nicht, ob die Datenbank dann auch wieder ausatmen konnte.
[SPEAKER_00]: In der Regel hat sie es nicht geschafft und dann war das nämlich so ein kascadierendes Event, das ist das wir mit leeren Caches hoch kamen, die Datenbank abgeschossen haben und so weiter und so vor.
[SPEAKER_01]: Und lasst mir mal raten, die Caches haben mit jedem neuen Rikwester.
[SPEAKER_01]: Sie bekommen haben wieder ein Rikwester nach hinten geschickt zum Verkehr.
[SPEAKER_01]: Wenn ich was lokal nicht beantworten kann, schick es weiter an das Bekennt.
[SPEAKER_00]: Ja, natürlich, also diese Art von Problemen, die ist jetzt nicht selten.
[SPEAKER_00]: Und besonders, wenn du mehrere Komponenten hast, dann, also ich sag mal, jetzt eine Micro-Service, eigentlich die Tour mit zehn oder fünf Komponenten, die dann so eine Kette bilden.
[SPEAKER_00]: Und was kannst du dann dagegen machen?
[SPEAKER_01]: Ging so einen Sanderringhurt.
[SPEAKER_01]: Problem, warum heißt es eigentlich Fanderinghurt?
[SPEAKER_01]: Problem.
[SPEAKER_00]: Sehr gute Frage.
[SPEAKER_00]: Ich hab Jet-Gepidierfeißung gefragt, weil ich einfach nicht weiß.
[SPEAKER_00]: Das Sanderringhurt problem heißt so, weil es bildlich an eine stammtende Herde, so eine Herde von Tieren, z.B.
[SPEAKER_00]: sonst erinnert, die plötzlich alle gleichzeitig losrenn, wenn ein Auslöser z.B.
[SPEAKER_00]: ein Knall kommt.
[SPEAKER_00]: Ah, so ein Held.
[SPEAKER_00]: Aber, gute Frage, was kann man damit machen?
[SPEAKER_00]: Also ich mein, da kommt genau Resilience Engineering in Spiel.
[SPEAKER_00]: Also, dann lass uns mal ein bisschen nach reingehen.
[SPEAKER_00]: Und zwar, fangen wir mal mit den Basics an.
[SPEAKER_00]: Du hast eine Web App und du hast eine Datenbank und die Web App bauten Request zu Datenbank auf.
[SPEAKER_00]: Du hast nichts konfiguriert, aus irgendwelchen Gründen braucht die Datenbank eine Minute dreißig, um meine Antwort zu machen.
[SPEAKER_00]: Wann hast du das letzte Mal eine Minute dreißig auf die Response seiner Webseite gewartet?
[SPEAKER_01]: Ja, das Rennek sagt gestern im Online-Banking, aber sogar da ist ein bisschen schneller geworden mittlerweile.
[SPEAKER_00]: Na ja, du merkst ja.
[SPEAKER_00]: Wenn man lange braucht, eine Anfrage zu beantworten, dann ist das ja schon eine Art Fail ja.
[SPEAKER_00]: Allein diese Neuesie-Kunden haben Pauswirkung zum Beispiel die Request selbst brauchen länger.
[SPEAKER_00]: Beziehungsweise werden gar nicht beantwortet.
[SPEAKER_00]: Wenn eine App auf eine Anforderung Request wartet, wird eine Ressource gehalten, nämlich eine Connection auf der Datenbankseite.
[SPEAKER_00]: Da wird etwas reserviert.
[SPEAKER_00]: Wenn das viele machen, dann hast du ziemlich viele stehende Connections, weil jede Connection dauert ja Neuesie Sekunden.
[SPEAKER_00]: Die Ressourcen sei es Memories, Rets oder Verbindungen oder Teilweise auch um E-Firmelle ports.
[SPEAKER_00]: Die sind halt auch begrenzt und dabei kommt dann zu einer sogenannten Contentchen also um ein Wetschdreit um die Ressourcen.
[SPEAKER_00]: Punkt ist aber, die User Experience auch mega kacke.
[SPEAKER_00]: Wie geht man der ganzen Sache jetzt einfach vor?
[SPEAKER_00]: Und da hatten wir schon Initial darüber gesprochen.
[SPEAKER_00]: Wir sprechen jetzt mal über Timeouts.
[SPEAKER_00]: In Timeout sagt einfach, du sollst der Web App, du gibst der einfach eine Zahl mit, wenn die eine DatenbarConnection aufmacht, das ist zum Beispiel der Reisysikunden.
[SPEAKER_00]: Das bedeutet, du definierst die maximale Zeitspanne, die deine Web App auf die fertigstellung eine Anfragewarte, das auf die Anfrageleidaten.
[SPEAKER_00]: Und die Timeouts können wirklich dann für alles genommen werden.
[SPEAKER_00]: Für Remote Calls und Remote Calls sind in diesem Fall der Call.
[SPEAKER_00]: Die Datenbank für System Calls, also wenn es z.B.
[SPEAKER_00]: die GIT executable auf einem Linux-System ausfüß oder oder.
[SPEAKER_00]: Und da hast du ja schon gesagt, dafür lässt du dich eigentlich auf den Default wert von der Leibrie.
[SPEAKER_00]: Das richtig?
[SPEAKER_00]: Ich verlass mir eigentlich überall auf die Voltwerte.
[SPEAKER_00]: Was hast du denn für einen Timeout?
[SPEAKER_00]: Also, weil ein Timeout ist der Leider und jetzt kommt wieder das Exploding Head emoji, nicht gleich Timeout.
[SPEAKER_00]: Das weiß du Wolfgang oder?
[SPEAKER_01]: Ja, das Problem ist ja grundsätzlich mal, habe wir überhaupt einen Timeout.
[SPEAKER_01]: Also ich geh jetzt davon aus, ich habe einen Default Timeout, aber vielleicht habe ich auch gar keinen Timeout.
[SPEAKER_01]: Wie zum Beispiel bei meinem Zap Process Problem, was ich in der Intro erwähnt habe?
[SPEAKER_00]: Ja, ich mein, wenn, wenn, wenn dein Kleint kein Timeout hat und wir sprechen, wie nehme ich davon mal die Datenbank und nicht ein Zap Process?
[SPEAKER_00]: Ja, die Datenbank wird mit hoher Wahrscheinlichkeit auch eine, ein Max-Connection Timeout haben.
[SPEAKER_01]: Das wahrscheinlich sehr, sehr hoch ist bei einer Datenbank, weil kann da die Connection wahrscheinlich auch ewig oder ziemlich lange offen halten.
[SPEAKER_01]: Genau, teilweise auch vor Eber.
[SPEAKER_01]: Wahrscheinlich muss die aktiv sein, in der Connection natürlich aber grundsätzlicher.
[SPEAKER_00]: Ah, schönes Wort, aktiv sein.
[SPEAKER_00]: Und zwar, diese Überleitung, als hätten wir sie geplant.
[SPEAKER_00]: Also, ich meine, ein Timeout ist ja gleich nicht ein Timeout, ne?
[SPEAKER_00]: Lass mal über Timeout sprechen.
[SPEAKER_00]: Und zwar gibt es drei Arten von verschiedenen Timeouts.
[SPEAKER_00]: Es gibt aber die Connection Timeout.
[SPEAKER_00]: Es gibt aber den Read oder den Request Timeout.
[SPEAKER_00]: Und es gibt aber den Eidel Timeout.
[SPEAKER_00]: Und wenn du jetzt in einer kleinen Library einen Wert sitzt, frage ich immer.
[SPEAKER_00]: Welchen Teilmords der Zudan beziehungsweise in diesem Wert, welche Teilmord sind da drin?
[SPEAKER_00]: Ein Konnektrum Time-Mord ist die maximale Zeit, die ein klein darauf wartet eine Verbindung zu einem externen System aufzubauen.
[SPEAKER_00]: Also das Initial-Latime-Out oder das Initial-N-Darten und davon bis Teilmord.
[SPEAKER_00]: Halt, ne?
[SPEAKER_00]: So nach dem Motto, das bedeutet D&S, TLS, Autonifizierung, Autorisierung.
[SPEAKER_00]: So, der ganzen klarer Datscher dazu gehört, bis ich eine Verbindung zu daten, man kann uns auch joh jetzt keine Inquiry sind.
[SPEAKER_00]: Und daher Netzwerk dazwischen ist und User und Passwort und Verschlüsselung zu weiter und D&S.
[SPEAKER_00]: Es ist immer D&S, das Problem, das wissen wir, kann das natürlich auch in die Binnen gehen.
[SPEAKER_00]: Oder vielleicht die Leitung einfach nur sehr lang, vielleicht machen wir gerade von China nach Amerika oder ähnliches.
[SPEAKER_00]: Der zweite Timeout ist der Request Timeout oder der Read Timeout.
[SPEAKER_00]: Also das ist die maximale Zeit, die ein kleint wartet, nachdem die Verbindung bereits besteht, um auf einer Antwort vom Server zu war.
[SPEAKER_00]: Das ist also eigentlich deine Datenbankury.
[SPEAKER_00]: Select, Name, From, Users und so weiter.
[SPEAKER_00]: Dann gibt es den dritten time, das ist der Eidel-Time-Aut, das ist die Zeit, die eine inaktive Verbindung offen gehalten wird, bevor sie automatisch geschlossen wird, ohne das ein Neuer-Request gesendet.
[SPEAKER_00]: Also eigentlich kannst du sagen, ein Kleint, macht eine Verbindung auf, da beginnt der Connection Time-Out, der Verbindungsaufruhung mit Observer, so TCP-Handshaker, so weiter, dann steht die Verbindung, dann wird die Klirie gesendet, da beginnt der Request Time-Out, dann wird ja.
[SPEAKER_00]: Dann kommt die Server anvort zurück, dann wird die Antwort erhalten vom Kleint und dann beginnt der Eideteim aus.
[SPEAKER_00]: Wer schließt wann die Verbindung?
[SPEAKER_00]: Weil in der Regel hast du entweder eine Persistente Verbindung auf dem vom Kleint zum Server oder der Server schließt die Verbindung irgendwann ohne Reklein schließt.
[SPEAKER_00]: Aber ich habe gerade was von Contentchen gesprochen oder von Resource Contentchen, weil wenn du nämlich kein eilteilteimert hast, da hältst du ja ganz viele Connections und Resource und eilte rum und dran und irgendwann sie die halt begrenzt und dann voll und so mit kann die Datenbank keine neue Anfragen mehr bedienen und so mit wo dann beim nächsten Call dein Connection Time-Mot viel schlagen.
[SPEAKER_00]: Und der ist die große Frage, wenn du ein Time-Mot definierst in einer kleinen Larry was inkludiert der Time-Mot, der in S-O-L-Till Essence check, persistente Connections und so weiter und so fort.
[SPEAKER_00]: Wie viel Kleintleib ist hast du schon gesehen, wo du alle drei spezifisch definieren kannst?
[SPEAKER_00]: Oder wie viel Dokumentationen hast du schon gelesen, wo explizit gesagt wird, welcher dieser Teim aus da inkludiert ist in dieser Einzahl?
[SPEAKER_01]: Ihr habt halt ständig diese Antwort nicht, würde gerne sagen, weil ich würde gerne sagen, bei Datenbankern da kenne ich mir aus, aber sogar bei Datenbankernheim ist selten um diese Werte eigentlich bemüht, muss man sagen ja.
[SPEAKER_01]: Aus ist es war mal ein Problem und dann eher zur Wasseite.
[SPEAKER_00]: Jetzt hast du du vorlässig auf die Default-Werte, auf die Zähne, die vor Holz.
[SPEAKER_00]: Was ist denn guter Wert?
[SPEAKER_00]: Fünf Halmort.
[SPEAKER_00]: Ja, der er eingestellt ist.
[SPEAKER_00]: Schon klar.
[SPEAKER_00]: Aber wenn mal, wer mal absolut.
[SPEAKER_01]: Sie dreißig sie Kunden, okay?
[SPEAKER_01]: Ja, das ist voll Kontext abhängig, natürlich.
[SPEAKER_01]: Also, je nachdem, was für im Umfeld, ich bin.
[SPEAKER_01]: Und wie wichtig mir die Connection zum Beispiel ist.
[SPEAKER_01]: Und weil lang, da User warten kann, ist es ein Background-Prozess.
[SPEAKER_01]: Es ist ein Cohn mit dem Frontend, mit dem User.
[SPEAKER_01]: Ich bin natürlich alles mit rein.
[SPEAKER_00]: Kontext ist die eine Teemartek, aber generell ist es sehr, sehr tricky in richting Wert zu finden.
[SPEAKER_00]: Denn hast du einen hohen Wert, ist es irgendwie sinnlos in Time-Out zu setzen, denn du hältst ja die Ressourcen und du setzt ja den Time-Out und die Ressourcen nicht lange zu halten.
[SPEAKER_00]: Mit zu niedrigen Wert hast du sehr wahrscheinlich erhöhte Load oder eine erhöhte Risiko für Ausfälle, weil dann die Anfrage halt nicht in Zeit bearbeitet werden kann und du deswegen ein Fehler nach oben propagierst in die Web App.
[SPEAKER_01]: Aber wie find ich dann raus, was er gut wird ist.
[SPEAKER_01]: Also, jetzt sagst du, okay, es ist schwierig, aber in der Realität, wie schaff ist dann?
[SPEAKER_00]: Ja, sehr, sehr gute Frage.
[SPEAKER_00]: Also, ein, da habe ich ja nicht die Antwort, aber ich habe einen guten Startpunkt.
[SPEAKER_00]: Und zwar, für was habe ich dir da im Podcast, du er Spezialist, du musst jetzt die einzige Variatwort haben bitte.
[SPEAKER_00]: Und das mal auf du kommst jetzt gerade hier mit der Edipenz antwort mein Kontext und ich muss jetzt hier antwort haben das geht so nicht deswegen darf ich also immer wenn du sagst das kommt auf den Kontext auf an kann ich auch sagen das kommt auf den Kontext auf an ok das ist wie so ein backert systemachdruck backert system haben wir gleich auch noch mal aber
[SPEAKER_00]: Die erste Frage ist, wie viel Fehler kann zu akzeptieren?
[SPEAKER_00]: Wie viel Prozent deiner Request können fählen?
[SPEAKER_00]: Und wenn ihr mit dieser Frage zu eurem Produktmanager zu eure Produkmanagerin geht und die sagt null, wissen wir alle, das funktioniert so nicht.
[SPEAKER_00]: So funktioniert leider die Welt nicht.
[SPEAKER_00]: Werner Vogel sagte, was Wolfgang?
[SPEAKER_00]: Es fält alles und immer ganz genau.
[SPEAKER_00]: Deswegen kann man eigentlich als Grundregel mit Folgener zahlstagen.
[SPEAKER_00]: Sagen wir mal null, komme eins Prozent Deiner Anfragen, können Ihnen die Binsen geben, können viel schlagen.
[SPEAKER_01]: Ist es deine Annahme oder ist es ein Wert dafür dich okay wäre mit dem zu starten?
[SPEAKER_01]: Das ist für mich jetzt erstmal okay.
[SPEAKER_01]: Weil in der Realität
[SPEAKER_00]: Fällen wahrscheinlich mehr als nur ein Prozent, oder?
[SPEAKER_00]: Wahrscheinlich fehlen dann mehr, aber warum, die so nur Kuma eins, erzähle ich dir jetzt, wenn du mich mal ausreden lässt und mir zuhörst.
[SPEAKER_00]: Und sein muss... Wie nehmen einfach mal die Latens, also die Tail Latensie des Downstream Services?
[SPEAKER_00]: Das bedeutet in diesem Fall unsere Daten.
[SPEAKER_00]: Was ist denn Tail Latensie?
[SPEAKER_00]: Sorge ich dir jetzt, die Tail Latensie oder die Latens des Downstream Services beschreibt die langsamsten Antwortzeiten des Systems.
[SPEAKER_00]: Kurzum, wir messen die Responsezeiten der Datenbank.
[SPEAKER_00]: Wie lang braucht die Datenbank, die Antwort zu liefern?
[SPEAKER_00]: Ja, wenn wir mal dreien halbse Kunden.
[SPEAKER_00]: Das ist das, in den Statistik, das P-Nein, die nein, dort nein, das neuen unskümmern neuen Percentile, der Antwortzeiten, dann der Datenbank.
[SPEAKER_00]: Deswegen saften wir auch Nullkoma-Einsprozent der Request können fählen.
[SPEAKER_00]: Weil neuen Nordkümmern neuen Plus-Nullkoma-Eins sind wie viel, hundert Prozent richtig vollfangen.
[SPEAKER_01]: Und was ist das bei Zentiel?
[SPEAKER_00]: Das ist mal klar.
[SPEAKER_00]: Jetzt geht es jetzt ja jetzt hier in die Statistik.
[SPEAKER_00]: Also, du hast eine Stelle vor jeden Request.
[SPEAKER_00]: Ja?
[SPEAKER_00]: jeden Request Miss du mit.
[SPEAKER_00]: Was ja, hoffentlich mach.
[SPEAKER_00]: Natürlich, wir haben alle voller Observer Willis hier.
[SPEAKER_00]: Und jetzt sagst du, okay, wie viel deiner Anfragen werden in welcher Zeit beantwortet?
[SPEAKER_00]: Weil du willst ja sagen, okay, wie viel meiner Anfragen oder sind sehr langsam und wie viel meine Anfragen sind sehr schnell.
[SPEAKER_01]: Also wenn wir jetzt mal annehmen, wir haben Thousands Request.
[SPEAKER_01]: Und wir haben das P non-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on-on
[SPEAKER_00]: besagt, dass nur Nullkoma eins Prozent deiner Request schlechter also höher sind als der Rest der Request.
[SPEAKER_01]: Also höher in Szene von der Request Time.
[SPEAKER_01]: Das heißt ein einziges Request darf höher sein als der PN-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On-On
[SPEAKER_01]: Wenn wir die Rikwäste haben.
[SPEAKER_01]: Genau.
[SPEAKER_01]: P-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V-V.
[SPEAKER_00]: Und wenn wir jetzt drei, kommen wir fünf Sekunden auf dem Kleint als Timeout einstellen.
[SPEAKER_00]: Dann schlagen, laut unseren Messungen, null, kommen wir eins Prozent, also bei deinen Tausend Request sind das dann zehn, eins.
[SPEAKER_00]: Das ist eins, ein Request legt dann fehlen.
[SPEAKER_01]: Und das klingt jetzt vielleicht relativ weniger, aber wenn man sich überlegt, eine Million Request sind es schon, thousand Request in den null, kommen wir ein Prozent.
[SPEAKER_01]: Also das ist dann schon,
[SPEAKER_01]: gar nicht zu wenig, obwohl wir da schon in einer kommere Stelle trinzen.
[SPEAKER_00]: Und natürlich kannst du dann anfangen, deine Datenbankwürdig zu optimieren, dein Schema zu optimieren und zu weiter und zu fort.
[SPEAKER_00]: Und dann mit Messungen, den Request Time, natürlich weiter runterzudrehen.
[SPEAKER_00]: Denn drei, kümmer fünf Sekunden auf den Datenbankanfrau warten.
[SPEAKER_00]: Ist natürlich jetzt im Web Vorteil, oder jetzt im Web Kontext, oder im App Kontext, das würde ich ziemlich lange.
[SPEAKER_00]: Auch LLMs, wenn du jetzt kein Deep Sinking machst anvorten, ja schneller.
[SPEAKER_00]: Und der Grund ist, warum die die, die fägen, das so ein bisschen, weil die die Antwort raus, streamen, während sie die Antwort noch produzieren, aber das sind andere Themen.
[SPEAKER_01]: Aber man sieht schon auf jeden Fall um, überhaupt dann Entscheidungen treffen zu können, muss man mal das ganze Messen.
[SPEAKER_01]: Und da stellt sich schon, wie viele Leute messen, denn wirklich Rick West Times oder ihre Timeouts oder viele Lockman vielleicht noch, aber der Performance geht da wahrscheinlich der Prozentschutz schon nach unten von Projekten, die das wirklich machen.
[SPEAKER_01]: Aber wie Lockman, denn das ganze im Einforschnitt.
[SPEAKER_01]: Also ich habe eine Applikation, wie kommen wir das mit?
[SPEAKER_01]: Ihr habt zwar mein Log, wo kann dann ein Arrows trennen und Zeuges achten, aber wie kommen wir zu diesem Performance-Metrik?
[SPEAKER_00]: Also jetzt machen wir hier ein zweit zu eins, weil ich sag jetzt die Depends, die Depends, was du für einen Monitoring-Stack hast.
[SPEAKER_00]: Aber das Einfraste, was du schon mal machen kannst, ist schon durch das Logging-Einbauen.
[SPEAKER_00]: Das bedeutet immer, wenn du einen Retry hast oder immer, wenn du einen Datenbankerfrage sendest oder wenn die Datenangfrage zurückkommt,
[SPEAKER_00]: kannst du einfach einen Lockset-Senden database-Request-Received und dann einfach die Zeit, die es gedauert hat in einer strukturierten Lock ins Fall schreiben.
[SPEAKER_00]: Das kannst du dann später irgendwie mit irgendeinem Greb oder SED oder was hast du gar ja nicht passen.
[SPEAKER_00]: Das wäre so, dass einfachst du ohne jetzt einen großen Monitoringstag mit Prometo ist oder ähnliches zu haben.
[SPEAKER_00]: Natürlich kannst du die ganze Thematik auch mit Histogramms oder Netifistogramms.
[SPEAKER_00]: Bei Prometheus über ich schaff mal die klassischen Standard-Observility, Cloud-Native-Computer-Fondation-Tools und so weiter darstellen, da kommt es wirklich ganz auf an, was du da hast, was du für eine Reibe hast, was du für eine Applikation hast, aber ein Lock schreiben, das bedeutet in der Tie auf die Disk, ist erstmal eine super Sache.
[SPEAKER_01]: Und wenn man es ganz ordentlich machen will, springt man jetzt am besten in die Episode einhundert eins, wo wir überopendelle Metry gesprochen haben, wenn sie über den Neumann, der beschreibt auch, wie man ganz einfach einsteigen kann in den ganzen Monitoring waren, sehen würde ich fast sagen.
[SPEAKER_00]: Dass es gibt, die auf jeden Fall schon mal einen guten Start, wo man natürlich sagen muss, okay, oben Telemetry ist ja sich Prometheus, jetzt so ein Beispiel, aber es muss sich Prometheus sein, das kann auch alles anders sein, ne?
[SPEAKER_00]: Also gibt ja ähnliche Tools.
[SPEAKER_00]: Da fällt mir gerade ein, wir haben noch keine Episode dazu Prometheus gemacht, so richtig, oder?
[SPEAKER_00]: Ne, wir hatten nur den Autor vom Promissus dar, aber sonst nicht okay.
[SPEAKER_00]: Julius wollte, war bei uns in Podcast, Wolfgang viel, dem Dank, dass du dich an allem auf unsere Episode nähern kannst.
[SPEAKER_00]: Jetzt ist es aber so, und jetzt kommt mein DevOps Thema wieder auf den Tisch.
[SPEAKER_00]: Wenn wir uns mal über Infrastruktur Gedanken machen, dann ist das so, dass die Datenbank in der Regel
[SPEAKER_00]: Verteiltes und dann hat man vor der Datenbank gegebenenfalls einen Load Balancer oder bei Postgres das auf zum PG-Bauenzer oder bei Mauskuelles sind zwischen often VTES oder oder oder oder.
[SPEAKER_00]: Punkt ist man hat da in der Regel ein Klasse, vielleicht hat man auch bei einer relational Datenbank einen Split-Bit-Bit für Read and Right also was.
[SPEAKER_00]: Punkt ist, da sind ein paar hat der Komponenten oder vielleicht auch Software kommen in der Zwischen.
[SPEAKER_00]: Deswegen Achtung
[SPEAKER_00]: Auf falsch konfigurierte Timeouts.
[SPEAKER_00]: Wenn euer Timeout im Kleint in der Web App höher ist, als der Timeout von dem Load-Bellenzer vor der Datenbank, oder vor dem PG-Bauenzer, oder wie Test, machen wir uns jetzt vor, da bringt dann alles nix.
[SPEAKER_00]: Weil dann ja, weil dann die Zwischenart mehr einfach terminiert oder die Zwischensysteme, somit und da haltet euch mal mit Augen absolut.
[SPEAKER_00]: Oder du hast aber große Anforderungen, da müssen ja Teams miteinander sprechen?
[SPEAKER_00]: Ja, Moment.
[SPEAKER_00]: Und jetzt geht's ja sogar, vielleicht sogar Abteilungsübergreifentierer, Däffen mit Obst.
[SPEAKER_00]: Aber wenn wir mal das Thema Kontext Deadline aufmachen, dann müssen wir noch mehr Teams miteinander sprechen.
[SPEAKER_00]: Denn, weiß du, was eine Kontext Deadline ist, Wolfgang.
[SPEAKER_00]: Das Problem eines Timeouts ist, dass ein Timeout in der Regel die Verbindung oder die maximale Zeit einer Verbindung zwischen zwei Prozessen definiert.
[SPEAKER_00]: Jetzt sind aber moderne Systeme und Cloudsysteme ja auf eine Verbindung von fünf Systemen zehn Systemen.
[SPEAKER_00]: Wie viel hängen da so in der Kette mit drin?
[SPEAKER_00]: Eine ganze Menge.
[SPEAKER_00]: Und was interessiert mich der Timeout von einer Applikation zu seinem Data Storage, wenn fünf Applikationen in der Kette sind?
[SPEAKER_00]: Und da kommt die Kontext-Atleinenspiel.
[SPEAKER_00]: Das ist also ein Zeitpunkt in der Zukunft bis zu dem eine Operation, also ein Request oder eine Funktion, spätestens abgeschlossen werden muss.
[SPEAKER_00]: Also du kannst das ein, hier als übergeordnter Time-Out-Definiert.
[SPEAKER_00]: Jetzt schält ihr mal vor, du bist auf Amazon.com und da kommen ganz viele Produktdetails auf die Seite, hinten dran, wird das eine Masse an Request sein.
[SPEAKER_00]: Und die Summe aller Zeiten, die die Request benötigen, ist die Antwortzeit.
[SPEAKER_00]: Wie lang wartet man jetzt also ganz vorne auf der Webseite bis die Wikres alle so ich geführt werden.
[SPEAKER_00]: Jeder dieser einzelnen Subsysteme hat ein Timor von Drain-Habsekunden.
[SPEAKER_00]: Wenn Amazon.com, Drain-Habsekunden laden würde.
[SPEAKER_00]: Wenn ich mir sicher will, es zu der nicht einkaufen.
[SPEAKER_00]: Deswegen wird Amazon vorne sagen, maximal eine Sekunde.
[SPEAKER_00]: Und wenn innerhalb einer Sekunde die Antwort nicht da sind, dann wird Kaskadieren auch unten dieser Wikres einfach abgebrochen.
[SPEAKER_01]: So, und jetzt haben wir mal eine Frage an dich, in wie fehlen, es ist auf der Komponenten, die du geschrieben hast, hast du überhaupt so einen Abbruch drinnen, dass du aktiv Sachen abbrechen kannst?
[SPEAKER_01]: Ich finde das sehr schön, was du gerade fragst.
[SPEAKER_00]: In wie viel Go hast du in letzter Zeit geschrieben?
[SPEAKER_00]: Ja, ich schreib nie, go, machst du nur du.
[SPEAKER_00]: Go hat eine tolle Komponentiniert sich Kontext.
[SPEAKER_00]: Und in jedem Netzwerkkole gibt's du einen Kontext mit rein.
[SPEAKER_00]: Und dieser Kontext kann auf Basis von entweder dann einen eigenen Programmierung, dann hat er eine Methode nicht sich abort oder Kanzelheißig glaube ich.
[SPEAKER_00]: Kurzum in der Programmierschwoll GO ist genau das, was du da gerade sagst, einen sogenannter First-class Citizen.
[SPEAKER_00]: Du gibt's ein Kontext mit an einen Red-Sourcing-Koll und kann sagen, wenn dieser Teil mal der Reich ist, dann kannst du das automatisch oder.
[SPEAKER_00]: Wenn ich eine Ero irgendwo habe, dann kannst du den Request.
[SPEAKER_00]: Also das ist ein Klaus-Klasse-Tesner bei.
[SPEAKER_01]: Ja, das geht innerhalb von der Software.
[SPEAKER_01]: Aber wenn ihr zu beherdete B.A.s.
[SPEAKER_01]: kommuniziere, dann müsste mir ja in dem Protokoll, was überlegen, wie kann ich ein Request kannst.
[SPEAKER_01]: Und weil die habe das ja schon geschickt.
[SPEAKER_01]: Ihr habt der herdete B. Connection offen und muss jetzt in meinem eigenen Protokoll dem anderen Service mitteilen.
[SPEAKER_01]: Ich breche jetzt ab, oder
[SPEAKER_01]: Kein Ernährung, das Frontent hat mir gesagt, ich muss jetzt abbrechen, bricht du den Job auch ab, den du jetzt gerade machst.
[SPEAKER_01]: Also du meinst, du meinst, du meinst, bei kascadierenden Anfragen.
[SPEAKER_01]: Genau, um das kascadierend zu machen.
[SPEAKER_00]: Das ist klar, wie super schwer ist.
[SPEAKER_00]: Ihr habt das nur nie gemacht.
[SPEAKER_00]: Meines wissen, nach kann G-APC genau das.
[SPEAKER_00]: Der Punkt ist aber, jede Applikation muss sich selbst darum kümmern, die Kohl, die aufgemacht werden, auch abzubrechen, wenn der Abstream-Kohl abgebrochen wird.
[SPEAKER_01]: Ja, aber es kann nicht so leicht zu implementieren.
[SPEAKER_01]: Also, wenn ein Konnexchen wegbricht, dass du dann wirklich den Keiner und den Kohl, den internen Job abbricht, das muss man erst mal mitdenken, so.
[SPEAKER_00]: Hundert Prozent.
[SPEAKER_00]: Aber ist das nicht genau die Antwort auf die Frage, ob wir zum Thema Timeouts, ob wir da überhaupt eine ganze Potkassipi-Sode fühlen können?
[SPEAKER_00]: Also, ich weiß ja nicht.
[SPEAKER_00]: Ich glaube,
[SPEAKER_00]: Wir quatschen jetzt schon wieder fünf, drei, drei Minuten und wir sind erst bei Timeouts, denn ein Timeout selbst ist ja eigentlich, ist das ein Ausfall oder ist das nur ein Pazielerausfall, denn das wäre gleich meine nächste Frage gewesen, was mache ich denn wenn irgendwo ein Timeout stattfindet.
[SPEAKER_01]: Also, ich muss hier reagieren irgendwie.
[SPEAKER_01]: Was machst du als User wenn ein YouTube-Video nicht led?
[SPEAKER_01]: Ja, das ist schon ganz im Frontend.
[SPEAKER_01]: Aber wenn es hinten irgendwo im Stack irgendwo, beantwortet doch mal die Frage, was machst du, wenn ein YouTube-Video nicht lert?
[SPEAKER_00]: Ja, ich reale oder, ja, dankeschön.
[SPEAKER_00]: Und das ist es, ja.
[SPEAKER_00]: Wenn du ein Teilmort hast, dann ist es natürlich schwierig, was schwierig zu wissen, egal ob du im Frontend bis oder hinten in den Nögen System ist, dass ein paar Zielerfehler oder ein Transienterfehler.
[SPEAKER_00]: Also ein paar Zielerfehler ist, wenn ein bestimmter Prozent Satz der Anfragen erfolgreich ist.
[SPEAKER_00]: Das bedeutet, dass das System ist verfügbar.
[SPEAKER_00]: Aber die Anfrage, die du schickst, einfach zu teuer und rent einfach in deinem Ort.
[SPEAKER_00]: Dann den Datenbank für wir brauchen, einfach zu lange.
[SPEAKER_00]: Oder ist das ein Transienter vieler, wenn eine Anfrage für einen kurzen Zeitraum einfach viel schlägt, weil zum Beispiel der Load-Belletzer zwischenzeitlichen Neugestadt.
[SPEAKER_00]: Das sind ja unterschiedliche Fehlerklassen.
[SPEAKER_00]: Bei beiden Fehlerklassen ist zumindest eine der Lösungen ein Reload, und das machst du ja auch mit dem YouTube-Video, haben wir halt gesprochen, also ein Retry.
[SPEAKER_00]: Und jetzt ist die Frage, hältst du ein Retry für eine gute Strategie, hältst du ein Retry für einen guten Lösungsantatz.
[SPEAKER_01]: Ja, glaube ich, es ist der einzige Lösungsansatz, weil um herauszufinden, ob wir jetzt in dem Nullkommel ein Prozent Fehlerfall drin bin, dann ich muss ja irgendwie noch mal probieren, ob wir aber herauszufinden, wo das Problem liegt, ob das Problem ist, das länger besteht oder nicht, weil wenn ich einfach immer sofort aufhören kann, natürlich auch,
[SPEAKER_01]: Und überlasst es dann dem User, dass er nochmal Reloaded, aber da ist wahrscheinlich noch schlimmer, weil der drückt dann einfach der Steierung erdige ganze Zeit und seine dann hundert die Request bis mal funktioniert.
[SPEAKER_01]: Also es ist die Frage, wo ich das mache, weil ich glaube Retrice, die einzige Möglichkeit, um irgendwas herauszufinden.
[SPEAKER_00]: Ja gut, die Alternative ist halt, dass so eine Fehler ganz nach oben gibt und Sachen okay, pass mal auf.
[SPEAKER_00]: Also wir reden jetzt hier nicht vom User Retrice, wir reden jetzt hier vom systematischen Retry, ein Programmiert in der App.
[SPEAKER_01]: Genau, ich kann, also es gibt, glaube ich, die zwei einzigen Möglichkeiten, die bricht komplett ab und muss halt jemand anderes sich drum kümmern oder ich versuchst noch mal und probiere selber herauszufinden, ob es ein Dauerhaftes Problem ist oder nicht.
[SPEAKER_00]: Ja, die dritte Lösung ist, wir machen den Retry Smartar, aber das sagen wir da sprechen wir gleich nochmal darüber.
[SPEAKER_00]: Also am Endeffekt ein Retry, denkt man darüber nach, wir gehen jetzt nicht klar.
[SPEAKER_00]: Also wir kriegen den Fehler zurück, wir haben wir sind in die Konnexchen, Teilmautgesprung, wir können keine Konnexchen aufbauen.
[SPEAKER_00]: Wir haben eine Vorlube,
[SPEAKER_00]: Wir haben da drauf.
[SPEAKER_00]: Also wir retryen sofort und aggressiv, kann man etwas sagen.
[SPEAKER_00]: Und jetzt ist die Immolienten aus der Ersteuerung erträgliche ganze Zeit.
[SPEAKER_00]: Ja, so ungefähr.
[SPEAKER_00]: Nur halt leider viel schneller, weil so schnell kann ein User nicht darum erdrücken.
[SPEAKER_00]: Und da habe ich eine schöne Annäckdote gelesen.
[SPEAKER_00]: Und zwar wiederholungen Re-Trice sind ja eigentlich völlig egoistisch.
[SPEAKER_00]: Also sind das Helfisch, wenn du so möchtest.
[SPEAKER_00]: Denn mit einem Re-Trice betonst du die Wichtigkeit der Anfrage und du verlangst
[SPEAKER_00]: dass ein anderer Dienst mehr seiner Ressourcen für die Bearbeitung deiner eigenen Anfrage einsetzt.
[SPEAKER_00]: Und jetzt du als Freelancer und das kann man fast auf alles anwenden, wenn ein Kunde zu egoistisch ist, dann kann die es doch zu weit reichenden Problemen führen.
[SPEAKER_01]: Na ja, ihr wird sagen, es scheint dann automatisch im Blockking Modus und am Server lassen wir dann erst recht viel Zeit.
[SPEAKER_00]: Also man könnte auch fast sagen, du betreibst ein bisschen wie Retry Optimierung, aber lass uns mal ganz größer darüber sprechen.
[SPEAKER_00]: Also das ist ganz ehrlich hier zu sich.
[SPEAKER_00]: Also mit dem Retry wird natürlich mehr Zeit vom Extern zur war aufgewendet und um die Erfolgschanxen fühlt deine Anfrage zu erhöhen.
[SPEAKER_00]: Man kann schon sagen Retry ist wirklich egoistisch.
[SPEAKER_00]: Und diese ganze tematik kann nämlich zu einem Retry Storm fühlen.
[SPEAKER_00]: Also wenn viele Kleinstner, Eve und gleichzeitig fehlen das Schlag eine Request einfach wiederholen, dann chem hast du auf dem anderen Server rum.
[SPEAKER_00]: Das ist auch so einer Art Connection zu dem Sundering Hurt Problem, was wir gerade erwähnt haben.
[SPEAKER_00]: Jetzt stellt ihr vor, der ist offline.
[SPEAKER_00]: So, down, also der Prozess läuft nicht.
[SPEAKER_00]: Und der wird dann wieder neu gestartet.
[SPEAKER_00]: Und dann kommt das hoch und zehntausend kleines, komm so fort.
[SPEAKER_00]: Hallo, gib mir mal eine Connection.
[SPEAKER_00]: Da macht der Server.
[SPEAKER_00]: Ja?
[SPEAKER_00]: Und dann schauen wir mal, ob der ausarmt kann.
[SPEAKER_00]: Also das funktioniert in der Regel halt nicht.
[SPEAKER_00]: Und dann fragen wir uns mal, kann denn eigentlich jeder Request überhaupt wieder holt werden.
[SPEAKER_00]: Wie oft hat es du schon ein Kontaktformular auf einer Webseite abgesendet?
[SPEAKER_00]: Du bist auf der Herzlich willkommen Seite.
[SPEAKER_00]: Wir haben ihre E-Mail erhalten, bedürks STRGR und was kommt dein im Browser?
[SPEAKER_00]: Vielen Dank.
[SPEAKER_00]: Wir haben deine Anfrage erhalten.
[SPEAKER_00]: Ja, so fern kein Redirect gemacht wurde.
[SPEAKER_00]: Und sonst kommt möchten Sie dieses Formular in Neuzen.
[SPEAKER_00]: Ja, und es wird automatisch einfach neugiesende.
[SPEAKER_00]: Genau.
[SPEAKER_00]: Und das ist natürlich an sogenannte Side Effect.
[SPEAKER_00]: Sollte man Side Effects Retrient, was retreist du?
[SPEAKER_00]: Ist deine Anfrage gerade jeden Potent oder nicht?
[SPEAKER_00]: Das ist nämlich der Unteranwende, warum er ziemlich viele Formulare, über die Postmetode im Web, nachdem sie bearbeitet wurden, noch einen Redirect machen, auch in der Verurkzeite.
[SPEAKER_00]: Damit du STR-Germachen kannst, damit du die Anfrage nicht noch mal sind.
[SPEAKER_00]: Und jetzt komm's!
[SPEAKER_00]: Jetzt bist du in einen Timeout gerandt.
[SPEAKER_00]: Beine Request.
[SPEAKER_00]: Wie weiß du denn, ob der Zeit effekt, also das Versenden dieser E-Mail oder den Eintragene Datenberg umgesetzt wurde?
[SPEAKER_00]: Also als Software.
[SPEAKER_00]: Jetzt nicht als User.
[SPEAKER_01]: Ja, je nachdem auch du schönes API Design hast natürlich.
[SPEAKER_01]: Also ganz oft so bei Payment Provider kennt man das, dass man vielleicht eine Reference ID angeben muss.
[SPEAKER_01]: Und hoffentlich würde dann der Payment Gateway sagen, Moment dieser Reference ID habe ich schon bearbeitet.
[SPEAKER_01]: Aber das ist dann schon, heilest du feste Kettet würde immer sagen und in der Realität sieht man das sehr selten zu.
[SPEAKER_00]: Und genau da kommen wir zu den Punkt Echtektoren Design.
[SPEAKER_00]: Also ich meine, du musst bei Connection Time Out für Ideen potenz Designen.
[SPEAKER_00]: Du sagst jetzt, dass der Forenser, die bei einem Payment Provider, du kannst natürlich auch auf die Art des Fehlers oder die Art des Timeouts schon irgendwie drauf reagieren.
[SPEAKER_00]: Also welchen Time Out du zurückgebt, was dir die Kontrolle über welchen Fehler du kannst, du kannst auch Antworten zurückstreamen.
[SPEAKER_01]: Wobei du natürlich nur die Möglichkeit hast, einen Fehlercode oder eine Informationen zurückzugeben, wenn es kein Teimart ist.
[SPEAKER_01]: Weil wenn du natürlich nichts zurückbekommenst und dann der kleinen Teimautet, der hat natürlich dann keine Info ab dem Idealfall, kannst du natürlich irgendwas auch Submitten und eine Informationen geben.
[SPEAKER_00]: Ja, Alternativ kannst du natürlich auf dem zu aufzurufenen System, auch die ganze Double-Cate-Logik fahren.
[SPEAKER_00]: Du merkst schon, da müssen auch Teams miteinander reden und so weiter.
[SPEAKER_01]: Ja, da sehen wir wieder bei deinem Kontext.
[SPEAKER_01]: Du kannst ja auch beim Request zum Beispiel ein Teil mitgeben, wenn die API das hergibt und dem Server sagen, ich war den nur solange und geben wir sonst nähn vor, was los ist, oder?
[SPEAKER_01]: Ja, das wäre ja auch möglich vom dies.
[SPEAKER_01]: Aber das sind wir wieder bei dem ganzen Design.
[SPEAKER_00]: Genau und ein gutes Design verhindert halt du klikarte bei den Side effects, bei eine Retry.
[SPEAKER_00]: So, jetzt, ich denke, ich denke, und das habe ich auch gelesen und das fand ich auch sehr schön, deswegen möchte ich das gerne erwähnen.
[SPEAKER_00]: Retrys ist so wie Medizin, sinnvoll in der richtigen Menge, also wie Medikament.
[SPEAKER_00]: Aber bei Ausnutzung kann es halt sehr hohen Schaden fuhrt.
[SPEAKER_00]: Denn eine Downzeit in verteilten System und fast jedes System ist ein verteiltes System zwischen
[SPEAKER_00]: Es gibt fast keine Möglichkeit, die Anzahl der Wiederholungsversuche zwischen allen Apps und allen Kleinen zu koordinieren, um die richtige Anzahl zu erreichen bzw.
[SPEAKER_00]: zu finden.
[SPEAKER_00]: Weil du willst ja dieses Thema Downstream nicht überlasten.
[SPEAKER_00]: Okay, also was mache ich dann dagegen?
[SPEAKER_00]: Ja, wie gesagt, deswegen hat diese gerade das gemacht.
[SPEAKER_00]: Mach die mal Gedanken darüber, dass wiederholungen unsere Retrist egoistisch sind.
[SPEAKER_00]: Also ist deine Anfrage, ist dein Retrieg wirklich so wichtig, dass du mehrere Sorsten auf dem Downstream Service reservierst oder nicht.
[SPEAKER_01]: Okay, also dann gehen wir mal in die Kommunistische Ecke.
[SPEAKER_01]: Wie sind dann diese Kommunistischen Retrice aus die rücksicht nehmen auf die Algemeine?
[SPEAKER_00]: Nein, im Plimentierungsmäßig haben wir gerade gesagt, wir haben eine Vorschleife.
[SPEAKER_00]: Die Vorschleife hat ein Break, wenn der Connect erfolgreich ausgefüllt wurde.
[SPEAKER_00]: Das ist doch deine klassische Programmierung, oder?
[SPEAKER_01]: Ich wollte gerade sagen, wenn du wirklich Vorschleife haben hast, aber ja, okay, man kann sich so vorstellen, ich hoffe, du hast eine Abruft-Bedingung, wenn ich es jetzt nicht nach drei Retries oder so.
[SPEAKER_00]: Oh, gut, gute Sache.
[SPEAKER_00]: Wie viel Retweiß machst du denn?
[SPEAKER_00]: Das ist schon ein Nevorfall mit I.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.E.
[SPEAKER_00]: Eine bessere Art und Weise könnte gegebenenfalls einen Back-Off-Beziehungsversinn exponentieller Back-Off sein.
[SPEAKER_00]: Also was ist das?
[SPEAKER_00]: Eigentlich ist das ein regelmäßiger Retry mit einer Pause dazwischen.
[SPEAKER_00]: Zum Beispiel alle fünf Sekunden.
[SPEAKER_00]: Und Nächsmundezieller Back-Off ist, dass du kein startischen Warte wert dazwischen hast, sondern die Warte Zeit wird nach jedem Versuch exponentieller Höhe.
[SPEAKER_00]: Das kann natürlich zu langen Back-Offs führen, also das bedeutet.
[SPEAKER_00]: Du machst den ersten Call, fält.
[SPEAKER_00]: Wartest eine Sekunde, zweiter Kohl, zwei Sekunden, dritter Kohl, vier Sekunden und so weiter.
[SPEAKER_00]: Also das ist jetzt sehr glücklich.
[SPEAKER_00]: Das kann natürlich dann zu langen Back-Off-Zeiten führen, ja, je nachdem, wie viel Erhöhungsritte hast, wenn du keine Apochbedingung hast, du hat es gerade als drei Apochbedingung genannt.
[SPEAKER_00]: Du kannst aber auch sagen, okay, das mal auf, lass uns doch einfach mal eine maximale Wartezeit einführen und sagen, wenn wir okay, wenn wir jetzt bei sixteen sind oder bei zwei und thirty Sekunden oder wie die Sekunden oder welche Einheit wir auch immer haben.
[SPEAKER_00]: Dann brechen wir, das ab.
[SPEAKER_00]: Das ist eigentlich du hast auf Basis der Anzahl der Konnexche.
[SPEAKER_00]: Es ist auf Basis der Zeit ab.
[SPEAKER_00]: Das ist ein bisschen vorherseber.
[SPEAKER_00]: Und das du, man nennt das auch Predictable Kept Exponential Backoff, das du halt nicht vor Ever wartest.
[SPEAKER_00]: Weil sonst bezahlt natürlich relativ schwierig.
[SPEAKER_01]: Okay, wenn du aber in die Realität schaust, dann hast du halt nicht immer diese kommunistischen Kleins, auch immer mit diesem Begriff aufhalten.
[SPEAKER_01]: Mit den netten Kleins, und du hast halt auch die egoistischen Kleins, oder du hast ganz viele netter Kleins, dann sind sie im Endeffekt, aber auch vielleicht trotzdem viele Requests, die du bekommst.
[SPEAKER_01]: Also was mache denn auf der Serverseite mit diesen ganzen Requests, wenn sie mir zu viel werden?
[SPEAKER_01]: Also kann ja auf der Serverseite auch reagieren.
[SPEAKER_01]: Oder muss sie davon ausgehen, dass alle netten sind auf diese
[SPEAKER_00]: Es geht nicht immer um nur, dass es zu viel Request sind, sondern auch wann diese Request ausgeführt werden.
[SPEAKER_00]: Jetzt haben wir das Problem, alle Kleins versuchen zu einer stabilen Rate zu konnecken.
[SPEAKER_00]: Also haben wir eigentlich alle Kleins, haben zu einer Pause zwischen die geben dem Server natürlich Luft zu Atmen und zu Recoveren und zu Neustarten und allem drum und ran.
[SPEAKER_00]: aber alle knallen natürlich zu selben Zeit.
[SPEAKER_00]: Und wenn wir jetzt mal um das Problem mal wirklich zu visualisieren, wenn wir jetzt das Service-Echnektur haben und auf dem höchsten Levelmachstum Retribe im Exxonizellenbeck auf und du hast ein fünf Layersystem und du hast drei Versuche pro Layers und der letzte Layers ist die Datenbank, die Datenbank schlägt fehlen.
[SPEAKER_00]: Alle Systeme oben drüber wiederholen natürlich jetzt ihre Anfragen.
[SPEAKER_00]: Das bedeutet eigentlich, dass wir die Last auf der Datenbank um das zwei, hundred, drei und forty-fache steigern.
[SPEAKER_00]: Leia ein.
[SPEAKER_00]: Bei fünf ist es.
[SPEAKER_00]: Der erste Leia macht drei Versuche.
[SPEAKER_00]: Für jeden dieser drei Versuche ruft er Leia zwei auf, dass ebenfalls drei Versuche macht.
[SPEAKER_00]: Also drei mal drei gleicheinander.
[SPEAKER_00]: Leia drei, macht auch wieder drei Versuche.
[SPEAKER_00]: Das sind wir schon bei sieben, zwanzig.
[SPEAKER_00]: Leia viel macht auch drei Versuche immer beeinnachtig.
[SPEAKER_00]: Und so mal bei Leia fünf, der direkt vor der Datenbank ist immer bei ca.
[SPEAKER_00]: Das hat natürlich eine Harte Nummer.
[SPEAKER_00]: Kurz um bei Retrise geht die Load nach oben für das Empfang dieses Themen.
[SPEAKER_00]: Und das ist die Frage, was kann man denn machen?
[SPEAKER_00]: Und da gibt's zwei eigentlich drei ganz gute Antworten.
[SPEAKER_00]: Eine Sache ist ein sogenanntes Circuitbreaker.
[SPEAKER_00]: Hat aber nichts mit dem Zirkus zu tun oder?
[SPEAKER_00]: Nein, sondern eher Circuit, ich glaube eher um den Rundkurs.
[SPEAKER_00]: Ja, Sirker ist das Schaltkreis oder genau Schaltungkreislauf.
[SPEAKER_00]: Ja.
[SPEAKER_00]: Da unterbrecher von dem Stromkreislauf zum Beispiel Sirker.
[SPEAKER_00]: Und zwar macht ein Zürgerbreaker.
[SPEAKER_00]: Der sagt einfach, ich mache jetzt einfach gar keine Konneckschme.
[SPEAKER_00]: Auf ich stoppe jetzt die U-Tries, wenn ich einen gewissen Schwellenwert überschritten habe.
[SPEAKER_00]: Kurzum, du Versuchst es dreimal.
[SPEAKER_00]: Und dann wird einfach gestoppt.
[SPEAKER_00]: Dann wird gewartet, zwanzig Sekunden.
[SPEAKER_00]: Und nach zwanzig Sekunden wird es wieder dreimal versucht.
[SPEAKER_00]: In der Hoffnung ist das System wieder da.
[SPEAKER_00]: Also kurz um ein Zürgerbreaker hat irgendwie verschiedene Zustände geschlossen, offen und halb auf dem Halb auf dem ist genau dieser.
[SPEAKER_00]: Ich versuche es wieder, ist der Service wieder da.
[SPEAKER_01]: Um wo es das Hacker Breakheads angelegt ist, der Kleid ist, der am Server oder ist der Zwischen.
[SPEAKER_00]: Ja, das kommt auf deiner Echtektur an, also, dass ich kann es in der Regel so, dass er entweder im Kleid ist oder irgendwie als Zeit kann nebenbei,
[SPEAKER_00]: z.B.
[SPEAKER_00]: in einem Kubernetes Infrastruktur, dass dein Service und Zeit gehabt und jeden Netzwerk holt über den circuitbreaker macht.
[SPEAKER_00]: Weil das hat natürlich den Vorteil, dass der circuitbreaker eine eigene Komponente sein kann und nicht als Logik in einer Software implementiert werden muss.
[SPEAKER_00]: Auf dem Server kannst du es haltig machen, klar du kannst es nach Source, IP und Port machen und so weiter ist aber schon irgendwie schwierig.
[SPEAKER_00]: Ja, seitka ist ja für mich selber, also quasi zieht's beim Server dran zumindest.
[SPEAKER_00]: Ja, genau.
[SPEAKER_00]: Also das wäre dann eine mittelkomponente zwischen Datenbank und Web Applikation in der Hinsicht.
[SPEAKER_00]: Aber das Problem bei einem Söchgebreaker ist eigentlich, wo das gibt mehrere Problem beim Söchgebreaker.
[SPEAKER_00]: Also auf der einen Seite waren reicht ein Simpler-Time-Out und waren brauche ich mehr zum Beispiel ein Söchgebreaker.
[SPEAKER_00]: Dann die zweite thematik ist, ich habe ja gerade von diesen Zuständen von wie wie beim Schaltkreis geschlossen auf dem Halb offen.
[SPEAKER_00]: Wir gesprochen das natürlich ein modales Verhalten, was natürlich unglaublich schwer zu testen ist.
[SPEAKER_00]: Also ich meine, dieses Modales Verhalten, das bedeutet den Wechsel zwischen normal.
[SPEAKER_00]: Es funktioniert alles.
[SPEAKER_00]: Zu dem Fehlermodus, es geht nichts mehr durch, zu dem Modus halb offen.
[SPEAKER_00]: Also der Test, ob der Downstream-Service wieder funktionieren, ist halt unglaublich schwierig zu testen.
[SPEAKER_00]: Denn der Wechsel waren von einem Modus in den anderen Gewächsfeld wird, ist zeitbasiert, haben wir gerade gesagt wegen dem Wartemodus, der kommt unter Las Spitzen, kommt nur auf und in bestimmten Fehler sehen er.
[SPEAKER_00]: Wenn er Downstream-Service nämlich nicht da ist, also die Simulation der ganze Thematik ist natürlich unglaublich schwierig.
[SPEAKER_00]: Und auch das Testing davon.
[SPEAKER_01]: Mir ist jetzt ja fast beindlich, aber jetzt fällt mir erst ein was Circuit Breaker natürlich heisst, Circuit Breaker ist die Sicherung.
[SPEAKER_01]: Weil das schon Last-Spitze sagst, ein LS in Deutschland einzelt, die mir bei Stromschund, den wir sprechen, das auskennen.
[SPEAKER_01]: Das hier mein Hoppe ist, aber Circuit Breaker ist also schon eher so zu sehen, wie eine Sicherung, die ihm notwendig schaltet und trausgekickt wird.
[SPEAKER_01]: Und nicht so lasst da an that Fall ist.
[SPEAKER_01]: Wenn eine Downstream-Service nicht da ist, dann würde ich mal sagen, wir haben ein Notfall.
[SPEAKER_01]: Genau, also sollte kein Traffic-Shaping oder so was sein.
[SPEAKER_01]: Also das ist schon eher für den Notfall gedacht und weniger für gezielte Steierung.
[SPEAKER_00]: Jetzt kannst du dir überlegen, immer wenn etwas schwer zu testen ist und du er hast nach Hause voll.
[SPEAKER_00]: Das beim incidentant Recovery, auf dem Schirm zu haben.
[SPEAKER_00]: Und dann genau zu wissen und das Monitoring, welchen Zuschauen wann war der Circuit Bäcker jetzt genau?
[SPEAKER_00]: Und dann die Timeline für den Postmotiv zu schreiben.
[SPEAKER_00]: Also du merkst schon, ne?
[SPEAKER_00]: Die Komplexität steigt enorm.
[SPEAKER_00]: Jetzt hast du erwähnt, du hast drei Ansätze für so was Suckelbreaker.
[SPEAKER_00]: Was gibt es noch?
[SPEAKER_00]: Suckelbreaker ist die eine thematik.
[SPEAKER_00]: Dann kommt dann noch ein sogenanntes Bucket-System oder ein Token Bucket-Retrisis-Temicht.
[SPEAKER_00]: Ich glaube, das kommt von Amazon bzw.
[SPEAKER_00]: hat jedes Amazon SDK das auf jeden Fall eingebaut.
[SPEAKER_00]: Was ganz interessant ist.
[SPEAKER_00]: Schelle dir vor, du hast ein Einmal mit Token, ja?
[SPEAKER_00]: In jedem Einmal sind einfach zehn Token drin.
[SPEAKER_00]: Und du machst ja allen Österreicher Kübel.
[SPEAKER_00]: Und bei jedem Connect zu einem Service deinem Modib, oder was, was ich nicht?
[SPEAKER_00]: Nimmst du ein Token aus deinem Eimer.
[SPEAKER_00]: Und jetzt ist der Service nicht mehr verfügbar, dann machst du ein Retry.
[SPEAKER_00]: Und weil du ja einen neuen Connect machst, nimmst du wieder ein Token aus deinem Eimer.
[SPEAKER_00]: Du kannst immer nur so viel Retry machen, wie Token es in dem Eimer sind.
[SPEAKER_00]: Mit Zamer gesagt, wir sind zehn Token in dem Eimer, also kannst du zehn Retrys machen.
[SPEAKER_00]: Und jetzt ist er einmal leer.
[SPEAKER_00]: Und du willst ein Retro machen, oder?
[SPEAKER_00]: Ja, ist nicht.
[SPEAKER_00]: Jetzt ist es aber so, da läuft neben neufiger Prozess.
[SPEAKER_00]: Der, der jeden Interval, ne neuen Token in den Einmal liegt.
[SPEAKER_01]: Ich lege den Token nicht zurück, weil mein Rick West erfolgreich war, sondern da kommt, da trappelt einfach immer ein Token nach dem anderen in den Einmal.
[SPEAKER_00]: Ganz genau.
[SPEAKER_00]: Vielleicht ist dann noch so ein Max-Cap, dass du nur Max-Centoken.
[SPEAKER_00]: Seem Einmal haben kannst, oder so.
[SPEAKER_00]: Ja, das kann auch sein.
[SPEAKER_00]: Aber das spielt jetzt keine Relle wanz für dieses Problem, oder diese Lösung, die wir jetzt hier besprechen.
[SPEAKER_01]: Das heißt, es ist eigentlich wegen Konenzator, der das nochmal klettert.
[SPEAKER_01]: Also du kannst mal einmal mehr oder einmal weniger Tokungsverwenden um so leicht die Spitzen drin zu haben, aber wenn du plötzlich kompletten Börst hast, dann nach oben schießt und ganz viele Retrice, dann wirst du gebrockt.
[SPEAKER_01]: Also es ist nochmal Intelligent, da ist ein Sackeprecke.
[SPEAKER_00]: Nee, es war eigentlich weniger intelligent meines Erachtens nach, denn du kriegst jeden Interval, also alle fünf Sekunden ne neuen Token zum Beispiel.
[SPEAKER_00]: Ja, jetzt verbrennt du deine Zehntoken, weil du eine Vorschleife hast und einfach hat, neu Konnektas.
[SPEAKER_00]: Und jetzt musst du wieder fünf Sekunden warten, bis der nächste Token kommt.
[SPEAKER_00]: Es ist also eigentlich in weicher Übergang, also du reduzierst den Retry Traffic in der kontrollierten Ahnung, weil so eine Adrosselung ist das ja.
[SPEAKER_00]: Genau, also du erlaubst ganz kurze Spitzen, aber keine Dauer Spitzen.
[SPEAKER_00]: Ganz genau.
[SPEAKER_00]: Und das ist, muss man zugeben ist natürlich auf der einen Seite viel leicht dazu testen und auch deutlich vorhersehbarer, als diese Modalwechsel zwischen offen, geschlossen und halb offen, wie so ein Zirkutbreaker.
[SPEAKER_00]: Okay, kommt jetzt noch was intelligentes?
[SPEAKER_00]: Ja, jetzt kommt noch mal mit dem Mattach.
[SPEAKER_00]: Und zwar haben wir gesagt von exponential back off.
[SPEAKER_00]: Ja, wir haben gesagt, okay, wir machen ein Retry und dann warten wir und dann ziehen wir die ganze Sache exponentiell hoch.
[SPEAKER_00]: Aber jetzt haben wir dann auch gesagt, okay, wenn jetzt alle Kleins exponentiell hochzählen, dann sind wir immer noch zu dem same Zeit da.
[SPEAKER_00]: Und dann haben wir wieder dieses Retry Storm, dieses Sundering hat Probleme zu weiter worden.
[SPEAKER_00]: Deswegen haben sich ganz viel geläuter, einen sogenannten Jitter ausgedacht.
[SPEAKER_00]: Und das ist oft in Kombination, was man ließt, Exponential Back-Off mit Jitter.
[SPEAKER_00]: Du musst dir vorstellen, wenn alle Fägeschlangen aufrufe, zu gleichen Zeit zurückkommen.
[SPEAKER_00]: Kommt es bei der Wiederholung, erneut zu konflikten nur zur Überlastung.
[SPEAKER_00]: Das hab ich ja gerade erzählt.
[SPEAKER_00]: Deswegen fügt man da so eine Art Zufälligkeit hin, zu, um die Wiederholungsversuche zeitlich zu verteilen.
[SPEAKER_00]: Über so eine Zeitlöser.
[SPEAKER_00]: Das nicht alle kleines Gleichzeitigkeiten, sondern
[SPEAKER_00]: dass wenn jetzt hundert Kleins hast, dass die hundert Kleins nicht sofort konnekten, sondern dass die hundert Kleins über fünf Sekunden gesprädelt werden.
[SPEAKER_00]: Was natürlich dann im Endeffekt hoffentlich weniger Ressourcen auf dem Ziel-Server verbrauchen muss.
[SPEAKER_00]: Also im Endeffekt ist das nicht nur sinnvoll, by-re-Trice und by-back-offs, sondern vielleicht auch eigentlich bei allen Zeitgebenden Prozisten.
[SPEAKER_00]: Stell dir mal vor, du hast auf jedem Server deiner Server-Farm, einen Grundjob, der sich von einer externen API
[SPEAKER_00]: Alle IP-Eidergessen holt oder so.
[SPEAKER_00]: Oder die aktuelle IP-Eideressen der Datenmachser.
[SPEAKER_00]: Weil wir wissen, dass in Verschopurin zwischen Dynamisch ist und deswegen IP-Eideressen-Dynamisch.
[SPEAKER_00]: Wenn du die Grundlage über alle Server mit einem Jitter versieß, das bedeutet, du lässt die alle in Minute zwölf starten und jeder kriegt eine andere Zufallzzahl, das sind, da wir fünf oder zehn oder fünf, zehn Sekunden und schadet, der eine Grundlage auf dem Server um zuhelfo fünf, der andere um zuhelfo zehn und der andere um zuhelfo fünf.
[SPEAKER_00]: Das ist dann so eine Art Randomness, wie du die Last auf dem Ziel zur war auf der API, die dann die IP erlassen zurück gibt, verteilen kannst.
[SPEAKER_01]: Und idealerweise bist du das dann auch normalen Exponential erhöhen, damit du um Anfang nicht zu lange Zeiten hast und am Ende die Zeiten vielleicht noch höher.
[SPEAKER_01]: Ja, so ein Enjitter ist in der Regel nur sinnvoll mit eine Begauf.
[SPEAKER_01]: Ganz genau.
[SPEAKER_01]: Und ja, aber das du auch den Chitter nochmal Exponential erhöhst.
[SPEAKER_01]: Weil dadurch hast du dann noch mehr Flexibilität, weil am Anfang bist du vielleicht nicht ein Chitter von zwei Sekunden haben, weil da bist du vielleicht noch schneller Retryne, aber umsohren,
[SPEAKER_01]: größer der eigentlichen Exponential Backoff wird, um zu größer bis du vielleicht auch den Cheater will.
[SPEAKER_01]: Aber das sind so Spieler ein und optimierungsprobleme dann.
[SPEAKER_00]: Da kommt es halt ganz auf an welche Jitterstrategie du wählst.
[SPEAKER_00]: Im Jitter gibt's verschiedene Strategien.
[SPEAKER_00]: Da gibt's ein Full Jitter, ein Equal Jitter und ein Deco-Related Jitter.
[SPEAKER_00]: Jeder Strategie hat da seine eigenen Vor-Nachteile mit Maximalera-Zufälligkeiten über weniger Karotisch, etc., etc.
[SPEAKER_00]: Deswegen, da muss man ein bisschen gucken, welche Jitterstrategie man wählt.
[SPEAKER_00]: Ich würde mich mal aus dem Fenster lehnen und sagen, für die meisten Use-Cases reicht eigentlich klassischer Full Jitter.
[SPEAKER_00]: Und Volljeter ist Equalent zu exponential back of midjeter, das wenn man das guckt.
[SPEAKER_01]: Es klinkt es alles sehr kompliziert.
[SPEAKER_01]: Ich muss da exponential pack off einbauen, irgendwelche randomness cheht dann noch dazu implementieren und eigentlich will ja nur irgendwie in du mein Rick Westsenden.
[SPEAKER_01]: Muss ich das alles selber programmieren oder das ist schon erwähnt, Amazon SDK, okay, aber wenn ich sonst unterwegs bin, was habe ich für Tools zur Verfügung?
[SPEAKER_01]: Klautcode.
[SPEAKER_01]: Ist ein gutes Tool, ja?
[SPEAKER_01]: Hat mir auch gerade geholfen, bei einem sehr komplexen Test von so Netzwerkproblemen, ja?
[SPEAKER_00]: Aber die Antwort ist natürlich nein, haben sich ein paar sehr klube Menschen hingersetzt oder die klube, um das Haus kommentieren, den hat da ein bisschen was geschrubelt.
[SPEAKER_00]: Also im Endeffekt gibt es natürlich für jede Sprache, irgendwelche Resilien oder vold Tolerance Libraries.
[SPEAKER_00]: Und jetzt mal hier ein paar zu nennen.
[SPEAKER_00]: Im Paisenbereich gibt es Tennis City oder Retriing.
[SPEAKER_00]: Tennis City ist in vork von Retriing Retriing, weil lange Zeit inaktiv ist jetzt wieder aktiv.
[SPEAKER_00]: Für die Paisen Leute, dann gibt es im Java Bereich gibt es Resilien vor J.
[SPEAKER_00]: Versteht diesen Trend mit, dass ihr die Java Library vor J. Am Saffeex haben muss nicht, aber oder dann gibt's Höstrichs von Netflix.
[SPEAKER_00]: Im Dort net Bereich gibt's Poly.
[SPEAKER_00]: Im Go-Bright gibt's Retrible HTTP von Hasicorp.
[SPEAKER_00]: Und ich gestagte davon aus, die Progommiersprache, die ihr vorwendet, die ihr es nicht gewähnt habt, die hat auch irgendwelche Full Turlins Libraries.
[SPEAKER_00]: Und da müsst ihr aber ein bisschen unten drunter gucken, was sie jetzt dann im Detail machen.
[SPEAKER_00]: Also ein Timeout und
[SPEAKER_00]: Ein exponentische Back-Off und Reed-Sry, also weiter werden, die alles haben, ein Jitter, da fängt schon wieder langsam an und dann verschiedene Jitterstrategien oder die einzelnen Definition von Connection, Reed und Eidel Timeout.
[SPEAKER_00]: Also da müssen wir dann im Detail mal drunter gucken, weil auf der einen Seite versuchen, diese Leivrische natürlich möglichst viel abzudenken.
[SPEAKER_01]: Und ist das jetzt eine Kombination gewesen, abzudenken.
[SPEAKER_01]: Also eine Mischung, abzudenken und wir einen Mitdenken ist das so eine neue Wortkreation.
[SPEAKER_00]: Vielleicht für Asorveno versprecher, aber ihr wisst, was ich meine, das tut mir nicht so im Floor.
[SPEAKER_00]: Aber auf der, also wie gesagt, auf der einen Seite wollen die halt ziemlich viele Funktionität anbieten und auf der anderen Seite natürlich schon ein gutes UI und API Design.
[SPEAKER_00]: Deswegen müssen wir mal ein bisschen gucken, was man alles konfigurieren kann.
[SPEAKER_01]: Bei man auch dazu sagen muss, es ist nicht super schwer selber zu implementieren.
[SPEAKER_01]: Also wir sprechen da oft wirklich von fünf Zahlen Code, wenn man sowas noch mit hinzufügt und
[SPEAKER_01]: Ja, schreibt ihr schon dein LLM, deines Vertrauens ist normalerweise kein Problem, sagst du einfach, okay, exponential backup und du hast nur ein paar Zahlen im Code rund herum und das ist okay.
[SPEAKER_00]: Da, die ich mit dem Wolfgang nicht mit, denn ich denke, diese ganze Thematik ist nicht einfach zu implementieren.
[SPEAKER_00]: Besonders kommt es nämlich immer ganz einfach mit welchen System ihr spricht.
[SPEAKER_00]: Nehmen wir mal RabbitMQ als Beispiel.
[SPEAKER_00]: Bei RabbitMQ machst du das ein Messisch-Q-System, dann machst du eine Connection zum Server auf.
[SPEAKER_00]: Wenn du ihn, wenn du die Connection hast, dann machst du erst mal einen neuen Kommunikations-Channel auf.
[SPEAKER_00]: Wenn du diesen Kommunikationschellen hast, dann kannst du da Konsumen oder Producen drin.
[SPEAKER_00]: Das bedeutet, du hast nicht nur eine Connection, du hast mehrere Connections, nur für deine Datenbank, die du einzeln händeln musst.
[SPEAKER_00]: Und dann kommt es natürlich mit der ganzen Zeit, die Fektoren und so weiter, was kannst du reitrollen, was wirst du nicht reitrollen.
[SPEAKER_00]: Also, das ist alles nicht so einfach wieder wofür das denkt.
[SPEAKER_01]: Es kommt drauf an, in was für ein Kontext du licht bewegst, wie immer.
[SPEAKER_01]: Aber es gibt da ganz viele Fälle, da ist es super einfach, wenn du einfach
[SPEAKER_01]: nur eine API abfrägst die ganze Zeit und da einfach ein Backhoff drin und hast gar kein Problem.
[SPEAKER_01]: Wenn du eine Q hast und einfach mit ein Backhoff wartest, bist du den Request wieder in die Q reinzendest, dass der wiederholt wird auch relativ easy.
[SPEAKER_01]: Wenn du natürlich in komplexen Connections umgebungen, wo persistente Connections drin sind und solche Sachen, das ist natürlich dann noch mal schwieriger.
[SPEAKER_01]: Aber ich sage noch ganz oft, wenn jetzt
[SPEAKER_01]: Das Tool, deiner Wahl, das nicht hergebt oder die programmiersprache oder das Connection Framework, ist es oft auch relativ einfach da, was drumherum zu bauen, aber kommt noch die Kaffte Nioskastraffer.
[SPEAKER_01]: Aber man muss es nicht immer verübergt komplizieren und da, was sie auch schneller vielleicht drei Teilen kurz selbst zu schreiben, als ein komplettes Riesen Framework reinzunehmen, was das Ganze auch wieder komplex macht.
[SPEAKER_00]: Bei der Framework tematik bin ich da bei dir ab und zu dieses leichter Selbstzuschreiben als die große Depanizierung zu holen, aber dennoch möchte ich dir jetzt hier mal auf die Ziel danken wollen, wegen deiner Ansicht, dass das alles so einfach ist, habe ich in den letzten zwölf Jahren einfach ein Job gehabt, weil eigentlich habe ich genau so was zu mich wie gemacht.
[SPEAKER_00]: In jeder Replikation hoht ich solche Art von Grimmendenstraus, optimier das mit Graceful Schattern und allen Dungen dran.
[SPEAKER_00]: Und hey, siehe da.
[SPEAKER_00]: Ich habe dadurch zwölf Jahre sehr erfolgreich meine Miete bezahlt.
[SPEAKER_00]: Also, bitte haben wir dieses Mindset weiter hin, dass das alles sehr einfach ist.
[SPEAKER_00]: Du, sicherst meine Job.
[SPEAKER_00]: Mach ich doch gar nicht.
[SPEAKER_00]: Aber jetzt können wir natürlich ziemlich viel Überleiblich zum Sparchen sprechen.
[SPEAKER_00]: Aber ein Tool möchte ich euch wirklich ans Herz legen.
[SPEAKER_00]: Und dann sind wir auch schon fast am Ende dieser Episode.
[SPEAKER_00]: Und zwar ist das Toxie-Proxy.
[SPEAKER_00]: Aber nur weil es so cool klingt oder oder macht es auch Sinn.
[SPEAKER_00]: Ne, das macht auch wirklich Sinn.
[SPEAKER_00]: ToxyProxy ist ein Tool, was so zwischen einer Web und einer Datenbank zum Beispiel packt.
[SPEAKER_00]: Und dann kannst du sagen, okay pack mal da bitte zwei hundred Millysikonletensied drauf oder lasst nur die Hälfte der TCP-Pakete ankommen.
[SPEAKER_00]: Und so weiter.
[SPEAKER_00]: Punkt ist, da kannst du halt dein Netzwerk Fail-Jahr simulieren und du mit deinem System conditions du deine Re-Trice oder da Back-Off, da Jitter und so weiter und so fort ordentlich testen.
[SPEAKER_00]: Und dann kannst du natürlich auch Partzielle und Transiente fehler, von dem wir gerade auch besprochen haben, für die Leute, die richtig gut zuhören, testen, wie verhält sich die ganze thematik.
[SPEAKER_00]: Natürlich ist es kein Junit oder Integrationssystem, sondern eher in manuellen Test, natürlich kannst du auch sehr viel Arbeit da reinstecken.
[SPEAKER_00]: Jetzt ist er dazu automatisieren.
[SPEAKER_00]: Aber da, das würde ich euch mal ins Herz legen, ist relativ schnell und relativ einfach aufgesetzt, ist wirklich interessant, damit mal eine Runde rumzuspielen.
[SPEAKER_00]: Und dann natürlich Achtung, wenn ihr observiert, hier auf Euren Retweiss habt ihr vor dem Backoff auf den Gitter.
[SPEAKER_00]: Auf die Teilen und ja, pinaint hinein.nein, war horenger global gesprochen, Pessertile, um das wirklich mal zu testen und zu visualisieren.
[SPEAKER_01]: Also ich glaube, weil du jetzt auch Juni Test erwähnt hast, es sind ja zwei unterschiedliche Test-Auten.
[SPEAKER_01]: Ich war selber gerade überrascht, weil in Beisen entdeckt habe, bzw.
[SPEAKER_01]: LM mir geholfen hat dabei, bei der wir programmieren.
[SPEAKER_01]: Nicht unbedingt freiwillig in dem Kontext, weil man zum Netzwerk träffigt wird.
[SPEAKER_01]: Aber man kann also ein Juni Test dann wirklich testen, funktioniert.
[SPEAKER_01]: Der Retry Mechanismus, was ist, wenn die Retrys höher setze,
[SPEAKER_01]: funktioniert dann mein Code richtig, wenn die Fehler richtig behandelt.
[SPEAKER_01]: Also das kann man alles mittlerweile sehr gut simulieren und testen, aber das testet halt nur meinen Code und wie der reagiert und da testet nicht die Applikation live, was da Toxie Proxinert durchschauen macht, weil da kann ich dann wirklich einiges simulieren, vielleicht sogar Last drauflegen und da Toxie Proxie in checktet mir dann Probleme.
[SPEAKER_01]: Und das ist natürlich schon ein anderer Testcase, als wir wenn jetzt Juni testen macht und im Idealfall machen, natürlich beides.
[SPEAKER_00]: Und um Anfang der Epi-Sode saß der Wolfgang auch noch nicht hohenlos.
[SPEAKER_00]: Ah, wie Trice, Timeouts ist ein ganz einfaches Thema.
[SPEAKER_00]: Können wir da überhaupt eine Epi-Sode zu machen?
[SPEAKER_00]: So, um Ende der Epi-Sode haben wir jetzt eine Stunde oder ein bisschen mehr auf der Uhr.
[SPEAKER_00]: Und als ich die Epi-Sode so ein bisschen vorbereitet habe, da habe ich mich eher dazu gezwungen Sachen wegzulassen.
[SPEAKER_00]: Also, wir haben jetzt über Timeouts, Re-Trice, Back-Off, Exponential, Back-Off.
[SPEAKER_00]: Das Amazon To-Kenn-Bucket System gesprochen über Gitter und Zowalter.
[SPEAKER_00]: Wir haben Themen wie Rate-Limiting, Bike-Hat-Petlands, also die Abschattung von Teil-Service um Fehler zu isolieren.
[SPEAKER_00]: Hatching, also Redu-Dunter-Request mit Karnzeln nach der ersten Antwort.
[SPEAKER_00]: Wir hatten zwar über Kontext-Set-Lang gesprochen, aber nicht über Redu-Dunter-Request.
[SPEAKER_00]: Load-Shading.
[SPEAKER_00]: Also, wenn ein System selbst erkennt, dass es überlastet ist, dass wir andere Sachen einfach abschalten können.
[SPEAKER_00]: Adaptive-Srotting, ja, so dynamisch entscheiden, welche Anfragen wir zulassen, welche wir vorzögern,
[SPEAKER_00]: um auch das eigene System zu protecten.
[SPEAKER_00]: Amazon Brown aus, yeah.
[SPEAKER_00]: Blackout, ich glaube, hat da ausfallbrown als ein teilweise Ausfall und dann die Aktivierung von nicht kritische Funktionität.
[SPEAKER_00]: Oh, da sogar Alternativenstrategien zu einem Retry, also FAFAS, Keywing, Asynchronität und so weiter.
[SPEAKER_00]: Überall so was haben wir doch gar nicht gesprochen.
[SPEAKER_00]: Also war von theoretisch, wenn die Community erst möcht und das könnt ihr uns gerne über Social Media über Email oder über Discord wissen lassen.
[SPEAKER_00]: Machen wir gerne noch mal eine zweite, vielleicht sogar eine dritte Episode zum Thema Reseries, Engineering und vielleicht fühlen wir auch mal eine ganze Episode einfach nur mit Red, Limitting wie man das eigentlich in der API mal berücksichtigen kann, weil da gibt es nämlich auch ein paar schöne Beispiele in der Wildnis.
[SPEAKER_01]: Probieren wir das gleich mal zu konkretisieren.
[SPEAKER_01]: Ihr könnt jetzt in allen Euren Podcasts, Apps, die ihr jetzt gerade verwendet, einfach rund das Grollen in den Shownotes.
[SPEAKER_01]: Und da gibt's so ein Phams Up und Phams Down.
[SPEAKER_01]: Für alle, wo jetzt was Neues dabei gewesen ist, nicht so oder da Großteil, neu war, bitte gern Phams Up, da Rest auf.
[SPEAKER_01]: wirklich mal färmstaun drücken, einfach wenn nicht so viel Neues dabei war, damit wir mal wirklich aus der Menge auch eine Informationen bekommen, die viel Neues war eigentlich für euch dabei.
[SPEAKER_01]: Es würde uns wirklich interessieren und dann kann ich da im Ande vielleicht den Statistik auch zeigen, damit wir da mal zahlen dahinter haben.
[SPEAKER_01]: Aber ich war jetzt doch einiges für mich zumindest dabei, an den in dem Fall vielen Dank für deine Haarezonte Erweiterung.
[SPEAKER_01]: Bist du schon nie schon losgegangen und hast uns abgedrückt?
[SPEAKER_01]: Fragst du jetzt mich, oder?
[SPEAKER_01]: Ja, ja, müsst ihr ja für einen Wolfe in der Zukunft sprechen, der existiert ja jetzt in dem Moment noch nicht.
[SPEAKER_01]: So gut ist unsere Automatisierung noch nicht, dass die schon noch schon erstellt werden, bevor wir die Episode aufgenommen haben.
[SPEAKER_00]: Und wie immer gilt, wer sich da ein bisschen mehr einlesen möchte, kann in die Schonnutz gehen.
[SPEAKER_00]: Da haben wir natürlich eine ganze Menge und ich erlingsarber.
[SPEAKER_00]: Wer auch Bock hat mit mir über Resilginz-Enginehmungszusprechen.
[SPEAKER_00]: Denn das ist einer meiner Herzsystem.
[SPEAKER_00]: Ich glaube, wir haben eine Zoffentwicklungsstände einfach da reinposten.
[SPEAKER_00]: Und ich werde das dann schon sehen.
[SPEAKER_00]: Deswegen wäre da Bock hat ein bisschen mit mir zu über das Gutieren.
[SPEAKER_00]: Aber ich will gern auch wissen, wie ihr das in einer Woche filmen macht.
[SPEAKER_00]: Hab ihr so eine Stelle, also gibt es Leute, die sich darum kümmern.
[SPEAKER_00]: Oder ist das Teil aus normalen Produkt-Feature-Inwicklungsprozesses, das über sowas nachdenkt?
[SPEAKER_00]: Oder wird das alles durch Cloud-Native-Infrocher-Pur und irgendwelchen Proxies und Zeit-Kasung sowas gelöst?
[SPEAKER_00]: Also kümmern sich da irgendwelche Däfferkleutung.
[SPEAKER_00]: Und wie funktioniert eigentlich die Kommunikation zwischen den Software-Entwicklern, den Däfferpläuten und den Obstlern?
[SPEAKER_00]: In der Timer- und Abstimmung mit der Kontext-Settlein und den Notbeln-Settleimungs- und so weiter und so fort?
[SPEAKER_00]: Oder habt ihr dauerhaft auf Ausfälle, weil ihr eure Timeouts und Retrice und allem drum und dran nicht untergetrunnt.
[SPEAKER_00]: Also, da müssen wir keine Namen nehmen, weil ich steh nicht so auf Blaming, aber wir überinteressieren und machen uns nichts vor, irgendwie grün sind, weil er alle so ein bisschen.
[SPEAKER_01]: Ich habe übrigens noch ein Pro-Tip, die man die Kleinen zerziehen kann, man kann einfach die API-Colse kostenpflichtig machen und mit jedem API-Colzeilst du was, dann fangen die Kleins automatisch an sich drauf zu verhalten.
[SPEAKER_00]: Ich glaube, der Wolfgang hat die Akköln News von dem Cloudflayer konnte in die Pändeste gelesen.
[SPEAKER_00]: Aber lassen wir das mal so stehen.
[SPEAKER_00]: Wir verabschieden uns für diese Woche.
[SPEAKER_00]: Wir würden uns super freuen, wenn die die Episode gefallen hat und du, die den Link mal schnapps und in deinem Slex Channel Microsoft Teams.
[SPEAKER_00]: Krief dabei.
[SPEAKER_00]: Oder IAC, Deiner Wahl.
[SPEAKER_00]: Tiles oder vielleicht einfach per WhatsApp.
[SPEAKER_00]: Also mich wird es so.
[SPEAKER_01]: Wenn ihr Brief da ob es sagt, falls die IORC ein, aber selbst Alter, selbst Alter.
[SPEAKER_01]: Erweh wird den unsradiskot Community des jetzt schon zerlegen, weiß ich schon.
[SPEAKER_00]: Einfach mal die Episoluteilen wird uns sehr freuen.
[SPEAKER_00]: Ansonsten würde ich sagen, vielen Dank, dass du ein bisschen zugehört hast, denn die Flachenwitze von Raufgang kann ich nicht mehr hören.
[SPEAKER_00]: Aber Raufgang, damit du jetzt auch noch mal auszulachen hast, zum Ende noch ein etwas Haterwitz, oder kommt zweitmarrecher.
[SPEAKER_00]: Der eine ist nicht so brutal als er andere.
[SPEAKER_00]: Es ist wirklich saunter, die muss mit deiner Witzen reicher rumschlagen.
[SPEAKER_00]: Es ist doppelt schlimm.
[SPEAKER_00]: Wo schwimmen Nazi-Enten, wo im dritten Teich?
[SPEAKER_00]: Ja, der zweite ist ein dick besser, aber auch ein bisschen brutaler.
[SPEAKER_00]: Der Film Titanic kam in Amerika besser an als das Schiff.
[SPEAKER_01]: Es ist auch sehr gut.
[SPEAKER_01]: Es ist wirklich zwei, zwei gute gefällt mir.
[SPEAKER_00]: Bekommst du uns färms ab?
[SPEAKER_00]: Vielleicht noch wenn ihr nächste Episode noch mal ein paar, ich hab noch ein paar auf Lager hier.
[SPEAKER_00]: Und das muss mich sagen, Tschüss bis nächste Woche, bye-bye.
[SPEAKER_00]: Ciao.