Strimzi- en Kafka-onderdelen configureren en implementeren in Azure Kubernetes Service (AKS)

In dit artikel implementeert u de Strimzi-clusteroperator en een maximaal beschikbare Kafka-cluster in Azure Kubernetes Service (AKS).

Opmerking

Als u de vereiste infrastructuur voor deze implementatie nog niet hebt gemaakt, volgt u de stappen in De infrastructuur voorbereiden voor het implementeren van Kafka in Azure Kubernetes Service (AKS) om deze in te stellen. Vervolgens kunt u teruggaan naar dit artikel.

Strimzi-implementatie

De Strimzi-clusteroperator wordt geïmplementeerd in een eigen naamruimte strimzi-operatoren is geconfigureerd om de kafka naamruimte te bekijken waar de Kafka-clusteronderdelen worden geïmplementeerd. Voor hoge beschikbaarheid gebruikt de operator:

Meerdere replica's met leiderverkiezing: Eén replica fungeert als de actieve leider die ingezette middelen beheert, terwijl anderen in de wacht blijven. Als de leider uitvalt, neemt een stand-by-replica het over.
Zonegebonden verdeling: drie replica's (één per beschikbaarheidszone) bieden tolerantie tegen zonestoringen. Antiaffiniteitsregels voor pods voorkomen dat meerdere replica's in dezelfde zone worden gepland.
Budget voor podonderbreking: wordt automatisch gemaakt door de operatorimplementatie om ervoor te zorgen dat er ten minste één replica beschikbaar blijft tijdens vrijwillige onderbrekingen.

Deze architectuur zorgt ervoor dat de Strimzi-clusteroperator maximaal beschikbaar blijft, zelfs tijdens onderhoud van de infrastructuur of gedeeltelijke storingen.

Strimzi-clusteroperator installeren met Helm

Maak de naamruimten voor de Strimzi-clusteroperator en het Kafka-cluster met behulp van de kubectl create namespace opdracht.
```
kubectl create namespace strimzi-operator  
kubectl create namespace kafka  
```

Maak met het volgende script een values.yaml bestand om specifieke configuraties voor de Helm-grafiek te bieden:

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  
EOF

Installeer de Strimzi-clusteroperator met behulp van de helm install opdracht.

helm install strimzi-cluster-operator oci://quay.io/strimzi-helm/strimzi-kafka-operator \
--namespace strimzi-operator \
--values values.yaml

Controleer of de Strimzi-clusteroperator is geïmplementeerd en of alle pods een actieve status hebben met behulp van de kubectl get opdracht.

kubectl get pods -n strimzi-operator

De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:

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

Strimzi Drain Cleaner installeren met Helm

Strimzi Drain Cleaner zorgt ervoor dat Kubernetes-knooppunten soepel leeggemaakt worden door afvoeraanvragen voor brokerpods te onderscheppen, waardoor wordt voorkomen dat partitiereplica's van Kafka onder-gerepliceerd raken en de gezondheid en betrouwbaarheid van de cluster behouden blijven.

Voor hoge beschikbaarheid implementeert u Drain Cleaner met meerdere replica's in de beschikbaarheidszones en configureert u deze met pod-storingsbudgetten om ervoor te zorgen dat deze functioneel blijft tijdens de zonestoringen en de clusterupgrades.

Er is een Helm-grafiek beschikbaar voor de installatie van Strimzi Drain Cleaner:

Maak de naamruimte voor Drain Cleaner met behulp van de kubectl create namespace opdracht.
```
kubectl create namespace strimzi-drain-cleaner  
```

Maak een values.yaml bestand om specifieke configuraties voor de Helm-grafiek te overschrijven met behulp van het volgende script:

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  
EOF

Installeer de Strimzi Drain Cleaner met behulp van de helm install opdracht.

helm install strimzi-drain-cleaner oci://quay.io/strimzi-helm/strimzi-drain-cleaner \
--namespace strimzi-drain-cleaner \
--values values.yaml

Controleer of de Strimzi Drain Cleaner is geïmplementeerd en of alle pods een actieve status hebben met behulp van de kubectl get opdracht.

kubectl get pods -n strimzi-drain-cleaner

De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:

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

Kafka-clusterarchitectuur en overwegingen

De Strimzi-clusteroperator maakt declaratieve Kafka-implementatie in AKS mogelijk met behulp van aangepaste resourcedefinities. Vanaf Strimzi 0.46 gebruiken Kafka-clusters KRaft in Kafka in plaats van ZooKeeper.

Strimzi maakt gebruik van de KafkaNodePool aangepaste resource, waarbij aan elke pool een specifieke rol wordt toegewezen (broker, controller of beide):

Kafka-brokers verwerken de verwerking en opslag van berichten.
Kafka-controllers beheren Kafka-metagegevens met behulp van het raft-consensusprotocol.

Voor hoge beschikbaarheid wordt de doelarchitectuur gedefinieerd door:

Gescheiden systemen KafkaNodePools voor brokers en controllers, elk met drie replica's.
Topologie spreidingsbeperkingen die pods verdelen over beschikbaarheidszones en knooppunten.
Knooppuntaffiniteitsregels die het resourcegebruik optimaliseren met specifieke knooppuntgroepen.
Permanente volumes van azure Disk CSI-stuurprogramma met afzonderlijke volumes voor brokerberichten en metagegevens.

Deze architectuur verbetert de schaalbaarheid en fouttolerantie en maakt het mogelijk dat brokers en controllers onafhankelijk kunnen worden geschaald om te voldoen aan de workloadvereisten.

JVM-configuratie voor Kafka-productieclusters

