Docs/kafka producer default stricky partitioner

Best-Practices-for-Monitoring-Kafka-Producers.md

@@ -0,0 +1,38 @@
+### Best Practices for Monitoring Kafka Producers
+
+1. **Monitor Producer Metrics**:
+    - Use Kafka's built-in metrics to monitor producer performance. Key metrics include:
+        - `record-send-rate`: The number of records sent per second.
+        - `record-error-rate`: The number of record sends that resulted in errors per second.
+        - `record-retry-rate`: The number of record sends that were retried per second.
+        - `record-size-avg` and `record-size-max`: The average and maximum size of records sent.
+        - `request-latency-avg` and `request-latency-max`: The average and maximum request latency.
+
+2. **Enable JMX (Java Management Extensions)**:
+    - Configure Kafka producers to expose JMX metrics, which can be collected and visualized using monitoring tools like Prometheus, Grafana, or JConsole.
+
+3. **Log Important Events**:
+    - Implement logging for key events such as successful sends, retries, and errors. Use a logging framework like SLF4J with Logback or Log4j.
+
+4. **Set Alerts**:
+    - Configure alerts for critical metrics such as high error rates, high retry rates, or increased latency. This helps in quickly identifying and addressing issues.
+
+5. **Monitor Resource Usage**:
+    - Keep an eye on the resource usage (CPU, memory, network) of the producer application to ensure it is operating within acceptable limits.
+
+6. **Track Delivery Semantics**:
+    - Ensure that the producer's delivery semantics (e.g., at-least-once, exactly-once) are being met by monitoring the relevant metrics and logs.
+
+7. **Use Distributed Tracing**:
+    - Implement distributed tracing (e.g., using OpenTracing or Zipkin) to trace the flow of messages through the producer and the Kafka cluster. This helps in identifying bottlenecks and latency issues.
+
+8. **Regularly Review Configuration**:
+    - Periodically review and update the producer configuration to ensure it is optimized for current workloads and Kafka cluster conditions.
+
+9. **Monitor Broker Health**:
+    - Since producer performance is closely tied to broker health, monitor the Kafka brokers for issues such as high load, disk usage, and network latency.
+
+10. **Test Failover Scenarios**:
+    - Regularly test failover scenarios to ensure that the producer can handle broker failures and network partitions gracefully.
+
+By following these best practices, you can ensure that your Kafka producers are running efficiently and reliably, and you can quickly detect and resolve any issues that arise.

Compressão-de-Mensagens-no-Kafka.md

@@ -0,0 +1,60 @@
+### Compressão de Mensagens no Kafka
+
+#### Explicação
+A compressão de mensagens no Kafka pode ser configurada no nível do produtor, tópico ou broker. A compressão ajuda a reduzir o tamanho dos dados transmitidos e armazenados, melhorando a eficiência da rede e o desempenho do armazenamento.
+
+#### Tipos de Compressão
+Os tipos de compressão suportados pelo Kafka são:
+- **none**: Sem compressão.
+- **gzip**: Bom nível de compressão, mas pode ser mais lento.
+- **snappy**: Rápido, mas com menor taxa de compressão.
+- **lz4**: equilíbrio entre velocidade e taxa de compressão.
+- **zstd**: Alta taxa de compressão e velocidade, disponível a partir do Kafka 2.1.
+
+#### Configuração de Compressão no Produtor
+Para configurar a compressão no produtor, você pode definir a propriedade `compression.type`:
+
+```java
+public static void main(String[] args) {
+
+    Properties properties = new Properties();
+    properties.setProperty("bootstrap.servers", "localhost:9092");
+    properties.setProperty("key.serializer", StringSerializer.class.getName());
+    properties.setProperty("value.serializer", StringSerializer.class.getName());
+    properties.setProperty("compression.type", "gzip"); // Tipo de compressão
+    KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
+}
+```
+
+#### Configuração de Compressão no Tópico
+A compressão no nível do tópico pode ser configurada ao criar o tópico:
+
+```sh
+kafka-topics.sh --create --topic my_topic --partitions 3 --replication-factor 1 --config compression.type=gzip --bootstrap-server localhost:9092
+```
+
+#### Configuração de Compressão no Broker
+Para configurar a compressão no nível do broker, adicione a seguinte linha no arquivo `server.properties`:
+
+```properties
+compression.type=gzip
+```
+
+#### Batch de Mensagens
+O Kafka agrupa mensagens em batches para melhorar a eficiência. A compressão é aplicada ao batch inteiro, não a cada mensagem individualmente. Isso maximiza a eficiência da compressão.
+
+#### Vantagens da Compressão
+- **Redução do uso de rede**: Menos dados são transmitidos pela rede.
+- **Melhor desempenho de armazenamento**: Menos espaço é necessário para armazenar os dados.
+- **Maior throughput**: A compressão pode aumentar a taxa de transferência de dados.
+
+#### Desvantagens da Compressão
+- **Sobrecarga de CPU**: A compressão e descompressão consomem recursos de CPU.
+- **Latência**: Pode aumentar a latência devido ao tempo necessário para compressão e descompressão.
+
+#### Uso de Compressão
+- **Quando usar**: Em cenários onde a largura de banda da rede é limitada ou o armazenamento é caro.
+- **Quando evitar**: Em sistemas com restrições de CPU ou onde a latência é crítica.
+
+### Resumo
+A compressão de mensagens no Kafka pode ser configurada no produtor, tópico ou broker. Os tipos de compressão incluem `none`, `gzip`, `snappy`, `lz4` e `zstd`. A compressão reduz o uso de rede e armazenamento, mas pode aumentar a sobrecarga de CPU e a latência. É recomendada em ambientes com limitações de largura de banda ou armazenamento, mas deve ser usada com cautela em sistemas sensíveis à latência.

