Mengonfigurasi dan menyebarkan komponen Strimzi dan Kafka pada Azure Kubernetes Service (AKS)

Dalam artikel ini, Anda menyebarkan Operator Kluster Strimzi dan kluster Kafka yang sangat tersedia di Azure Kubernetes Service (AKS).

Nota

Jika Anda belum membuat infrastruktur yang diperlukan untuk penyebaran ini, ikuti langkah-langkah dalam Menyiapkan infrastruktur untuk menyebarkan Kafka di Azure Kubernetes Service (AKS) untuk disiapkan, lalu Anda dapat kembali ke artikel ini.

Penyebaran Strimzi

Operator Kluster Strimzi disebarkan di namespace-nya sendiri, strimzi-operator, dan dikonfigurasi untuk mengawasi namespace kafka di mana komponen kluster Kafka disebarkan. Untuk ketersediaan tinggi, operator menggunakan:

Beberapa replika dengan pemilihan pemimpin: Satu replika berfungsi sebagai pemimpin aktif yang mengelola sumber daya yang disebarkan, sementara yang lain tetap siaga. Jika pemimpin gagal, replika siaga mengambil alih.
Distribusi zona: Tiga replika (satu per zona ketersediaan) memberikan ketahanan terhadap pemadaman zona. Aturan anti-afinitas pod mencegah beberapa replika dijadwalkan di zona yang sama.
Anggaran Gangguan Pod: Dibuat secara otomatis oleh penerapan operator untuk memastikan setidaknya satu replika tetap tersedia selama gangguan yang disengaja.

Arsitektur ini memastikan Operator Kluster Strimzi tetap sangat tersedia bahkan selama pemeliharaan infrastruktur atau pemadaman parsial.

Menginstal Operator Kluster Strimzi menggunakan Helm

Buat namespace untuk Operator Kluster Strimzi dan kluster Kafka menggunakan perintah kubectl create namespace.
```
kubectl create namespace strimzi-operator  
kubectl create namespace kafka  
```

Dengan menggunakan skrip berikut, buat values.yaml file untuk menyediakan konfigurasi tertentu untuk bagan 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  
EOF

Instal Operator Kluster Strimzi menggunakan helm install perintah .

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

Verifikasikan Operator Kluster Strimzi berhasil disebarkan dan semua pod berada dalam status berjalan menggunakan perintah kubectl get.

kubectl get pods -n strimzi-operator

Output Anda akan terlihat mirip dengan contoh output berikut:

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

Menginstal Strimzi Drain Cleaner menggunakan Helm

Strimzi Drain Cleaner memastikan pengurasan simpul Kubernetes yang lancar dengan mencegat permintaan pengurasan untuk pod yang berfungsi sebagai broker, yang mencegah replika partisi Kafka mengalami kekurangan replikasi dan menjaga kesehatan serta keandalan kluster.

Untuk ketersediaan tinggi, sebarkan Drain Cleaner dengan beberapa replika di seluruh zona ketersediaan dan konfigurasikan dengan anggaran gangguan pod untuk memastikannya tetap berfungsi selama pemadaman zona atau peningkatan kluster.

Chart Helm tersedia untuk pemasangan Strimzi Drain Cleaner:

Buat namespace untuk Drain Cleaner menggunakan perintah kubectl create namespace.
```
kubectl create namespace strimzi-drain-cleaner  
```

Buat values.yaml file untuk menggantikan konfigurasi tertentu untuk chart Helm dengan skrip berikut:

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

Instal Strimzi Drain Cleaner menggunakan helm install perintah .

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

Pastikan bahwa Strimzi Drain Cleaner berhasil disebarkan dan bahwa semua pod dalam status berjalan menggunakan perintah kubectl get.

kubectl get pods -n strimzi-drain-cleaner

Output Anda akan terlihat mirip dengan contoh output berikut:

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

Arsitektur dan pertimbangan kluster Kafka

Operator Kluster Strimzi memungkinkan penyebaran Kafka deklaratif pada AKS menggunakan definisi sumber daya kustom. Dimulai dengan Strimzi 0.46, kluster Kafka menggunakan KRaft dalam Kafka alih-alih ZooKeeper.

Strimzi menggunakan KafkaNodePool sumber daya kustom, di mana setiap kumpulan diberi peran tertentu (broker, pengontrol, atau keduanya):

Broker Kafka menangani pemrosesan dan penyimpanan pesan.
Pengontrol Kafka mengelola metadata Kafka menggunakan protokol konensus Rakit.

Untuk ketersediaan tinggi, arsitektur target ditentukan oleh:

Pisahkan KafkaNodePools untuk broker dan kontroler, yang masing-masing memiliki tiga replika.
Batasan Penyebaran Topologi yang mendistribusikan pod di seluruh zona ketersediaan dan node.
Aturan afinitas node yang mengoptimalkan pemanfaatan sumber daya dengan kumpulan simpul tertentu.
Volume persisten dari driver Azure Disk CSI dengan volume terpisah untuk pesan broker dan metadata.

Arsitektur ini meningkatkan skalabilitas dan toleransi kesalahan sambil memungkinkan broker dan pengontrol diskalakan secara independen untuk memenuhi persyaratan beban kerja.

Konfigurasi JVM untuk kluster Kafka produksi

Menyetel Java Virtual Machine (JVM) sangat penting untuk performa broker dan pengontrol Kafka yang optimal, terutama di lingkungan produksi. Pengaturan JVM yang dikonfigurasi dengan benar membantu memaksimalkan throughput, meminimalkan latensi, dan memastikan stabilitas di bawah beban berat untuk setiap broker.

