2.4M messages per second.
Zero operational pain.

import "conduit-io/go-client"

func main() {
  client := conduit.Connect("localhost:9092")
  defer client.Close()

  // Produce with exactly-once semantics
  client.Produce("payments", &conduit.Message{
    Key:   []byte("order-4821"),
    Value: []byte(`{"amount":99.50,"currency":"USD"}`),
  })

  // Consume with automatic offset management
  consumer := client.Subscribe("payments", conduit.ConsumerOpts{
    Group:       "billing-service",
    StartOffset: conduit.Latest,
  })

  for msg := range consumer.Messages() {
    process(msg)
    msg.Ack()
  }
}

use conduit_client::{Client, Message};

async fn main() -> Result<()> {
    let client = Client::connect("localhost:9092").await?;

    // Produce with exactly-once semantics
    client.produce("payments", Message {
        key: "order-4821".into(),
        value: r#"{"amount":99.50,"currency":"USD"}"#
            .into(),
    }).await?;

    // Consume with automatic offset management
    let mut consumer = client
        .subscribe("payments")
        .group("billing-service")
        .start_offset(Offset::Latest)
        .build().await?;

    while let Some(msg) = consumer.next().await {
        process(&msg).await?;
        msg.ack().await?;
    }
    Ok(())
}