Het afstemmen van de Java Virtual Machine (JVM) is essentieel voor optimale Kafka-broker- en controllerprestaties, met name in productieomgevingen. Goed geconfigureerde JVM-instellingen helpen de doorvoer te maximaliseren, latentie te minimaliseren en stabiliteit te garanderen onder zware belasting voor elke broker.

LinkedIn, de makers van Kafka, hebben hun aanbevolen argumenten gedeeld voor het uitvoeren van Kafka op Java voor een van hun drukste clusters: Apache Kafka Java-configuratie. In deze handleiding wordt deze configuratie gebruikt als basislijn voor de Kafka-brokers. U kunt wijzigingen aanbrengen om te voldoen aan uw specifieke workloadvereisten.

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"

Kafka-knooppuntgroepen implementeren

In deze sectie maakt u twee Kafka-knooppuntgroepen: één voor brokers en één voor controllers.

Pas het YAML-manifest toe om de twee Kafka-knooppuntgroepen te maken met behulp van de kubectl apply opdracht.

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

Nadat u de Kafka-knooppuntgroepen hebt gemaakt, is de volgende stap het definiëren van een aangepaste Kafka-clusterresource waarmee deze pools worden gekoppeld aan een functionerend Kafka-ecosysteem. Deze architectuur volgt een scheiding van problemenpatroon, waarbij Kafka-knooppuntgroepen de infrastructuuraspecten beheren terwijl de Kafka-clusterresource configuraties op toepassingsniveau afhandelt.

Het Kafka-cluster implementeren

Voordat u het Kafka-cluster maakt, maakt u een ConfigMap die de configuratie JMX Prometheus Exporter bevat met behulp van de kubectl apply opdracht. Deze ConfigMap definieert hoe de interne JMX-metrische gegevens van Kafka worden getransformeerd en weergegeven in Prometheus-indeling, waardoor uitgebreide bewaking van uw Kafka-ecosysteem mogelijk is. De in deze configuratie gedefinieerde patronen koppelen JMX-metrische paden aan correct geformatteerde Prometheus-metrieken met de juiste typen en labels.

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
EOF

Implementeer de Kafka-clusterresource, die de eerder gemaakte knooppuntgroepen verbindt in een volledig Kafka-ecosysteem met behulp van de kubectl apply opdracht. Met deze aangepaste resource worden de volgende essentiële onderdelen geconfigureerd:

Kafka-kernconfiguratie: definieert replicatiefactoren, listenerinstellingen en andere Kafka-specifieke parameters.
Cruise Control: biedt geautomatiseerde clusterverdelings- en bewakingsmogelijkheden.
Entiteitsoperator: implementeert de onderwerp- en gebruikersoperators die Kafka-onderwerpen en -gebruikers declaratief beheren via Kubernetes-resources.
Metrische gegevens van JMX: hiermee configureert u blootstelling aan metrische gegevens met behulp van de eerder gedefinieerde ConfigMaps.

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: {}
EOF

Nadat u de implementatie van Kafka hebt geïmplementeerd, controleert u of alle KafkaNodePools, Kafka-clusterbronnen en de bijbehorende pods zijn gemaakt en in een actieve status met behulp van de kubectl get opdracht.

kubectl get pods,kafkanodepool,kafka -n kafka

De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:

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

Een Kafka-gebruiker en -onderwerp maken

De Strimzi Entity Operator, geïmplementeerd met de aangepaste resource van het Kafka-cluster, vertaalt Kubernetes aangepaste resources (KafkaTopic en KafkaUser) naar werkelijke Kafka-resources. Dit maakt GitOps-werkstromen en consistent configuratiebeheer mogelijk.

Opmerking

Het maken van Kafka-onderwerpen en -gebruikers declaratief met behulp van de entiteitsoperator is optioneel. U kunt ze ook maken met traditionele Kafka CLI-hulpprogramma's of API's. De declaratieve benadering biedt echter voordelen zoals versiebeheer, audittrails en consistent beheer in omgevingen.

Maak een Kafka-onderwerp met de onderwerpoperator met behulp van de kubectl apply opdracht.

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  
EOF

Controleer of de Kafka Topic correct is aangemaakt met behulp van de kubectl get-opdracht.
```
kubectl get kafkatopic -n kafka  
```
De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:
```
NAME         CLUSTER             PARTITIONS   REPLICATION FACTOR   READY  
test-topic   kafka-aks-cluster   4            3                    True  
```
Zie voor meer informatie het gebruik van de onderwerpoperator voor het beheren van Kafka-onderwerpen.

Maak een Kafka-gebruiker met de gebruikersoperator met behulp van de kubectl apply opdracht.

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: "*"  
EOF

Zie het gebruik van de gebruikersoperator voor het beheren van Kafka-gebruikers voor meer informatie.

Volgende stap

Bewaking en netwerken configureren voor een Kafka-cluster op AKS met behulp van de Strimzi-operator

Bijdragers

Microsoft onderhoudt dit artikel. De volgende inzenders hebben het oorspronkelijk geschreven:

Sergio Navar | Senior klanteningenieur
Erin Schaffer | Inhoudsontwikkelaar 2

Feedback

Is deze pagina nuttig?

Laatst bijgewerkt om 2025-09-19

Strimzi- en Kafka-onderdelen configureren en implementeren in Azure Kubernetes Service (AKS)

Strimzi-implementatie

Strimzi-clusteroperator installeren met Helm

Strimzi Drain Cleaner installeren met Helm

Kafka-clusterarchitectuur en overwegingen

JVM-configuratie voor Kafka-productieclusters

Kafka-knooppuntgroepen implementeren

Het Kafka-cluster implementeren

Een Kafka-gebruiker en -onderwerp maken

Volgende stap

Bijdragers

Feedback

Aanvullende resources