Introdução ao básico do Storm

Continue a criar, acelere o crescimento! Este é o 5º dia da minha participação no "Nuggets Daily New Plan · Outubro Update Challenge", clique para ver os detalhes do evento

1. Introdução do conceito

1. Storm é uma computação de fluxo em tempo real com grandes quantidades de dados.
2. Características

• Suporte a vários cenários em tempo real: processe mensagens e atualize bancos de dados em tempo real; consulte ou calcule fluxos de dados em tempo real e envie os resultados mais recentes ao cliente para exibição; paralelize consultas demoradas com base em chamadas RPC distribuídas.
• Alta escalabilidade: fácil de expandir, adicionar máquinas e ajustar o paralelismo
• Garantia de não perda de dados
• Super robustez
• Facilidade de uso: a semântica central é muito simples

3. Processo de operação

4. Introdução aos substantivos

• Paralelismo: é a tarefa, cada cópia do código spout/bolt será executada em uma tarefa
• Agrupamento de fluxo: a relação do fluxo de dados entre tarefas e tarefas
  • Estratégia de agrupamento de fluxo: Agrupamento aleatório: emissão aleatória
  • Agrupamento de Campos: emite com base em um ou mais campos

5. Exemplo de introdução

package com.mmc.storm;

import lombok.extern.slf4j.Slf4j;
import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.StormSubmitter;
import org.apache.storm.generated.AlreadyAliveException;
import org.apache.storm.generated.AuthorizationException;
import org.apache.storm.generated.InvalidTopologyException;
import org.apache.storm.spout.SpoutOutputCollector;
import org.apache.storm.task.OutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.TopologyBuilder;
import org.apache.storm.topology.base.BaseRichBolt;
import org.apache.storm.topology.base.BaseRichSpout;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
 * @description: 单词统计
 * @author: mmc
 * @create: 2019-10-21 22:47
 **/
@Slf4j
public class WordCountTopology {

    /**
     * 负责从数据源获取数据
     */
    public static class RandomSentenceSpout extends BaseRichSpout{

        private SpoutOutputCollector collector;

        private Random random;

        @Override
        public void open(Map map, TopologyContext topologyContext, SpoutOutputCollector spoutOutputCollector) {
            this.collector=spoutOutputCollector;
            this.random=new Random();
        }

        /**
         * 它会运行在task中，也就是说task会不断的循环调用它，就可以不断的发射新的数据，形成一个数据流
         */
        @Override
        public void nextTuple() {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String[] sentences = new String[]{"the cow jumped over the moon", "an apple a day keeps the doctor away",
                    "four score and seven years ago", "snow white and the seven dwarfs", "i am at two with nature"};
            String sentence=sentences[random.nextInt(sentences.length)];
            log.info("发送一段句子："+sentence);
            //这个Values，你可以理解为是构建一个Tuple，tuple是最小的数据单位
            collector.emit(new Values(sentence));
        }

        /**
         * 定义发送出去的tuple的字段的名称
         * @param outputFieldsDeclarer
         */
        @Override
        public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {
            outputFieldsDeclarer.declare(new Fields("sentence"));
        }
    }


    /**
     * 每一个Bolt代码也是发送到task里面去运行
     */
    public static class SplientSentence extends BaseRichBolt{

        private OutputCollector collector;

        @Override
        public void prepare(Map map, TopologyContext topologyContext, OutputCollector outputCollector) {
            this.collector=outputCollector;
        }

        /**
         * 每接受到一条数据都会交给execute方法去处理
         * @param tuple
         */
        @Override
        public void execute(Tuple tuple) {
            String sentence=tuple.getStringByField("sentence");
            String[] words=sentence.split(" ");
            for (String word:words){
                collector.emit(new Values(word));
            }
        }

        @Override
        public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {
            outputFieldsDeclarer.declare(new Fields("word"));
        }
    }


    public static class WordCount extends BaseRichBolt{

        private OutputCollector collector;

        private Map<String,Long> wordCountMap=new HashMap<>();

        @Override
        public void prepare(Map map, TopologyContext topologyContext, OutputCollector outputCollector) {
            this.collector=outputCollector;
        }

        @Override
        public void execute(Tuple tuple) {
            String word=tuple.getStringByField("word");
            Long count=wordCountMap.get(word);
            if(count==null){
                count=1L;
            }else {
                count++;
            }
            wordCountMap.put(word,count);
            log.info("【单词计数：】{}出现的次数是{}",word,count);
            collector.emit(new Values(word,count));

        }

        @Override
        public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {
            outputFieldsDeclarer.declare(new Fields("word","count"));
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //将Spolt和Bolts组合起来，形成一个拓扑
        TopologyBuilder builder=new TopologyBuilder();
        builder.setSpout("RandomSentence",new RandomSentenceSpout(),2);
        builder.setBolt("SplitSentence",new SplientSentence(),5).setNumTasks(10).shuffleGrouping("RandomSentence");
        builder.setBolt("WordCount",new WordCount(),10).setNumTasks(20).
                fieldsGrouping("SplitSentence",new Fields("word"));
        Config config=new Config();

        //命令行执行
        if(args!=null&&args.length>0){
            config.setNumWorkers(3);
            try {
                StormSubmitter.submitTopology(args[0],config,builder.createTopology());

            } catch (AlreadyAliveException e) {
                e.printStackTrace();
            } catch (InvalidTopologyException e) {
                e.printStackTrace();
            } catch (AuthorizationException e) {
                e.printStackTrace();
            }
        }else {
            config.setMaxTaskParallelism(20);
            LocalCluster cluster=new LocalCluster();
            cluster.submitTopology("WordCountTopology",config,builder.createTopology());
            Thread.sleep(60000);
            cluster.shutdown();
        }
    }
}

复制代码

2. Implantação de cluster

1. Baixe o endereço de download da tempestade
   : www.apache.org/dyn/closer.…
2. Configurar variáveis ​​de ambiente
   vi ~/.bashrc

export STORM_HOME=/usr/local/storm
export PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin:$ZOOKEEPER_HOME/bin:$JAVA_HOME/bin:$STORM_HOME/bin
复制代码

source ~/.bashrc 3. Modifique a configuração
Abra storm/conf/storm.yaml e adicione a seguinte configuração

storm.zookeeper.servers:
     - "192.168.1.12"
     - "192.168.1.13"
     - "192.168.1.14"

nimbus.seeds: ["192.168.1.12"]

storm.local.dir: "/var/storm"
 
supervisor.slots.ports:
   - 6700
   - 6701
   - 6702
   - 6703
复制代码

4. Crie uma pasta

mkdir /var/storm
复制代码

5. Iniciar

• Inicie o zookeeper primeiro
• Um nó inicia a tempestade nimbus >/dev/null 2>&1 &
• Todos os três nós executam o supervisor de tempestade >/dev/null 2>&1 &
• uma tempestade de nós ui>/dev/null 2>&1 &
• Dois nós supervisores Storm logviewer >/dev/null 2>&1 &

6. Feche a wordCountTopology da morte da tempestade