kafkit-client 0.1.5

Kafka 4.0+ pure Rust client.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

# Configuration

Configuration is split by client type:

- `ProducerConfig` for direct producer setup.
- `ConsumerConfig` for direct consumer and share-consumer setup.
- `AdminConfig` for admin operations.
- `KafkaClient` for shared bootstrap servers and topic-scoped builders.
- `TlsConfig` and `SaslConfig` for security settings.

The builder-style `KafkaClient` facade is convenient for application code. The
direct config types expose the same lower-level knobs when you need explicit
control.

## Bootstrap Servers

Use one bootstrap server for local development:

```rust,no_run
use kafkit_client::{KafkaProducer, ProducerConfig};

#[tokio::main]
async fn main() -> kafkit_client::Result<()> {
    let producer = KafkaProducer::connect(ProducerConfig::new("localhost:9092")).await?;
    producer.shutdown().await?;
    Ok(())
}
```

For production, pass more than one bootstrap server:

```rust,no_run
use kafkit_client::KafkaClient;

#[tokio::main]
async fn main() -> kafkit_client::Result<()> {
    let producer = KafkaClient::new("broker-a:9092")
        .with_bootstrap_servers(["broker-a:9092", "broker-b:9092", "broker-c:9092"])
        .topic("orders")
        .producer()
        .connect()
        .await?;

    producer.shutdown().await?;
    Ok(())
}
```

## Producer Settings

Common producer options include:

- `with_client_id(...)`
- `with_acks(...)`
- `with_enable_idempotence(...)`
- `with_compression(...)`
- `with_batch_size(...)`
- `with_linger(...)`
- `with_delivery_timeout(...)`
- `with_request_timeout(...)`
- `with_retry_backoff(...)`
- `with_max_retries(...)`
- `with_transactional_id(...)`

Transactional and idempotent producers require `acks = -1`; the client returns
an error if those settings conflict.

## Consumer Settings

Common consumer options include:

- `with_client_id(...)`
- `with_auto_offset_reset(...)`
- `with_isolation_level(...)`
- `with_enable_auto_commit(...)`
- `with_auto_commit_interval(...)`
- `with_fetch_max_wait(...)`
- `with_fetch_min_bytes(...)`
- `with_fetch_max_bytes(...)`
- `with_partition_max_bytes(...)`
- `with_instance_id(...)`
- `with_rack_id(...)`

Consumers use the modern Kafka group protocol. Classic consumer group fallback
settings are not provided.

## Security Settings

TLS can be configured either through `TlsConfig` or through convenience methods
on each config type:

```rust,no_run
use kafkit_client::{KafkaAdmin, AdminConfig, TlsConfig};

#[tokio::main]
async fn main() -> kafkit_client::Result<()> {
    let admin = KafkaAdmin::connect(
        AdminConfig::new("kafka.example.com:9093").with_tls(
            TlsConfig::new()
                .with_ca_cert_path("/etc/ssl/certs/kafka-ca.pem")
                .with_server_name("kafka.example.com"),
        ),
    )
    .await?;

    let cluster = admin.describe_cluster().await?;
    println!("cluster id: {}", cluster.cluster_id);
    Ok(())
}
```

SASL helpers are available on producer, consumer, admin, and ergonomic builders:

- `with_sasl_plain(username, password)`
- `with_sasl_scram_sha_256(username, password)`
- `with_sasl_scram_sha_512(username, password)`