LinkedIn, pembuat Kafka, membagikan argumen yang direkomendasikan untuk menjalankan Kafka di Java untuk salah satu kluster tersibuk mereka: Konfigurasi Java Apache Kafka. Panduan ini menggunakan konfigurasi ini sebagai garis besar untuk broker Kafka. Anda dapat membuat perubahan untuk memenuhi persyaratan beban kerja spesifik Anda.

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"

Menyebarkan kumpulan simpul Kafka

Di bagian ini, Anda membuat dua kumpulan simpul Kafka: satu untuk broker dan satu untuk pengontrol.

Terapkan manifes YAML untuk membuat dua kumpulan simpul Kafka menggunakan kubectl apply perintah .

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

Setelah membuat kumpulan simpul Kafka, langkah selanjutnya adalah menentukan sumber daya kustom kluster Kafka yang mengikat kumpulan ini ke dalam ekosistem Kafka yang berfungsi. Arsitektur ini mengikuti pemisahan pola kekhawatiran, di mana kumpulan simpul Kafka mengelola aspek infrastruktur sementara sumber daya kluster Kafka menangani konfigurasi tingkat aplikasi.

Menyebarkan kluster Kafka

Sebelum membuat kluster Kafka, buat ConfigMap yang berisi konfigurasi JMX Prometheus Exporter menggunakan kubectl apply perintah . ConfigMap ini mendefinisikan bagaimana metrik JMX internal Kafka diubah dan diekspos dalam format Prometheus, memungkinkan pemantauan komprehensif ekosistem Kafka Anda. Pola yang ditentukan dalam konfigurasi ini memetakan jalur metrik JMX ke metrik Prometheus yang diformat dengan benar, dengan jenis dan label yang sesuai.

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

Sebarkan sumber daya kluster Kafka, yang menghubungkan kumpulan simpul yang dibuat sebelumnya ke dalam ekosistem Kafka lengkap, menggunakan kubectl apply perintah . Sumber daya kustom ini mengonfigurasi komponen penting berikut:

Konfigurasi inti Kafka: Menentukan faktor replikasi, pengaturan pendengar, dan parameter khusus Kafka lainnya.
Cruise Control: Menyediakan kemampuan penyeimbangan dan pemantauan kluster otomatis.
Operator Entitas: Menyebarkan Topik dan Operator Pengguna yang mengelola topik dan pengguna Kafka secara deklaratif melalui sumber daya Kubernetes.
Metrik JMX: Mengonfigurasi paparan metrik menggunakan ConfigMaps yang ditentukan sebelumnya.

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

Setelah disebarkan, verifikasi penyebaran Kafka Anda dengan memeriksa bahwa semua KafkaNodePools, sumber daya kluster Kafka, dan pod yang sesuai sudah dibuat dan dalam keadaan berjalan menggunakan perintah kubectl get.

kubectl get pods,kafkanodepool,kafka -n kafka

Output Anda akan terlihat mirip dengan contoh output berikut:

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

Membuat Pengguna dan Topik Kafka

Operator Entitas Strimzi, yang disebarkan dengan sumber daya kustom kluster Kafka, menerjemahkan sumber daya kustom Kubernetes (KafkaTopic dan KafkaUser) ke dalam sumber daya Kafka yang sebenarnya. Ini memungkinkan alur kerja GitOps dan manajemen konfigurasi yang konsisten.

Nota

Membuat Topik Kafka dan Pengguna secara deklaratif menggunakan Operator Entitas bersifat opsional. Anda juga dapat membuatnya menggunakan alat atau API Kafka CLI tradisional. Namun, pendekatan deklaratif menawarkan manfaat seperti kontrol versi, jejak audit, dan manajemen yang konsisten di seluruh lingkungan.

Buat Topik Kafka dengan Operator Topik menggunakan perintah kubectl apply.

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

Verifikasi bahwa Topik Kafka berhasil dibuat menggunakan kubectl get perintah .
```
kubectl get kafkatopic -n kafka  
```
Output Anda akan terlihat mirip dengan contoh output berikut:
```
NAME         CLUSTER             PARTITIONS   REPLICATION FACTOR   READY  
test-topic   kafka-aks-cluster   4            3                    True  
```
Untuk informasi selengkapnya, lihat menggunakan Operator Topik untuk mengelola topik Kafka.

Buat Pengguna Kafka dengan Operator Pengguna menggunakan kubectl apply perintah .

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

Untuk informasi selengkapnya, lihat menggunakan Operator Pengguna untuk mengelola pengguna Kafka.

Langkah berikutnya

Mengonfigurasi pemantauan dan jaringan untuk kluster Kafka pada AKS menggunakan Operator Strimzi

Kontributor

Microsoft mempertahankan artikel ini. Kontributor berikut awalnya menulisnya:

Sergio Navar | Insinyur Pelanggan Senior
Erin Schaffer | Pengembang Konten 2

Saran dan Komentar

Apakah halaman ini membantu?

Terakhir diperbarui pada 2025-09-19

Mengonfigurasi dan menyebarkan komponen Strimzi dan Kafka pada Azure Kubernetes Service (AKS)

Penyebaran Strimzi

Menginstal Operator Kluster Strimzi menggunakan Helm

Menginstal Strimzi Drain Cleaner menggunakan Helm

Arsitektur dan pertimbangan kluster Kafka

Konfigurasi JVM untuk kluster Kafka produksi

Menyebarkan kumpulan simpul Kafka

Menyebarkan kluster Kafka

Membuat Pengguna dan Topik Kafka

Langkah berikutnya

Kontributor

Saran dan Komentar

Sumber Daya Tambahan: