Bestëmmung vun der entspriechender Gréisst fir e Kafka-Cluster zu Kubernetes

Note. iwwersat.: An dësem Artikel deelt Banzai Cloud e Beispill vu wéi seng personaliséiert Tools kënne benotzt ginn fir Kafka méi einfach ze benotzen bannent Kubernetes. Déi folgend Instruktiounen illustréieren wéi Dir d'optimal Gréisst vun Ärer Infrastruktur bestëmmen kënnt a Kafka selwer konfiguréieren fir den erfuerderlechen Duerchgang z'erreechen.

Apache Kafka ass eng verdeelt Streaming Plattform fir zouverlässeg, skalierbar an héich performant Echtzäit Streaming Systemer ze kreéieren. Seng beandrockend Fäegkeeten kënne mat Kubernetes verlängert ginn. Fir dëst hu mir entwéckelt Open Source Kafka Bedreiwer an engem Outil genannt Supertubes. Si erlaben Iech Kafka op Kubernetes ze lafen a seng verschidde Funktiounen ze benotzen, wéi d'Feintuning vun der Broker Konfiguratioun, metresch-baséiert Skala mat Rebalancing, Rack Sensibiliséierung, "mëll" (graciéis) Ausrollen vun Updates, etc.

Probéiert Supertubes an Ärem Cluster:

curl https://getsupertubes.sh | sh и supertubes install -a --no-democluster --kubeconfig <path-to-eks-cluster-kubeconfig-file>

Oder Kontakt Dokumentatioun. Dir kënnt och iwwer e puer vun de Fäegkeete vu Kafka liesen, d'Aarbecht mat deem automatiséiert gëtt mat Supertubes a Kafka Bedreiwer. Mir hu schonn iwwer si um Blog geschriwwen:

• Oh nee! Nach en anere Kafka Bedreiwer fir Kubernetes;
• Iwwerwaacht a bedreift Kafka baséiert op Prometheus Metriken;
• Kafka Rack Sensibiliséierung op Kubernetes;
• Apache Kafka iwwer Istio lafen - Benchmark;
• Benotzer authentifizéiert an Zougang kontrolléiert Cluster mam Kafka Bedreiwer;
• Kafka Rolling Upgrade an dynamesch Konfiguratioun op Kubernetes;
• Envoy Protokoll Filter fir Kafka, meshed.

Wann Dir décidéiert fir e Kafka-Cluster op Kubernetes z'installéieren, wäert Dir wahrscheinlech mat der Erausfuerderung konfrontéiert sinn déi optimal Gréisst vun der Basisdaten Infrastruktur ze bestëmmen an d'Noutwendegkeet Är Kafka-Konfiguratioun ze feinstëmmen fir d'Duerchsatzfuerderunge gerecht ze ginn. Déi maximal Leeschtung vun all Broker gëtt vun der Leeschtung vun den ënnerierdesche Infrastrukturkomponenten festgeluegt, wéi Erënnerung, Prozessor, Scheifgeschwindegkeet, Netzwierkbandbreedung, asw.

Idealerweis sollt d'Brokerkonfiguratioun sou sinn datt all Infrastrukturelementer op hir maximal Fäegkeeten benotzt ginn. Wéi och ëmmer, am richtege Liewen ass dëse Setup zimlech komplex. Et ass méi wahrscheinlech datt d'Benotzer Broker konfiguréieren fir d'Benotzung vun engem oder zwee Komponenten (Disk, Erënnerung oder Prozessor) maximéieren. Am Allgemengen, weist e Broker maximal Leeschtung wann seng Konfiguratioun erlaabt datt de luesste Bestanddeel zu sengem vollsten Ausmooss benotzt gëtt. Op dës Manéier kënne mir eng graff Iddi vun der Laascht kréien, déi ee Broker kann handhaben.

Theoretesch kënne mir och d'Zuel vun de Broker schätzen déi néideg ass fir eng bestëmmte Laascht ze handhaben. Wéi och ëmmer, an der Praxis ginn et sou vill Konfiguratiounsoptiounen op verschiddene Niveauen datt et ganz schwéier ass (wann net onméiglech) d'potenziell Leeschtung vun enger bestëmmter Konfiguratioun ze evaluéieren. An anere Wierder, et ass ganz schwéier eng Konfiguratioun ze plangen baséiert op enger bestëmmter Leeschtung.

