Poznámka:
Přístup k této stránce vyžaduje autorizaci. Můžete se zkusit přihlásit nebo změnit adresáře.
Přístup k této stránce vyžaduje autorizaci. Můžete zkusit změnit adresáře.
V tomto článku nasadíte operátora clusteru Strimzi a vysoce dostupný cluster Kafka ve službě Azure Kubernetes Service (AKS).
Poznámka:
Pokud jste pro toto nasazení nevytvořili požadovanou infrastrukturu, postupujte podle kroků v části Příprava infrastruktury pro nasazení Kafka ve službě Azure Kubernetes Service (AKS) a pak se můžete vrátit k tomuto článku.
Nasazení Strimzi
Operátor clusteru Strimzi je nasazený ve vlastním oboru názvů a je nakonfigurovaný tak, aby sledoval strimzi-operator obor názvů, kafkave kterém jsou nasazené komponenty clusteru Kafka. Pro zajištění vysoké dostupnosti operátor používá:
- Více replik s výběrem vedoucího: Jedna replika slouží jako aktivní vedoucí, který spravuje nasazené prostředky, zatímco ostatní repliky zůstávají v pohotovostním režimu. V případě selhání vedoucího převezme pohotovostní replika.
- Zónová distribuce: Tři repliky (jedna na zónu dostupnosti) zajišťují odolnost proti výpadkům zón. Pravidla proti spřažení podů brání naplánování více replik ve stejné zóně.
- Pod Disruption Budget: Automaticky vytvořený nasazením operátora, aby bylo zajištěno, že během dobrovolného přerušení zůstane k dispozici alespoň jedna replika.
Tato architektura zajišťuje, že operátor clusteru Strimzi zůstává vysoce dostupný i během údržby infrastruktury nebo částečného výpadku.
Instalace operátoru clusteru Strimzi pomocí Nástroje Helm
Pomocí příkazu vytvořte obory názvů pro operátora clusteru Strimzi a cluster
kubectl create namespaceKafka.kubectl create namespace strimzi-operator kubectl create namespace kafkaPomocí následujícího skriptu vytvořte
values.yamlsoubor, který poskytne konkrétní konfigurace chartu Helm:cat <<EOF > values.yaml replicas: 3 watchNamespaces: - kafka leaderElection: enabled: true podDisruptionBudget: enabled: true affinity: podAntiAffinity: requiredDuringSchedulingIgnoredDuringExecution: - labelSelector: matchExpressions: - key: name operator: In values: - strimzi-cluster-operator topologyKey: topology.kubernetes.io/zone EOFPomocí příkazu nainstalujte operátor clusteru
helm installStrimzi.helm install strimzi-cluster-operator oci://quay.io/strimzi-helm/strimzi-kafka-operator \ --namespace strimzi-operator \ --values values.yamlOvěřte pomocí příkazu
kubectl get, že se operátor clusteru Strimzi úspěšně nasadil a všechny pody jsou ve spuštěném stavu.kubectl get pods -n strimzi-operatorVaše výstupy by měly vypadat podobně jako následující příklad:
NAME READY STATUS RESTARTS AGE strimzi-cluster-operator-6f7588bb79-bvfdp 1/1 Running 0 1d22h strimzi-cluster-operator-6f7588bb79-lfcp6 1/1 Running 0 1d22h strimzi-cluster-operator-6f7588bb79-qdlm8 1/1 Running 0 1d22h
Instalace nástroje Strimzi Drain Cleaner pomocí Nástroje Helm
Strimzi Drain Cleaner zajišťuje hladký odvodný proces uzlu Kubernetes tím, že zachytí požadavky na vyprazdňování podů brokerů, což brání tomu, aby se repliky particí Kafka staly nedostatečně replikovanými a udržuje zdraví a spolehlivost clusteru.
Pro zajištění vysoké dostupnosti nasaďte nástroj Drain Cleaner s více replikami napříč zónami dostupnosti a nakonfigurujte jej s použitím rozpočtů na přerušení podů, aby zůstal funkční během výpadků zón nebo při upgradech clusteru.
Helm chart je k dispozici pro instalaci čističe odtoků Strimzi.
Pomocí příkazu
kubectl create namespacevytvořte obor názvů pro čistič odpadů.kubectl create namespace strimzi-drain-cleanerVytvořte soubor, který
values.yamlpřepíše konkrétní konfigurace chartu Helm pomocí následujícího skriptu:cat <<EOF > values.yaml replicaCount: 3 namespace: create: false podDisruptionBudget: create: true affinity: podAntiAffinity: requiredDuringSchedulingIgnoredDuringExecution: - labelSelector: matchExpressions: - key: app operator: In values: - strimzi-drain-cleaner topologyKey: topology.kubernetes.io/zone EOFNainstalujte nástroj Strimzi Drain Cleaner pomocí
helm installpříkazu.helm install strimzi-drain-cleaner oci://quay.io/strimzi-helm/strimzi-drain-cleaner \ --namespace strimzi-drain-cleaner \ --values values.yamlPomocí příkazu
kubectl getověřte, zda byl nástroj Strimzi Drain Cleaner úspěšně nasazen a že všechny pody jsou ve spuštěném stavu.kubectl get pods -n strimzi-drain-cleanerVaše výstupy by měly vypadat podobně jako následující příklad:
NAME READY STATUS RESTARTS AGE strimzi-drain-cleaner-6d694bd55b-dshkp 1/1 Running 0 1d22h strimzi-drain-cleaner-6d694bd55b-l8cbf 1/1 Running 0 1d22h strimzi-drain-cleaner-6d694bd55b-wj6xx 1/1 Running 0 1d22h
Architektura clusteru Kafka a důležité informace
Operátor clusteru Strimzi umožňuje deklarativní nasazení Kafka v AKS pomocí vlastních definic prostředků. Počínaje verzí Strimzi 0.46 používají clustery Kafka místo ZooKeeperu KRaft v rámci Kafka.
Strimzi používá KafkaNodePool vlastní zdroj, kde je každé skupině přiřazena specifická role (zprostředkovatel, kontroler nebo obojí):
- Zprostředkovatelé Kafka zpracovávají a ukládají zprávy.
- Kontrolery Kafka spravují metadata Kafka pomocí protokolu pro konsensus Raft.
Pro zajištění vysoké dostupnosti je cílová architektura definována takto:
- Oddělené části pro zprostředkovatele a kontrolery, přičemž každý má tři repliky.
- Topologická omezení rozprostření, která distribuují pody mezi zóny dostupnosti a uzly.
- Pravidla spřažení uzlů, která optimalizují využití prostředků v konkrétních fondech uzlů.
- Trvalé svazky z ovladače CSI disku Azure se samostatnými svazky pro zprávy a metadata pro zprostředkovatele.
Tato architektura zlepšuje škálovatelnost a odolnost proti chybám a zároveň umožňuje nezávislé škálování zprostředkovatelů a kontrolerů tak, aby splňovaly požadavky na úlohy.
Konfigurace prostředí JVM pro produkční clustery Kafka
Ladění virtuálního počítače Java (JVM) je důležité pro optimální výkon zprostředkovatele a kontroleru Kafka, zejména v produkčních prostředích. Správně nakonfigurovaná nastavení prostředí JVM pomáhají maximalizovat propustnost, minimalizovat latenci a zajistit stabilitu při vysokém zatížení každého zprostředkovatele.
LinkedIn, tvůrci Kafky, sdíleli své doporučené argumenty pro spuštění Kafky v Javě pro jeden z jejich nejvytíženějších clusterů: Apache Kafka Java Configuration. Tato příručka používá tuto konfiguraci jako směrný plán pro zprostředkovatele Kafka. Můžete provádět změny, které splňují vaše konkrétní požadavky na úlohy.
jvmOptions:
# Sets initial and maximum heap size to 6GB - critical for memory-intensive Kafka operations
# Equal sizing prevents resizing pauses
"-Xms": "6g"
"-Xmx": "6g"
"-XX":
# Initial metaspace size (class metadata storage area) at 96MB
"MetaspaceSize": "96m"
# Enables the Garbage-First (G1) garbage collector, optimized for better predictability and lower pause times
"UseG1GC": "true"
# Targets maximum GC pause time of 20ms - keeps latency predictable
"MaxGCPauseMillis": "20"
# Starts concurrent GC cycle when heap is 35% full - balances CPU overhead and frequency
"InitiatingHeapOccupancyPercent": "35"
# Sets G1 heap region size to 16MB - affects collection efficiency and pause times
"G1HeapRegionSize": "16M"
# Keeps at least 50% free space after metaspace GC - prevents frequent resizing
"MinMetaspaceFreeRatio": "50"
# Limits expansion to allow up to 80% free space in metaspace after GC
"MaxMetaspaceFreeRatio": "80"
# Makes explicit System.gc() calls run concurrently instead of stopping all threads
"ExplicitGCInvokesConcurrent": "true"
Nasazení fondů uzlů Kafka
V této části vytvoříte dva fondy uzlů Kafka: jeden pro zprostředkovatele a jeden pro kontrolery.
Pomocí příkazu
kubectl applyaplikujte manifest YAML k vytvoření dvou fondů uzlů pro Kafka.kubectl apply -n kafka -f - <<EOF --- apiVersion: kafka.strimzi.io/v1beta2 kind: KafkaNodePool metadata: name: controller labels: strimzi.io/cluster: kafka-aks-cluster spec: replicas: 3 roles: - controller resources: requests: memory: 4Gi limits: memory: 6Gi template: pod: metadata: labels: kafkaRole: controller affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: app operator: In values: - kafka podAffinity: preferredDuringSchedulingIgnoredDuringExecution: - weight: 100 podAffinityTerm: labelSelector: matchLabels: kafkaRole: broker topologyKey: kubernetes.io/hostname topologySpreadConstraints: - labelSelector: matchLabels: kafkaRole: controller maxSkew: 1 topologyKey: topology.kubernetes.io/zone whenUnsatisfiable: ScheduleAnyway - labelSelector: matchLabels: kafkaRole: controller maxSkew: 1 topologyKey: kubernetes.io/hostname whenUnsatisfiable: ScheduleAnyway storage: type: jbod volumes: - id: 0 type: persistent-claim size: 25Gi kraftMetadata: shared deleteClaim: false class: kafka-premium-ssd-v2 jvmOptions: "-Xms": "3g" "-Xmx": "3g" "-XX": "MetaspaceSize": "96m" "UseG1GC": "true" "MaxGCPauseMillis": "20" "InitiatingHeapOccupancyPercent": "35" "G1HeapRegionSize": "16M" "MinMetaspaceFreeRatio": "50" "MaxMetaspaceFreeRatio": "80" "ExplicitGCInvokesConcurrent": "true" --- apiVersion: kafka.strimzi.io/v1beta2 kind: KafkaNodePool metadata: name: broker labels: strimzi.io/cluster: kafka-aks-cluster spec: replicas: 3 roles: - broker resources: requests: memory: 8Gi limits: memory: 10Gi template: pod: metadata: labels: kafkaRole: broker affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: app operator: In values: - kafka podAffinity: preferredDuringSchedulingIgnoredDuringExecution: - weight: 100 podAffinityTerm: labelSelector: matchLabels: kafkaRole: controller topologyKey: kubernetes.io/hostname topologySpreadConstraints: - labelSelector: matchLabels: kafkaRole: broker maxSkew: 1 topologyKey: topology.kubernetes.io/zone whenUnsatisfiable: ScheduleAnyway - labelSelector: matchLabels: kafkaRole: broker maxSkew: 1 topologyKey: kubernetes.io/hostname whenUnsatisfiable: ScheduleAnyway storage: type: jbod volumes: - id: 0 type: persistent-claim size: 50Gi deleteClaim: false class: kafka-premium-ssd-v2 - id: 1 type: persistent-claim size: 25Gi kraftMetadata: shared deleteClaim: false class: kafka-premium-ssd-v2 jvmOptions: "-Xms": "6g" "-Xmx": "6g" "-XX": "MetaspaceSize": "96m" "UseG1GC": "true" "MaxGCPauseMillis": "20" "InitiatingHeapOccupancyPercent": "35" "G1HeapRegionSize": "16M" "MinMetaspaceFreeRatio": "50" "MaxMetaspaceFreeRatio": "80" "ExplicitGCInvokesConcurrent": "true" EOF
Po vytvoření fondů uzlů Kafka je dalším krokem definování vlastního prostředku clusteru Kafka, který tyto fondy sváže do funkčního ekosystému Kafka. Tato architektura se řídí vzorem oddělení zájmů, kdy fondy uzlů Kafka spravují aspekty infrastruktury, zatímco zdroj clusteru Kafka zpracovává konfigurace na úrovni aplikace.
Nasazení clusteru Kafka
Před vytvořením clusteru Kafka pomocí příkazu vytvořte objekt ConfigMap, který obsahuje konfiguraci
kubectl applyexportéru JMX Prometheus. Tato mapa configmap definuje, jak se interní metriky JMX Kafka transformují a zveřejňují ve formátu Prometheus a umožňují komplexní monitorování ekosystému Kafka. Vzory definované v této konfiguraci mapují cesty metrik JMX na správně naformátované metriky Prometheus s příslušnými typy a štítky.kubectl apply -n kafka -f - <<'EOF' --- apiVersion: v1 kind: ConfigMap metadata: name: kafka-metrics labels: app: strimzi data: kafka-metrics-config.yaml: | # See https://github.com/prometheus/jmx_exporter for more info about JMX Prometheus Exporter metrics lowercaseOutputName: true rules: # Special cases and very specific rules - pattern: kafka.server<type=(.+), name=(.+), clientId=(.+), topic=(.+), partition=(.*)><>Value name: kafka_server_$1_$2 type: GAUGE labels: clientId: "$3" topic: "$4" partition: "$5" - pattern: kafka.server<type=(.+), name=(.+), clientId=(.+), brokerHost=(.+), brokerPort=(.+)><>Value name: kafka_server_$1_$2 type: GAUGE labels: clientId: "$3" broker: "$4:$5" - pattern: kafka.server<type=(.+), cipher=(.+), protocol=(.+), listener=(.+), networkProcessor=(.+)><>connections name: kafka_server_$1_connections_tls_info type: GAUGE labels: cipher: "$2" protocol: "$3" listener: "$4" networkProcessor: "$5" - pattern: kafka.server<type=(.+), clientSoftwareName=(.+), clientSoftwareVersion=(.+), listener=(.+), networkProcessor=(.+)><>connections name: kafka_server_$1_connections_software type: GAUGE labels: clientSoftwareName: "$2" clientSoftwareVersion: "$3" listener: "$4" networkProcessor: "$5" - pattern: "kafka.server<type=(.+), listener=(.+), networkProcessor=(.+)><>(.+-total):" name: kafka_server_$1_$4 type: COUNTER labels: listener: "$2" networkProcessor: "$3" - pattern: "kafka.server<type=(.+), listener=(.+), networkProcessor=(.+)><>(.+):" name: kafka_server_$1_$4 type: GAUGE labels: listener: "$2" networkProcessor: "$3" - pattern: kafka.server<type=(.+), listener=(.+), networkProcessor=(.+)><>(.+-total) name: kafka_server_$1_$4 type: COUNTER labels: listener: "$2" networkProcessor: "$3" - pattern: kafka.server<type=(.+), listener=(.+), networkProcessor=(.+)><>(.+) name: kafka_server_$1_$4 type: GAUGE labels: listener: "$2" networkProcessor: "$3" # Some percent metrics use MeanRate attribute # Ex) kafka.server<type=(KafkaRequestHandlerPool), name=(RequestHandlerAvgIdlePercent)><>MeanRate - pattern: kafka.(\w+)<type=(.+), name=(.+)Percent\w*><>MeanRate name: kafka_$1_$2_$3_percent type: GAUGE # Generic gauges for percents - pattern: kafka.(\w+)<type=(.+), name=(.+)Percent\w*><>Value name: kafka_$1_$2_$3_percent type: GAUGE - pattern: kafka.(\w+)<type=(.+), name=(.+)Percent\w*, (.+)=(.+)><>Value name: kafka_$1_$2_$3_percent type: GAUGE labels: "$4": "$5" # Generic per-second counters with 0-2 key/value pairs - pattern: kafka.(\w+)<type=(.+), name=(.+)PerSec\w*, (.+)=(.+), (.+)=(.+)><>Count name: kafka_$1_$2_$3_total type: COUNTER labels: "$4": "$5" "$6": "$7" - pattern: kafka.(\w+)<type=(.+), name=(.+)PerSec\w*, (.+)=(.+)><>Count name: kafka_$1_$2_$3_total type: COUNTER labels: "$4": "$5" - pattern: kafka.(\w+)<type=(.+), name=(.+)PerSec\w*><>Count name: kafka_$1_$2_$3_total type: COUNTER # Generic gauges with 0-2 key/value pairs - pattern: kafka.(\w+)<type=(.+), name=(.+), (.+)=(.+), (.+)=(.+)><>Value name: kafka_$1_$2_$3 type: GAUGE labels: "$4": "$5" "$6": "$7" - pattern: kafka.(\w+)<type=(.+), name=(.+), (.+)=(.+)><>Value name: kafka_$1_$2_$3 type: GAUGE labels: "$4": "$5" - pattern: kafka.(\w+)<type=(.+), name=(.+)><>Value name: kafka_$1_$2_$3 type: GAUGE # Emulate Prometheus 'Summary' metrics for the exported 'Histogram's. # Note that these are missing the '_sum' metric! - pattern: kafka.(\w+)<type=(.+), name=(.+), (.+)=(.+), (.+)=(.+)><>Count name: kafka_$1_$2_$3_count type: COUNTER labels: "$4": "$5" "$6": "$7" - pattern: kafka.(\w+)<type=(.+), name=(.+), (.+)=(.*), (.+)=(.+)><>(\d+)thPercentile name: kafka_$1_$2_$3 type: GAUGE labels: "$4": "$5" "$6": "$7" quantile: "0.$8" - pattern: kafka.(\w+)<type=(.+), name=(.+), (.+)=(.+)><>Count name: kafka_$1_$2_$3_count type: COUNTER labels: "$4": "$5" - pattern: kafka.(\w+)<type=(.+), name=(.+), (.+)=(.*)><>(\d+)thPercentile name: kafka_$1_$2_$3 type: GAUGE labels: "$4": "$5" quantile: "0.$6" - pattern: kafka.(\w+)<type=(.+), name=(.+)><>Count name: kafka_$1_$2_$3_count type: COUNTER - pattern: kafka.(\w+)<type=(.+), name=(.+)><>(\d+)thPercentile name: kafka_$1_$2_$3 type: GAUGE labels: quantile: "0.$4" # KRaft overall related metrics # distinguish between always increasing COUNTER (total and max) and variable GAUGE (all others) metrics - pattern: "kafka.server<type=raft-metrics><>(.+-total|.+-max):" name: kafka_server_raftmetrics_$1 type: COUNTER - pattern: "kafka.server<type=raft-metrics><>(current-state): (.+)" name: kafka_server_raftmetrics_$1 value: 1 type: UNTYPED labels: $1: "$2" - pattern: "kafka.server<type=raft-metrics><>(.+):" name: kafka_server_raftmetrics_$1 type: GAUGE # KRaft "low level" channels related metrics # distinguish between always increasing COUNTER (total and max) and variable GAUGE (all others) metrics - pattern: "kafka.server<type=raft-channel-metrics><>(.+-total|.+-max):" name: kafka_server_raftchannelmetrics_$1 type: COUNTER - pattern: "kafka.server<type=raft-channel-metrics><>(.+):" name: kafka_server_raftchannelmetrics_$1 type: GAUGE # Broker metrics related to fetching metadata topic records in KRaft mode - pattern: "kafka.server<type=broker-metadata-metrics><>(.+):" name: kafka_server_brokermetadatametrics_$1 type: GAUGE --- apiVersion: v1 kind: ConfigMap metadata: name: cruise-control-metrics labels: app: strimzi data: metrics-config.yaml: | # See https://github.com/prometheus/jmx_exporter for more info about JMX Prometheus Exporter metrics lowercaseOutputName: true rules: - pattern: kafka.cruisecontrol<name=(.+)><>(\w+) name: kafka_cruisecontrol_$1_$2 type: GAUGE EOFNasaďte prostředek clusteru Kafka pomocí příkazu
kubectl apply, který připojí dříve vytvořené fondy uzlů do kompletního ekosystému Kafka. Tento vlastní zdroj konfiguruje následující důležité komponenty:- Konfigurace jádra Kafka: Definuje faktory replikace, nastavení naslouchacího procesu a další parametry specifické pro Kafka.
- Cruise Control: Poskytuje automatizované funkce vyrovnávání a monitorování clusterů.
- Operátor entity: Nasadí Topic a User Operátory, které spravují témata a uživatele Kafka deklarativně pomocí prostředků Kubernetes.
- Metriky JMX: Konfiguruje vystavení metrik pomocí dříve definovaných objektů ConfigMap.
kubectl apply -n kafka -f - <<EOF --- apiVersion: kafka.strimzi.io/v1beta2 kind: Kafka metadata: name: kafka-aks-cluster annotations: strimzi.io/node-pools: enabled strimzi.io/kraft: enabled spec: kafka: version: 3.9.0 metadataVersion: 3.9-IV0 rack: topologyKey: topology.kubernetes.io/zone template: podDisruptionBudget: maxUnavailable: 2 listeners: - name: internal port: 9092 type: internal tls: true config: offsets.topic.replication.factor: 3 transaction.state.log.replication.factor: 3 transaction.state.log.min.isr: 2 default.replication.factor: 3 min.insync.replicas: 2 log.segment.bytes: 1073741824 log.retention.hours: 168 log.retention.check.interval.ms: 300000 metricsConfig: type: jmxPrometheusExporter valueFrom: configMapKeyRef: name: kafka-metrics key: kafka-metrics-config.yaml cruiseControl: metricsConfig: type: jmxPrometheusExporter valueFrom: configMapKeyRef: name: cruise-control-metrics key: metrics-config.yaml entityOperator: topicOperator: {} userOperator: {} EOFPo nasazení ověřte nasazení Kafka tak, že pomocí příkazu zkontrolujete, jestli jsou vytvořené všechny clustery KafkaNodePools, prostředky clusteru Kafka a jejich odpovídající pody a ve spuštěném stavu
kubectl get.kubectl get pods,kafkanodepool,kafka -n kafkaVaše výstupy by měly vypadat podobně jako následující příklad:
NAME READY STATUS RESTARTS AGE pod/kafka-aks-cluster-broker-0 1/1 Running 0 1d22h pod/kafka-aks-cluster-broker-1 1/1 Running 0 1d22h pod/kafka-aks-cluster-broker-2 1/1 Running 0 1d22h pod/kafka-aks-cluster-controller-3 1/1 Running 0 1d22h pod/kafka-aks-cluster-controller-4 1/1 Running 0 1d22h pod/kafka-aks-cluster-controller-5 1/1 Running 0 1d22h pod/kafka-aks-cluster-cruise-control-844b69848-87rf6 1/1 Running 0 1d22h pod/kafka-aks-cluster-entity-operator-6f949f6774-t8wql 2/2 Running 0 1d22h NAME DESIRED REPLICAS ROLES NODEIDS kafkanodepool.kafka.strimzi.io/broker 3 ["broker"] [0,1,2] kafkanodepool.kafka.strimzi.io/controller 3 ["controller"] [3,4,5] NAME DESIRED KAFKA REPLICAS DESIRED ZK REPLICAS READY METADATA STATE WARNINGS kafka.kafka.strimzi.io/kafka-aks-cluster
Vytvoření uživatele a tématu Kafka
Operátor entity Strimzi nasazený s vlastním prostředkem clusteru Kafka, překládá vlastní prostředky Kubernetes (KafkaTopic a KafkaUser) do skutečných prostředků Kafka. To umožňuje pracovní postupy GitOps a konzistentní správu konfigurace.
Poznámka:
Vytváření témat Kafka a uživatelů deklarativně pomocí operátoru entity je volitelné. Můžete je také vytvořit pomocí tradičního příkazového řádku Kafka (CLI) nebo rozhraní API. Deklarativní přístup ale nabízí výhody, jako je správa verzí, záznamy auditu a konzistentní správa napříč prostředími.
Zadejte příkaz
kubectl applyk vytvoření tématu Kafka pomocí operátoru tématu.kubectl apply -n kafka -f - << EOF apiVersion: kafka.strimzi.io/v1beta2 kind: KafkaTopic metadata: name: test-topic labels: strimzi.io/cluster: kafka-aks-cluster spec: replicas: 3 partitions: 4 config: retention.ms: 7200000 segment.bytes: 1073741824 EOFOvěřte, že Kafka téma bylo úspěšně vytvořeno pomocí příkazu
kubectl get.kubectl get kafkatopic -n kafkaVaše výstupy by měly vypadat podobně jako následující příklad:
NAME CLUSTER PARTITIONS REPLICATION FACTOR READY test-topic kafka-aks-cluster 4 3 TrueDalší informace najdete v tématu Použití operátora tématu ke správě témat Kafka.
Pomocí příkazu
kubectl applyvytvořte uživatele Kafka pomocí uživatelského operátoru.kubectl apply -f - <<EOF apiVersion: kafka.strimzi.io/v1beta2 kind: KafkaUser metadata: name: test-user labels: strimzi.io/cluster: kafka-aks-cluster spec: authentication: type: tls authorization: type: simple acls: - resource: type: topic name: test-topic patternType: literal operations: - Describe - Read host: "*" - resource: type: group name: test-group patternType: literal operations: - Read host: "*" - resource: type: topic name: test-topic patternType: literal operations: - Create - Describe - Write host: "*" EOFDalší informace najdete v tématu Použití operátora uživatele ke správě uživatelů Kafka.
Další krok
Přispěvatelé
Microsoft udržuje tento článek. Následující přispěvatelé ho původně napsali:
- Sergio Navar | Vedoucí zákaznický inženýr
- Erin Schaffer | Content Developer 2