Configuração e uso do Kafka

Índice

1. O servidor usa o docker para instalar o kafka

2. springboot integra kafka para realizar produtores e consumidores

1. O servidor usa o docker para instalar o kafka

①. Instale o docker (o docker é semelhante à loja de software linux e todos os aplicativos podem ser baixados do docker)

a. Instalação automática

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

b. Iniciar janela de encaixe

sudo systemctl start docker

c. Verifique se o Docker Engine-Community está instalado corretamente executando a imagem hello-world.

// puxa a imagem

sudo docker pull hello-world

// implemento

ola-mundo sudo docker executar ola-mundo

d. A instalação foi bem-sucedida

②、zookeeper

a、docker search zookeeper

b, docker pull zookeeper

③. Instale o kafka

a, pesquisa docker kafka

b, docker pull wurstmeister/kafka

④, execute o tratador

a、docker run -d --restart=always --log-driver json-file --log-opt max-size=100m --log-opt max-file=2 --name zookeeper -p 2181:2181 -v /etc/localtime:/etc/localtime zookeeper

⑤, execute Kafka

a、 docker run -d --restart=always --log-driver json-file --log-opt max-size=100m --log-opt max-file=2 --name kafka -p 9092:9092 -e KAFKA_BROKER_ID=0 -e KAFKA_ZOOKEEPER_CONNECT=42.194.238.131:2181/kafka -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://42.194.238.131:9092 -e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 -v / etc/horalocal:/etc/ hora local wurstmeister/kafka

b. Descrição do parâmetro

Descrição do parâmetro:

-e KAFKA_BROKER_ID=0 No cluster kafka, cada kafka tem um BROKER_ID para se distinguir

-e KAFKA_ZOOKEEPER_CONNECT=172.21.10.10:2181/kafka Configurar o caminho kafka de gerenciamento zookeeper 172.21.10.10:2181/kafka

-e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://172.21.10.10:9092 Registre o endereço e a porta do kafka no zookeeper.Se for acesso remoto, precisa ser alterado para IP de rede externa, como acesso ao programa Java, que não pode ser conectado.

-e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 Configurar a porta de escuta do kafka

-v /etc/localtime:/etc/localtime sincronização de tempo do contêiner hora da máquina virtual

⑥. Verifique se o kafka pode ser usado

docker exec -it kafka bash

cd /opt/kafka_2.13-2.8.1/

caixa de cd

a. Execute o produtor kafka e envie mensagens

./kafka-console-producer.sh --broker-list localhost:9092 --topic test

b. Abra uma página e execute o consumidor kafka para enviar mensagens

./kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test --from-beginning

⑦, o resultado é assim

⑧. Cada mensagem tem um tópico. O consumidor especifica qual tópico ouvir. Se a mensagem entrar na fila de mensagens for o tópico que especificamos para monitorar, ela será consumida, caso contrário, não será consumida (o tópico de produção e consumo especificado aqui por tópico)

9. Se o consumidor cair, o produtor continuará enviando a mensagem, e a mensagem não será perdida. Após a reinicialização do consumidor, ele receberá todas as mensagens enviadas após o tempo de inatividade

2. springboot integra kafka para realizar produtores e consumidores

①. Crie dependências no pom

<dependência>

        <groupId>org.springframework.kafka</groupId>

        <artifactId>spring-kafka</artifactId>

         <version>2.7.8</version>

</dependência>

②, Arranjo kafka

a. Adicione a seguinte configuração ao arquivo application.yml: (Observação: dois nomes idênticos em yml relatarão um erro, como duas molas)

primavera:

         Kafka:

                #O endereço IP e o número da porta do seu próprio kafka

                 servidores de bootstrap: localhost:9092

                 consumidor:

                 #Um group-id representa um grupo de consumidores e uma mensagem pode ser consumida por vários grupos de consumidores

ID do grupo: meu-grupo

auto-offset-reset: mais cedo

                produtor: #serialization

serializador de valor: org.apache.kafka.common.serialization.StringSerializer

key-serializer: org.apache.kafka.common.serialization.StringSerializer

b. Criar um produtor

@Configuration 
public class KafkaProducerConfig { 

    @Value("${spring.kafka.bootstrap-servers}") 
    private String bootstrapServers; 

    @Bean 
    public Map<String, Object> produtorConfigs() { 
        Map<String, Object> props = new HashMap<>(); 
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers); 
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class); 
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class); 
        adereços de retorno; 
    } 

    @Bean  
    public ProdutoraFactory<String, String> produtorFactory() {
        return new DefaultKafkaProducerFactory<>(producerConfigs()); 
    } 

    @Bean
    public KafkaTemplate<String, String> kafkaTemplate() { 
        return new KafkaTemplate<>(producerFactory()); 
    } 

}

O método sendMessage é usado para enviar mensagens para Kafka.

@RestController 
public class KafkaController { 

    @Autowired 
    private KafkaTemplate<String, String> kafkaTemplate; 

    @PostMapping("/send") 
    public void sendMessage(@RequestBody String message) { 
        kafkaTemplate.send("meu-tópico", mensagem); 
    } 

}

c. Criar um consumidor

@Configuration 
@EnableKafka 
public class KafkaConsumerConfig { 

    @Value("${spring.kafka.bootstrap-servers}") 
    private String bootstrapServers; 

    @Value("${spring.kafka.consumer.group-id}") 
    private String groupId; 

    @Bean 
    public Map<String, Object> consumerConfigs() { 
        Map<String, Object> props = new HashMap<>(); 
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers); 
        props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId); 
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "mais antigo"); 
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); 
        adereços de retorno;
    } 

    @Bean 
    public ConsumerFactory<String, String> consumerFactory() { 
        return new DefaultKafkaConsumerFactory<>(consumerConfigs()); 
    } 

    @Bean 
    public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() { 
        ConcurrentKafkaListenerContainerFactory<String, String> fábrica = new ConcurrentKafkaListenerContainerFactory<>(); 
        fábrica.setConsumerFactory(consumerFactory()); 
        fábrica de retorno; 
    } 

}

A anotação @KafkaListener declara um método de consumidor para receber de

Mensagens lidas no tópico my-topic

@Service 
public class KafkaConsumer { 

    @KafkaListener(topics = "meu-tópico", groupId = "meu-grupo-id") 
    public void consumir(String message) { 
        System.out.println("Mensagem recebida: " + mensagem); 
    } 

}