Fir Supertubes Benotzer hu mir normalerweis déi folgend Approche: mir fänken un mat enger Konfiguratioun (Infrastruktur + Astellungen), da moosst seng Leeschtung, passen d'Broker-Astellungen un a widderhuelen de Prozess nach eng Kéier. Dëst geschitt bis de luesste Bestanddeel vun der Infrastruktur voll genotzt gëtt.

Op dës Manéier kréie mir eng méi kloer Iddi wéivill Broker e Stärekoup brauch fir eng gewësse Laascht ze handhaben (d'Zuel vun de Courtiere hänkt och vun anere Faktoren of, sou wéi d'Mindestzuel vu Messagerepliken fir Widderstandsfäegkeet ze garantéieren, d'Zuel vun de Partitionen Leader, etc.). Zousätzlech kréie mir Abléck an wéi eng Infrastrukturkomponente vertikal Skaléierung erfuerderen.

Dësen Artikel schwätzt iwwer d'Schrëtt déi mir huelen fir dat Bescht aus de luesste Komponenten an initial Konfiguratiounen ze kréien an den Duerchgang vun engem Kafka Cluster ze moossen. Eng héich elastesch Konfiguratioun erfuerdert op d'mannst dräi lafen Broker (min.insync.replicas=3), iwwer dräi verschidden Accessibilitéitszonen verdeelt. Fir d'Kubernetes Infrastruktur ze konfiguréieren, ze skaléieren an ze iwwerwaachen, benotze mir eis eege Containermanagementplattform fir Hybridwolleken - Pipeline. Et ënnerstëtzt on-premise (bare Metal, VMware) a fënnef Aarte vu Wolleken (Alibaba, AWS, Azure, Google, Oracle), souwéi all Kombinatioun vun hinnen.

Gedanken iwwer Kafka Cluster Infrastruktur a Konfiguratioun

Fir d'Beispiller hei drënner hu mir AWS als Cloud Provider an EKS als Kubernetes Verdeelung gewielt. Eng ähnlech Konfiguratioun ka mat Hëllef ëmgesat ginn P.K.E. - Kubernetes Verdeelung vun Banzai Cloud, zertifizéiert vun CNCF.

Scheif

Amazon bitt verschidde EBS Volumen Typen. Am Kär gp2 и io1 et sinn SSD fiert, Ee, fir eng héich Débit ze garantéieren gp2 verbraucht cumuléierten Kreditter (I/O Credits), also hu mir den Typ léiwer gemaach io1, déi konsequent héich Débit ubitt.

Instanz Typen

D'Performance vum Kafka ass héich ofhängeg vum Betribssystem Säit Cache, also brauche mir Instanzen mat genuch Erënnerung fir de Broker (JVM) a Säit Cache. Instanz c5.2x grouss - e gudde Start, well et huet 16 GB Erënnerung an optimiséiert fir mat EBS ze schaffen. Säin Nodeel ass datt et nëmme fäeg ass maximal Leeschtung fir net méi wéi 30 Minutten all 24 Stonnen ze liwweren. Wann Är Aarbechtsbelaaschtung eng Héichleistung iwwer eng méi laang Zäit erfuerdert, wëllt Dir vläicht aner Instanztypen berücksichtegen. Dat ass genau wat mir gemaach hunn, ophalen c5.4x grouss. Et bitt maximal Duerchsetze an 593,75 Mbps. Maximum Duerchgang vun engem EBS Volumen io1 méi héich wéi d'Instanz c5.4x grouss, also de luesste Element vun der Infrastruktur ass méiglecherweis den I/O Duerchgang vun dëser Instanztyp (wat eis Laaschtester och bestätegen).

Netz

Den Netzduerchgang muss grouss genuch sinn am Verglach mat der Leeschtung vun der VM Instanz an der Scheif, soss gëtt d'Netzwierk e Flaschenhals. An eisem Fall, d'Netzwierk Interface c5.4x grouss Ënnerstëtzt Geschwindegkeete vu bis zu 10 Gb / s, wat wesentlech méi héich ass wéi den I / O Duerchgang vun enger VM Instanz.

Broker Deployment

Broker sollen ofgesat ginn (geplangt a Kubernetes) op engagéierten Noden fir ze vermeiden mat anere Prozesser fir CPU, Erënnerung, Netzwierk an Diskressourcen ze konkurréieren.

Java Versioun

Déi logesch Wiel ass Java 11 well et kompatibel ass mat Docker am Sënn datt de JVM korrekt d'Prozessoren an d'Erënnerung fir de Container bestëmmt an deem de Broker leeft. Wësse datt CPU Limiten wichteg sinn, setzt de JVM intern an transparent d'Zuel vun de GC thread an JIT thread. Mir hunn de Kafka Bild benotzt banzaicloud/kafka:2.13-2.4.0, déi Kafka Versioun 2.4.0 (Scala 2.13) op Java 11 enthält.

Wann Dir méi iwwer Java / JVM op Kubernetes léiere wëllt, kuckt eis folgend Posts:

• Firwat meng Java Applikatioun OOMKilled ass;
• Wéi richteg Gréisst Container fir Java 10 Uwendungen.

Broker Erënnerung Astellunge

Et ginn zwee Schlësselaspekter fir de Broker Memory ze konfiguréieren: Astellunge fir de JVM a fir de Kubernetes Pod. D'Erënnerungslimit, déi fir e Pod festgeluegt ass, muss méi grouss sinn wéi déi maximal Heapgréisst, sou datt de JVM Plaz fir de Java Metaspace huet, deen a sengem eegene Gedächtnis wunnt a fir de Betribssystem Säit Cache deen Kafka aktiv benotzt. An eisen Tester hu mir Kafka Broker mat Parameteren lancéiert -Xmx4G -Xms2G, an d'Erënnerungslimit fir de Pod war 10 Gi. Notéiert w.e.g. datt d'Erënnerungsastellunge fir de JVM automatesch kritt kënne ginn -XX:MaxRAMPercentage и -X:MinRAMPercentage, baséiert op der Erënnerung Limite fir de Pod.

Broker Prozessor Astellunge

Am Allgemengen kënnt Dir d'Performance verbesseren andeems Dir d'Parallalismus erhéijen andeems Dir d'Zuel vun de thread, déi vum Kafka benotzt gëtt, erhéijen. Wat méi Prozessoren fir Kafka verfügbar sinn, wat besser. An eisem Test hu mir mat enger Limite vu 6 Prozessoren ugefaang a lues a lues (duerch Iteratiounen) hir Zuel op 15 erhéicht. num.network.threads=12 an de Broker-Astellunge fir d'Zuel vun de Threads ze erhéijen déi Daten aus dem Netz kréien an se schécken. Direkt z'entdecken datt d'Follower Broker net séier genuch Replikae konnten kréien, hunn se opgewuess num.replica.fetchers bis 4 fir d'Geschwindegkeet ze erhéijen, mat där Follower Broker Messagen vu Leader replizéiert hunn.

Lueden Generatioun Tool

Dir sollt suergen datt de gewielte Lastgenerator net aus der Kapazitéit leeft ier de Kafka-Cluster (dee benchmarkéiert gëtt) seng maximal Belaaschtung erreecht. An anere Wierder, et ass néideg eng virleefeg Bewäertung vun de Fäegkeeten vum Laaschtgeneratiounsinstrument ze maachen, an och Instanztypen fir et mat enger genuch Zuel vu Prozessoren an Erënnerung ze wielen. An dësem Fall wäert eist Tool méi Laascht produzéieren wéi de Kafka Cluster kann handhaben. No villen Experimenter hu mir eis op dräi Exemplare festgeluecht c5.4x grouss, jidderee vun deenen e Generator lafen huet.

Benchmarking

Leeschtungsmessung ass en iterative Prozess deen déi folgend Etappen enthält:

• Infrastruktur opbauen (EKS Cluster, Kafka Cluster, Last Generatioun Tool, souwéi Prometheus a Grafana);
• Generéiere vun enger Laascht fir eng gewëssen Zäit fir zoufälleg Ofwäichungen an de gesammelten Leeschtungsindikatoren ze filteren;
• Upassung vun der Broker Infrastruktur a Konfiguratioun baséiert op observéiert Leeschtungsindikatoren;
• widderhuelen de Prozess bis den erfuerderlechen Niveau vum Kafka-Cluster-Duerchgang erreecht gëtt. Zur selwechter Zäit muss et konsequent reproduzéierbar sinn a minimale Variatiounen am Duerchgang weisen.

Déi nächst Sektioun beschreift d'Schrëtt déi während dem Testcluster Benchmarking Prozess gemaach goufen.

Tools

Déi folgend Tools goufen benotzt fir séier eng Basiskonfiguratioun z'installéieren, Lasten ze generéieren an d'Leeschtung ze moossen:

• Banzai Cloud Pipeline fir en EKS-Cluster vun Amazon ze organiséieren c Prometheus (fir Kafka an Infrastruktur Metriken ze sammelen) an grafana (fir dës Metriken ze visualiséieren). Mir hu profitéiert integréiert в Pipeline Servicer déi federéiert Iwwerwaachung ubidden, zentraliséiert Log Sammlung, Schwachstelle Scannen, Katastrophen Erhuelung, Enterprise-Grad Sécherheet a vill méi.
• Sangrenel - e Tool fir d'Laaschttest e Kafka Cluster.
• Grafana Dashboards fir Kafka Metriken an Infrastruktur ze visualiséieren: Kubernetes Kafka, Node Exporter.
• Supertubes CLI fir den einfachste Wee fir e Kafka-Cluster op Kubernetes opzestellen. Zookeeper, Kafka Bedreiwer, Envoy a vill aner Komponenten sinn installéiert a richteg konfiguréiert fir e Produktiounsfäeg Kafka Cluster op Kubernetes ze lafen.
  • Fir Installatioun supertubes CLI benotzt d'Instruktioune geliwwert hei.

EKS Cluster

Bereet en EKS-Cluster mat engagéierten Aarbechternoden vir c5.4x grouss a verschiddene Disponibilitéitszonen fir Pods mat Kafka Brokeren, wéi och engagéierten Noden fir de Lastgenerator an d'Iwwerwaachungsinfrastruktur.

banzai cluster create -f https://raw.githubusercontent.com/banzaicloud/kafka-operator/master/docs/benchmarks/infrastructure/cluster_eks_202001.json

Wann den EKS Stärekoup op a lafen ass, aktivéiert seng integréiert Iwwerwachung Service - si wäert Prometheus a Grafana an e Cluster ofsetzen.

Kafka System Komponente

Installéiert Kafka System Komponenten (Zookeeper, Kafka-Bedreiwer) an EKS mat Supertubes CLI:

supertubes install -a --no-democluster --kubeconfig <path-to-eks-cluster-kubeconfig-file>

Kafka Cluster

Par défaut benotzt EKS EBS Bänn vum Typ gp2, also musst Dir eng separat Späicherklass erstellen op Basis vu Bänn io1 fir Kafka Cluster:

kubectl create -f - <<EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: fast-ssd
provisioner: kubernetes.io/aws-ebs
parameters:
  type: io1
  iopsPerGB: "50"
  fsType: ext4
volumeBindingMode: WaitForFirstConsumer
EOF

Setzt de Parameter fir Broker min.insync.replicas=3 an deploy Broker Pods op Noden an dräi verschidden Disponibilitéitszonen:

supertubes cluster create -n kafka --kubeconfig <path-to-eks-cluster-kubeconfig-file> -f https://raw.githubusercontent.com/banzaicloud/kafka-operator/master/docs/benchmarks/infrastructure/kafka_202001_3brokers.yaml --wait --timeout 600

Sujeten

Mir lafen dräi Laascht Generator Instanzen parallel. Jidderee vun hinnen schreift op säin eegent Thema, dat ass, mir brauchen am Ganzen dräi Themen:

supertubes cluster topic create -n kafka --kubeconfig <path-to-eks-cluster-kubeconfig-file> -f -<<EOF
apiVersion: kafka.banzaicloud.io/v1alpha1
kind: KafkaTopic
metadata:
  name: perftest1
spec:
  name: perftest1
  partitions: 12
  replicationFactor: 3
  retention.ms: '28800000'
  cleanup.policy: delete
EOF

supertubes cluster topic create -n kafka --kubeconfig <path-to-eks-cluster-kubeconfig-file> -f -<<EOF
apiVersion: kafka.banzaicloud.io/v1alpha1
kind: KafkaTopic
metadata:
    name: perftest2
spec:
  name: perftest2
  partitions: 12
  replicationFactor: 3
  retention.ms: '28800000'
  cleanup.policy: delete
EOF

supertubes cluster topic create -n kafka --kubeconfig <path-to-eks-cluster-kubeconfig-file> -f -<<EOF
apiVersion: kafka.banzaicloud.io/v1alpha1
kind: KafkaTopic
metadata:
  name: perftest3
spec:
  name: perftest3
  partitions: 12
  replicationFactor: 3
  retention.ms: '28800000'
  cleanup.policy: delete
EOF

Fir all Thema ass de Replikatiounsfaktor 3 - de Minimum recommandéiert Wäert fir héich verfügbare Produktiounssystemer.

Lueden Generatioun Tool

Mir hunn dräi Exemplare vum Lastgenerator gestart (jidderee schreift an engem separaten Thema). Fir Belaaschtungsgenerator Pods, musst Dir Node Affinitéit setzen sou datt se nëmmen op den Noden geplangt sinn, déi fir si zougewisen sinn:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  labels:
    app: loadtest
  name: perf-load1
  namespace: kafka
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: loadtest
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: loadtest
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: nodepool.banzaicloud.io/name
                operator: In
                values:
                - loadgen
      containers:
      - args:
        - -brokers=kafka-0:29092,kafka-1:29092,kafka-2:29092,kafka-3:29092
        - -topic=perftest1
        - -required-acks=all
        - -message-size=512
        - -workers=20
        image: banzaicloud/perfload:0.1.0-blog
        imagePullPolicy: Always
        name: sangrenel
        resources:
          limits:
            cpu: 2
            memory: 1Gi
          requests:
            cpu: 2
            memory: 1Gi
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30

E puer Punkte fir ze notéieren:

• De Lastgenerator generéiert Messagen vun 512 Bytes an der Längt a publizéiert se op Kafka a Chargen vun 500 Messagen.
• Mat engem Argument -required-acks=all D'Publikatioun gëtt als erfollegräich ugesinn wann all synchroniséiert Repliken vun der Noriicht vu Kafka Broker kritt a bestätegt ginn. Dëst bedeit datt mir am Benchmark net nëmmen d'Geschwindegkeet vun de Leader gemooss hunn, déi Messagen kréien, awer och hir Follower, déi Messagen replizéieren. Den Zweck vun dësem Test ass net d'Konsumenten Liesgeschwindegkeet ze bewäerten (Konsumenten) kierzlech kritt Messagen déi nach ëmmer am OS Säit Cache bleiwen, a säi Verglach mat der Liesgeschwindegkeet vun de Messagen déi op der Disk gespäichert sinn.
• De Lastgenerator bedreift 20 Aarbechter parallel (-workers=20). All Aarbechter enthält 5 Produzenten déi d'Verbindung vum Aarbechter zum Kafka-Cluster deelen. Als Resultat huet all Generator 100 Produzenten, a si schécken all Messagen un de Kafka-Cluster.

Iwwerwaachung vun der Gesondheet vum Cluster

Wärend der Belaaschtung vum Kafka-Cluster hu mir och seng Gesondheet iwwerwaacht fir sécherzestellen datt et keng Pod-Restarts, keng ausser-synchroniséiert Repliken, a maximal Duerchsetze mat minimale Schwankungen:

• De Lastgenerator schreift Standardstatistiken iwwer d'Zuel vun de verëffentlechte Messagen an d'Feelerquote. De Fehlerquote soll d'selwecht bleiwen 0,00%.
• Cruise Kontrolléiere, ofgesat vum Kafka-Bedreiwer, bitt en Dashboard, wou mir och den Zoustand vum Cluster iwwerwaache kënnen. Fir dëse Panel ze gesinn, maacht:

  supertubes cluster cruisecontrol show -n kafka --kubeconfig <path-to-eks-cluster-kubeconfig-file>

• ISR Niveau (Zuel vun "in-synchroniséiert" Repliken) schrumpfen an Expansioun sinn gläich wéi 0.

Miessresultater

3 Courtiere, Message Gréisst - 512 Bytes

Mat Partitionen gläichméisseg iwwer dräi Broker verdeelt, konnte mir Leeschtung erreechen ~500 Mb/s (ongeféier 990 Tausend Messagen pro Sekonn):

De Gedächtnisverbrauch vun der virtueller JVM Maschinn ass net méi wéi 2 GB:

Disk Duerchgang erreecht de maximalen I / O Node Duerchgang op all dräi Instanzen op deenen d'Broker lafen:

Vun den Donnéeën iwwer d'Erënnerungsverbrauch duerch Noden, folgt et datt de Systempuffer an de Caching ~10-15 GB geholl hunn:

3 Courtiere, Message Gréisst - 100 Bytes

Wéi d'Messagegréisst erofgeet, fällt den Duerchgang ëm ongeféier 15-20%: d'Zäit déi all Message veraarbecht gëtt beaflosst se. Zousätzlech ass d'Prozessorbelaaschtung bal verduebelt.

Zënter Brokernoden nach ëmmer onbenotzt Kären hunn, kann d'Performance verbessert ginn andeems d'Kafka Konfiguratioun geännert gëtt. Dëst ass keng einfach Aufgab, also fir den Duerchgang ze erhéijen ass et besser mat méi grousse Messagen ze schaffen.

4 Courtiere, Message Gréisst - 512 Bytes

Dir kënnt d'Performance vun engem Kafka-Cluster ganz einfach erhéijen andeems Dir nei Brokeren bäidréit an e Gläichgewiicht vun de Partitionen behalen (dëst garantéiert datt d'Laascht gläichméisseg tëscht Broker verdeelt gëtt). An eisem Fall, nodeems Dir e Broker bäigefüügt huet, ass de Clusterduerchgang eropgaang ~580 Mb/s (~1,1 Millioune Messagen pro Sekonn). De Wuesstum huet sech manner wéi erwaart: dëst ass haaptsächlech duerch d'Ongläichgewiicht vun de Partitionen erkläert (net all Broker schaffen um Héichpunkt vun hire Fäegkeeten).