Configuração-Propriedades-Kafka-Producer.md

@@ -0,0 +1,72 @@
+### Configuração de Propriedades no Kafka Producer
+
+No Kafka 3.x, algumas propriedades vêm configuradas por padrão, como `min.insync.replicas`. Portanto, não é necessário configurá-las explicitamente, a menos que você queira alterar o valor padrão. Abaixo, explico as propriedades que você mencionou e quando configurá-las:
+
+#### Propriedades Configuradas
+
+1. **`enable.idempotence`**:
+    - **Descrição**: Habilita a idempotência no produtor para evitar mensagens duplicadas.
+    - **Quando Configurar**: Necessário configurar explicitamente em versões anteriores ao Kafka 3.x. No Kafka 3.x, já vem habilitado por padrão.
+    - **Exemplo**:
+      ```java
+      public static void main(String[] args){
+        Properties properties = new Properties();
+        properties.setProperty("enable.idempotence", IS_BOOLEAN);
+      }
+      ```
+
+2. **`retries`**:
+    - **Descrição**: Define o número de tentativas de reenvio em caso de falhas transitórias.
+    - **Quando Configurar**: Necessário configurar explicitamente em versões anteriores ao Kafka 3.x. No Kafka 3.x, já vem configurado por padrão.
+    - **Exemplo**:
+      ```java
+        public static void main(String[] args){
+            Properties properties = new Properties();
+      properties.setProperty("retries", "3");
+        }
+      ```
+
+3. **`retry.backoff.ms`**:
+    - **Descrição**: Define o tempo de espera entre tentativas de reenvio.
+    - **Quando Configurar**: Necessário configurar explicitamente em versões anteriores ao Kafka 3.x. No Kafka 3.x, já vem configurado por padrão.
+    - **Exemplo**:
+      ```java
+       public static void main(String[] args){
+        Properties properties = new Properties();
+      properties.setProperty("retry.backoff.ms", "100");
+      }
+      ```
+
+4. **`delivery.timeout.ms`**:
+    - **Descrição**: Define o tempo máximo que o produtor tentará enviar uma mensagem antes de desistir.
+    - **Quando Configurar**: Necessário configurar explicitamente em versões anteriores ao Kafka 3.x. No Kafka 3.x, já vem configurado por padrão.
+    - **Exemplo**:
+      ```java
+      public static void main(String[] args){
+        Properties properties = new Properties();
+      properties.setProperty("delivery.timeout.ms", "120000"); // 2 minutos
+      }
+      ```
+
+### Exemplo de Configuração para Versões Anteriores ao Kafka 3.x
+
+```java
+public static void main(String[] args) {
+
+    Properties properties = new Properties();
+    properties.setProperty("bootstrap.servers", "localhost:9092");
+    properties.setProperty("key.serializer", StringSerializer.class.getName());
+    properties.setProperty("value.serializer", StringSerializer.class.getName());
+
+// Habilitar idempotência para evitar mensagens duplicadas
+    properties.setProperty("enable.idempotence", IS_BOOLEAN);
+// Configurar o número de tentativas de reenvio
+    properties.setProperty("retries", "3");
+// Configurar o tempo de espera entre tentativas
+    properties.setProperty("retry.backoff.ms", "100");
+// Configurar o tempo limite de entrega
+    properties.setProperty("delivery.timeout.ms", "120000"); // 2 minutos
+}
+```
+
+Para versões do Kafka 3.x e posteriores, essas configurações já vêm por padrão e não precisam ser explicitamente definidas, a menos que você queira alterar os valores padrão.