Erënnerungsverbrauch vun der JVM Maschinn blouf ënner 2 GB:

D'Aarbecht vun de Broker mat Drive gouf vum Ongläichgewiicht vun de Partitionen beaflosst:

Conclusiounen

Déi iterativ Approche, déi uewe presentéiert gëtt, kann erweidert ginn fir méi komplex Szenarie ze decken, déi Honnerte vu Konsumenten involvéiert, Repartitionéierung, Rollupdates, Pod Neistarten, etc. All dëst erlaabt eis d'Limite vun de Kapka-Cluster-Kapazitéiten a verschiddene Konditiounen ze bewäerten, Flaschenhalsen a senger Operatioun z'identifizéieren a Weeër ze fannen fir se ze bekämpfen.

Mir hunn Supertubes entworf fir séier an einfach e Cluster z'installéieren, et ze konfiguréieren, Brokeren an Themen ze addéieren / ewechzehuelen, op Alarmer z'äntwerten, a sécherzestellen datt Kafka allgemeng richteg op Kubernetes funktionnéiert. Eist Zil ass et Iech ze hëllefen Iech op d'Haaptaufgab ze konzentréieren ("Kafka Messagen "generéieren" an "konsuméieren") an all déi haart Aarbecht un Supertubes an dem Kafka Bedreiwer loossen.

Wann Dir un Banzai Cloud Technologien an Open Source Projeten interesséiert sidd, abonnéiert Iech op d'Firma op GitHub, LinkedIn oder Twitter.

PS vum Iwwersetzer

Liest och op eisem Blog:

• «Eng Geschicht mam Redis Bedreiwer an K8s an eng Mini-Iwwerpréiwung vun Utilities fir Daten aus dëser Datebank ze analyséieren";
• «Nahtlos Migratioun vu RabbitMQ op Kubernetes";
• «zetcd vum CoreOS: Ersetzen ZooKeeper mat ... etc".

Source: will.com