CentOS7分布式环境搭建

最新推荐文章于 2023-11-22 13:42:12 发布

limx-csd

最新推荐文章于 2023-11-22 13:42:12 发布

阅读量325

点赞数

分类专栏： Linux环境配置

本文链接：https://blog.csdn.net/u012283351/article/details/103459249

版权

Linux环境配置专栏收录该内容

2 篇文章 0 订阅

订阅专栏

CentOS7分布式环境搭建

一、Kafka安装

1、下载kafka

下载地址：http://kafka.apache.org/downloads

不能下载源码，下载编译过的

2、安装kafka

将kafka上传到 Linux里面并解压,kafka需要JDK的环境。

解压kafka
tar -zxvf kafka_2.12-2.2.0.tgz
 
重命名
mv kafka_2.12-2.2.0 kafka

配置config下面的server.properties文件

broker.id=1    改为1
 
增加ip映射，如果不增加就是locahost。这样没办法使用java连接
host.name=192.168.100.129

在这里插入图片描述

3、kafka基本操作命令

启动zk
bin/zookeeper-server-start.sh  config/zookeeper.properties
 
启动kafka
bin/kafka-server-start.sh config/server.properties
 
创建tocic
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test
 
查询topic列表
bin/kafka-topics.sh --list --zookeeper localhost:2181
 
启动 Producer
bin/kafka-console-producer.sh --broker-list 192.168.100.129:9092 --topic test
 
启动 Consumer
bin/kafka-console-consumer.sh --bootstrap-server 192.168.100.129:9092 --topic test --from-beginning
 
topic的信息
bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic test

4、使用java API 操作kafka推送和消费消息

导入kafka包

<dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka_2.12</artifactId>
</dependency>

生产者Producer代码简单示例

import java.util.Properties;
 
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
 
public class Producer {
    private static KafkaProducer<String, String> producer;
     
    static {
        Properties props = new Properties();
        //声生产者kafkka地址
        props.put("bootstrap.servers", "192.168.100.129:9092");
        //key序列化
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        producer = new KafkaProducer<>(props);
    }
 
    //发送消息
    private static void send() {
        //topic   key   推送的消息
        ProducerRecord<String, String> record = new ProducerRecord<String, String>("test","key", "1231231231");
        producer.send(record);
        producer.close();
    }
 
    public static void main(String[] args) {
        send();
 
    }
}

在这里插入图片描述

消费者Consumer示例代码

import java.util.Collections;
import java.util.Properties;
 
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
 
 
public class Consumer {
 
    private static KafkaConsumer<String, String> consumer;
    private static Properties props;
    static {
        props = new Properties();
        //声生产者kafkka地址
        props.put("bootstrap.servers", "192.168.100.129:9092");
        //key反序列化
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        //组???????
        props.put("group.id", "yangk");
    }
 
    private static void ConsumerMessage() {
        //允许自动提交位移
        props.put("enable.auto.commit", true);
        consumer = new KafkaConsumer<String, String>(props);
        consumer.subscribe(Collections.singleton("test"));
 
        //使用轮询拉取数据--消费完成之后会根据设置时长来清除消息，被消费过的消息，如果想再次被消费，可以根据偏移量(offset)来获取
        try {
            while (true) {
                ConsumerRecords<String, String> records = consumer.poll(100);
                for (ConsumerRecord<String, String> r : records) {
                    System.out.printf("topic = %s, offset = %s, key = %s, value = %s", r.topic(), r.offset(),
                            r.key(), r.value());
 
                }
            }
        } finally {
            consumer.close();
        }
    }
 
    public static void main(String[] args) {
        ConsumerMessage();
    }
 
}

在这里插入图片描述

5、总结

在启动kafka的时候遇到一个问题，这个问题的原因是因为Linux中的JDK版本低的原因导致。出现错误还是要细心的去看错误日志才能更准确的定位到错误的原因

这里也算是kafka的一个简单入门吧。后面还是需要继续学习kafka,来解决不懂得疑问

二、MongoDB 安装

1、安装包下载

MongoDB下载地址： wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-4.0.0.tgz

2、MongoDB安装

# 1.在usr/local/下创建mongodb文件夹
cd /usr/local/
mkdir mongodb

# 2.解压文件
tar -xzvf mongodb-linux-x86_64-rhel70-4.0.1.tgz

# 3.将解压后的文件下所有内容移动到mongodb文件夹下
# 注意这里不是将mongodb-linux-x86_64-rhel70-4.0.1文件夹移动到创建好的mongodb下，而是文件下的内容
mv mongodb-linux-x86_64-rhel70-4.0.1/*  /usr/local/mongodb/

# 4.添加mongodb的环境变量
vi /etc/profile

# 5.在文件末尾插入如下内容
export MONGODB_HOME=/usr/local/mongodb  
export PATH=$PATH:$MONGODB_HOME/bin

# 6.修改保存后要重启系统配置，执行命令如下
source /etc/profile

经过上述步骤，基本的配置已经完成了，接下来创建mongodb数据文件和日志文件的存放位置，并且对启动项进行配置，启动项配置其中包含数据库文件路径和日志文件路径，填写上述将要创建的文件夹或文件路径。具体步骤如下：

# 1.创建数据库文件存放路径
cd /usr/local/mongodb
mkdir -p data/db
chmod -r 777 data/db

# 2.创建日志文件
cd /usr/local/mongodb
mkdir logs
cd logs
touch mongodb.log

# 3.创建启动文件
cd /usr/local/mongodb/bin
touch mongodb.conf

# 4.编辑启动文件
vi mongodb.conf

# 5.在文件中插入如下内容
dbpath=/opt/mongodb/data/db  #数据文件存放目录
logpath=/opt/mongodb/logs/mongodb.log #日志存放目录
port=27017 #端口
fork=true #以守护程序的方式启用，即在后台运行
logappend=true
maxConns=5000
storageEngine = mmapv1
bind_ip=0.0.0.0

3、启动数据库

# 切换到bin目录下
cd /usr/local/mongodb/bin

# 启动数据库
./mongod --config mongodb.conf

# 访问数据库
./mongo

三、Redis 安装

1、什么是Redis

redis是用C语言开发的一个开源的高性能键值对（key-value）数据库。它通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止redis支持的键值数据类型如下字符串、列表（lists）、集合（sets）、有序集合（sorts sets）、哈希表（hashs）

2、Redis应用场景

缓存（数据查询、短连接、新闻内容、商品内容等等）。（最多使用）
分布式集群架构中的session分离。
聊天室的在线好友列表。
任务队列。（秒杀、抢购、12306等等）
应用排行榜。
网站访问统计。
数据过期处理（可以精确到毫秒）

3、 Redis安装

在CentOS环境下，Redis的安装与部署，redis从3.0版本以后增加了集群功能。
由于Redis是用C语言编写，所以编译时需要gcc，

yum install gcc-c++

通过官网下载地址：http://download.redis.io/releases/redis-5.0.0.tar.gz
或使用linux wget命令：wget http://download.redis.io/releases/redis-5.0.0.tar.gz

tar -zxvf redis-5.0.0.tar.gz

进入解压后的目录进行编译make，指定目录安装make install 如 /usr/local/redis

cd redis-5.0.0/
make (这里进redis-5.0.0/目录下直接make编译就好了)
make install PREFIX=/usr/local/redis   （指定编译路径）

进入安装目录bin下

cd /usr/local/redis/bin

目录结构是这样的
在这里插入图片描述

redis-benchmark redis性能测试工具
redis-check-aof AOF文件修复工具
redis-check-rdb RDB文件修复工具
redis-cli redis命令行客户端
redis.conf redis配置文件
redis-sentinal redis集群管理工具
redis-server redis服务进程

4、启动Redis

前端模式启动

/usr/local/redis/bin/redis-server
或 cd /usr/local/redis/bin 运行 ./redis-server

前端模式启动的缺点是ssh命令窗口关闭则redis-server程序结束，故不推荐使用此方法。
在这里插入图片描述
2. 后端模式启动
1）从redis的源码目录中复制redis.conf到redis的安装目录bin下。

cp /root/redis-5.0.0/redis.conf /usr/local/redis/bin

在这里插入图片描述
2）修改配置文件（是否后台启动）

vim /usr/local/redis/bin/redis.conf

找到 daemonize 按i 进入编辑模式把no 改为 yes
按ESC + :wq 保存退出
在这里插入图片描述
执行如下命令启动redis：

cd /usr/local/redis/bin

./redis-server ./redis.conf

查看是否启动成功

ps aux|grep redis

在这里插入图片描述
redis默认端口为 6379，可更改redis.conf文件，修改端口号

5、关闭Redis

强行终止redis进程可能会导致redis持久化数据丢失。
正确停止Redis的方式应该是向Redis发送SHUTDOWN命令，
命令为：

cd /usr/local/redis
./bin/redis-cli shutdown

强行终止redis：pkill redis-server

6、Redis开机自启

方法一：

vim /etc/init.d/redis 编写脚本 (输入下面的代码)

# chkconfig: 2345 10 90
# description: Start and Stop redis

PATH=/usr/local/bin:/sbin:/usr/bin:/bin

REDISPORT=6379 #实际环境而定
EXEC=/usr/local/redis/bin/redis-server #实际环境而定
REDIS_CLI=/usr/local/redis/bin/redis-cli #实际环境而定

PIDFILE=/var/run/redis.pid
CONF="/usr/local/redis/bin/redis.conf" #实际环境而定

case "$1" in
        start)
                if [ -f $PIDFILE ]
                then
                        echo "$PIDFILE exists, process is already running or crashed."
                else
                        echo "Starting Redis server..."
                        $EXEC $CONF
                fi
                if [ "$?"="0" ]
                then
                        echo "Redis is running..."
                fi
                ;;
        stop)
                if [ ! -f $PIDFILE ]
                then
                        echo "$PIDFILE exists, process is not running."
                else
                        PID=$(cat $PIDFILE)
                        echo "Stopping..."
                        $REDIS_CLI -p $REDISPORT SHUTDOWN
                        while [ -x $PIDFILE ]
                        do
                                echo "Waiting for Redis to shutdown..."
                                sleep 1
                        done
                        echo "Redis stopped"
                fi
                ;;
        restart|force-reload)
                ${0} stop
                ${0} start
                ;;
        *)
                echo "Usage: /etc/init.d/redis {start|stop|restart|force-reload}" >&2
                exit 1
esac

配置开机启动

chmod 755 /etc/init.d/redis #设置文件redis的权限，让Linux可以执行
chkconfig redis on    #开启服务自启动
chkconfig --list      #查看所有注册的脚本文件
service redis start   #启动
service redis stop    #关闭redis

3）检测是否成功

reboot  #重启--如果是centos6.5学过来的，init 0与init 6一样在centos7适用
ps aux|grep redis #查看redis进程是否存在

方法二：(centos7推荐)
centos 7以上是用Systemd进行系统初始化的，Systemd 是 Linux 系统中最新的初始化系统（init），它主要的设计目标是克服 sysvinit 固有的缺点，提高系统的启动速度。
Systemd服务文件以.service结尾，比如现在要建立redis为开机启动，如果用yum install命令安装的，yum命令会自动创建redis.service文件，直接用命令systemcel enable redis.service设置开机启动即可

在系统服务目录里创建redis.service文件

vim /etc/systemd/system/redis.service

写入以下内容：

[Unit]
Description=redis-server
After=network.target

[Service]
Type=forking
ExecStart=/usr/local/redis/bin/redis-server /usr/local/redis/bin/redis.conf
PrivateTmp=true

[Install]
WantedBy=multi-user.target

注意：ExecStart配置成自己的路径
配置描述：
　　Description:描述服务
　　After:描述服务类别
　　[Service]服务运行参数的设置
　　Type=forking是后台运行的形式
　　ExecStart为服务的具体运行命令
　　ExecReload为重启命令
　　ExecStop为停止命令
　　PrivateTmp=True表示给服务分配独立的临时空间
　　注意：[Service]的启动、重启、停止命令全部要求使用绝对路径
　　[Install]运行级别下服务安装的相关设置，可设置为多用户，即系统运行级别为3

重载系统服务：systemctl daemon-reload

测试并加入开机自启
先关闭redis-server
　systemctl stop redis.service
　开启redis-server
　systemctl start redis.service #如果服务是开启状态，使用此命令会启动失败。
开启成功，将服务加入开机自启
　　systemctl enable redis.service #注意后面不能跟空格
reboot #重启
查看服务运行状态：systemctl status redis.service
全部命令
　　systemctl start redis.service #启动redis服务
　　systemctl enable redis.service #设置开机自启动
　　systemctl disable redis.service #停止开机自启动
　　systemctl status redis.service #查看服务当前状态
　　systemctl restart redis.service　 #重新启动服务
　　systemctl list-units --type=service #查看所有已启动的服务
测试代码
引入jar包：

public class JedisTest {

    @Test
    public void testJedisSingle() {
        //创建一个jedis的对象。
        Jedis jedis = new Jedis("172.20.10.7", 6379);
        //调用jedis对象的方法，方法名称和redis的命令一致。
        jedis.set("key1", "jedis test");
        String str = jedis.get("key1");
        System.out.println(str);
        //关闭jedis。
        jedis.close();
    }
    
    /**
     * 使用连接池
     */
    @Test
    public void testJedisPool() {
        //创建jedis连接池
        JedisPool pool = new JedisPool("172.20.10.7", 6379);
        //从连接池中获得Jedis对象
        Jedis jedis = pool.getResource();
        String str = jedis.get("key1");
        System.out.println(str);
        //关闭jedis对象
        jedis.close();
        pool.close();
    }
}

至此redis安装配置完毕。

四、安装ElasticSearch

1、检测是否安装了Elasticsearch

ps aux |grep elasticsearch

2、安装JDK

3、下载Elasticsearch

wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.0.0.tar.gz
# 解压Elasticsearch
tar -zxvf elasticsearch-6.0.0.tar.gz
# 移动Elasticsearch到/usr/local/elasticsearch
mv elasticsearch-6.0.0 /usr/local/elasticsearch

4. 修改配置文件

进入/usr/local/elasticsearch/config目录，使用vi编辑器

 vi elasticsearch.yml
 network.host: 192.168.181.201
discovery.zen.ping.unicast.hosts: ["192.168.181.201"]

修改/etc/sysctl.conf否则会出现
max virutal memory areas vm.max_map_count [65530] is too low, increase to at least [262144]

vm.max_map_count=262144

退出保存后执行如下命令:

sysctl -p

使用vi编辑器，修改/etc/security/limits.conf文件，在文件末尾添加如下代码,否则会出现
max number of threads [3750] for user [xxx] is too low, increase to at least [4096]

1 # sanglp为登录服务器的用户名
2 
3 sanglp soft nofile 65536
4 sanglp hard nofile 65536
5 sanglp soft nproc  4096
6 sanglp hard nproc  4096

切记退出重新登录。

启动Elasticsearch
进入/usr/local/elasticsearch目录之中，输入以下命令，开始Elasticsearch服务：

1 ./bin/elasticsearch

在这里插入图片描述

新建spring boot的elasticsearch项目
在start.spring.io中新建springboot项目，并导入到intellij中
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>

        <groupId>com.slp</groupId>
        <artifactId>springboot-elasticsearch</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>

        <name>springboot-elasticsearch</name>
        <description>Demo project for Spring Boot</description>

        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.0.BUILD-SNAPSHOT</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>

        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
        </properties>

        <dependencies>
            <!--添加web的应用依赖-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <!--添加spring-data-elasticsearch的依赖-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
            </dependency>

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>

            <dependency>
                <groupId>net.java.dev.jna</groupId>
                <artifactId>jna</artifactId>
                <version>3.0.9</version>
            </dependency>
        </dependencies>

        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>

        <repositories>
            <repository>
                <id>spring-snapshots</id>
                <name>Spring Snapshots</name>
                <url>https://repo.spring.io/snapshot</url>
                <snapshots>
                    <enabled>true</enabled>
                </snapshots>
            </repository>
            <repository>
                <id>spring-milestones</id>
                <name>Spring Milestones</name>
                <url>https://repo.spring.io/milestone</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </repository>
        </repositories>

        <pluginRepositories>
            <pluginRepository>
                <id>spring-snapshots</id>
                <name>Spring Snapshots</name>
                <url>https://repo.spring.io/snapshot</url>
                <snapshots>
                    <enabled>true</enabled>
                </snapshots>
            </pluginRepository>
            <pluginRepository>
                <id>spring-milestones</id>
                <name>Spring Milestones</name>
                <url>https://repo.spring.io/milestone</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </pluginRepository>
        </pluginRepositories>
    </project>

application.yml

spring:
    data:
         elasticsearch:
             cluster-name:  elasticsearch #默认为elasticsearch
             cluster-nodes: 192.168.181.201:9300 #配置es节点信息，逗号分隔，如果没有指定，则启动ClientNode
             properties:
                 path:
                   logs: ./elasticsearch/log #elasticsearch日志存储目录
                   data: ./elasticsearch/data #elasticsearch数据存储目录

Article.java

package com.slp.springbootelasticsearch.pojo;
import org.springframework.data.elasticsearch.annotations.Document;
import java.io.Serializable;
    
/**
 * @author sanglp
 * @create 2018-07-04 9:06
 * @desc 文章实体类,默认情况下添加@Document注解会对实体中的所有属性建立索引，
 **/
@Document(indexName = "projectname",type = "article",indexStoreType = "fs",shards = 5,replicas = 1,refreshInterval = "-1")
public class Article implements Serializable {
    
    private Long id;
    /**
     * 标题
     */
    private String title;
    /**
     * 摘要
     */
    private String abstracts;
    /**
     * 内容
     */
    private String content;
    /**
     * 发表时间
     */
    private String postTime;
    /**
     * 点击率
     */
    private String clickCount;
    /**
     * 作者
     */
    private Author author;
    /**
     * 所属教程
     */
    private Tutorial tutorial;
}

Author.java

package com.slp.springbootelasticsearch.pojo;
import java.io.Serializable;
/**
 * @author sanglp
 * @create 2018-07-04 9:04
 * @desc 作者实体类
 **/
public class Author  implements Serializable{
	/**
     * 作者ID
     */
    private Long id;
    /**
     * 作者姓名
     */
    private String name;
    /**
     * 作者简介
     */
    private String remark;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }
}

Tutorial.java

package com.slp.springbootelasticsearch.pojo;
import java.io.Serializable;
/**
  * @author sanglp
  * @create 2018-07-04 9:03
  * @desc 实体类
  **/
public class Tutorial implements Serializable {
	private Long id;
    //教程名称
     private String name ;

     public Long getId() {
         return id;
     }

     public void setId(Long id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }
}

@Document注解里面的几个属性，类比mysql的话是这样：
index –> DB
type –> Table
Document –> row
@Id注解加上后，在Elasticsearch里相应于该列就是主键了，在查询时就可以直接用主键查询，后面再看。其实和mysql非常类似，基本就是一个数据库。

@Persistent
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface Document {
    
    String indexName();//索引库的名称，个人建议以项目的名称命名
    
    String type() default "";//类型，个人建议以实体的名称命名
    
     short shards() default 5;//默认分区数
    
     short replicas() default 1;//每个分区默认的备份数
    
     String refreshInterval() default "1s";//刷新间隔
    
     String indexStoreType() default "fs";//索引文件存储类型
}

加上了@Document注解之后，默认情况下这个实体中所有的属性都会被建立索引、并且分词。
我们通过@Field注解来进行详细的指定，如果没有特殊需求，那么只需要添加@Document即可。

@Field注解的定义如下：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@Documented
@Inherited
public @interface Field {

	FieldType type() default FieldType.Auto;#自动检测属性的类型
	
	FieldIndex index() default FieldIndex.analyzed;#默认情况下分词
	
	DateFormat format() default DateFormat.none;
	
	String pattern() default "";
	
	boolean store() default false;#默认情况下不存储原文
	
	String searchAnalyzer() default "";#指定字段搜索时使用的分词器
	
	String indexAnalyzer() default "";#指定字段建立索引时指定的分词器
	
	String[] ignoreFields() default {};#如果某个字段需要被忽略
	
	boolean includeInParent() default false;
}

ArticleSearchRepository.java相当于dao

package com.slp.springbootelasticsearch.repository;

import com.slp.springbootelasticsearch.pojo.Article;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

/**
 * @author sanglp
 * @create 2018-07-04 9:27
 * @desc 文章reposiroty  泛型的参数分别是实体类型和主键类型
 **/
public interface ArticleSearchRepository extends ElasticsearchRepository<Article,Long> {
    
}

测试用例

package com.slp.springbootelasticsearch;

import com.slp.springbootelasticsearch.pojo.Article;
import com.slp.springbootelasticsearch.pojo.Author;
import com.slp.springbootelasticsearch.pojo.Tutorial;
import com.slp.springbootelasticsearch.repository.ArticleSearchRepository;
import org.elasticsearch.index.query.QueryStringQueryBuilder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Iterator;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootElasticsearchApplicationTests {

    @Test
    public void contextLoads() {
    }
    @Autowired
    private ArticleSearchRepository articleSearchRepository;
    @Test
    public void testSaveArticleIndex(){
        Author author = new Author();
        author.setId(1L);
        author.setName("slp");
        author.setRemark("test");

        Tutorial tutorial = new Tutorial();
        tutorial.setId(1L);
        tutorial.setName("elastic search");

        Article article = new Article();
        article.setId(1L);
        article.setTitle("spring boot integrate elasticsearch");
        article.setAbstracts("elasticsearch is very easy");
        article.setTutorial(tutorial);
        article.setAuthor(author);
        article.setContent("elasticsearch based on lucene");
        article.setPostTime("20180704");
        article.setClickCount("1");
        articleSearchRepository.save(article);

    }

    @Test
    public void testSearch(){
        String queryString="spring";//搜索关键字
        QueryStringQueryBuilder builder=new QueryStringQueryBuilder(queryString);
        Iterable<Article> searchResult = articleSearchRepository.search(builder);
        Iterator<Article> iterator = searchResult.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next().getAbstracts());
        }
    }
}

五、安装MySQL5.7解压版

1、使用wget 下载MySQL安装包

wget https://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.26-linux-glibc2.12-x86_64.tar.gz

2、安装libaio库

yum install libaio

3、解压安装包

tar -zxvf mysql-5.7.26-linux-glibc2.12-x86_64.tar.gz

4、添加用户和用户组

groupadd mysql
useradd -r -g mysql -s /bin/false mysql

5、初始化数据目录

cd mysql5.7
mkdir mysql-files
 
#将目录用户和组所有权授予 mysql用户和mysql 组，并相应地设置目录权限：
chown mysql:mysql mysql-files 
chmod 750 mysql-files

6、配置my.cnf文件

删除CentOS7 etc目录自带的my.cnf 和 my.cnf.d

rm -rf  /etc/my.*

配置新的my.cnf

#新建一个my.cnf
vim /etc/my.cnf

加入如下配置

[client]
port = 3306
socket = /tmp/mysql.sock
[mysqld]
init-connect='SET NAMES utf8'
socket=/tmp/mysql.sock #mysql启动时生成的文件
basedir=/usr/local/mysql/mysql5.7/ 
datadir=/usr/local/mysql/mysql5.7/data
max_connections=200             # 允许最大连接数
character-set-server=utf8           # 服务端使用的字符集默认为8比特编码的latin1字符集
default-storage-engine=INNODB           # 创建新表时将使用的默认存储引擎
[mysqld_safe]
log-error=/usr/local/mysql/mysql5.7/data/mariadb.log
pid-file=/usr/local/mysql/mysql5.7/data/mariadb.pid
# skip-grant-tables   免密码登录

7、配置mysql环境变量


vim /etc/profile
#在最后一行加入:
export PATH=$PATH:/usr/local/mysql/mysql5.7/bin
#重新加载配置文件使配置的环境变量生效:
source /etc/profile

8、初始化MySQL

#不生成初始密码
mysqld --initialize-insecure --user=mysql --basedir=/usr/local/mysql/mysql5.7/ --datadir=/usr/local/mysql/mysql5.7/data

9、启动MySQL

#卡住不动回车
mysqld_safe --user=mysql &

10、登录

mysql -u root -p

11、修改密码

use mysql;
 
update user set authentication_string=password('这里填你设置的密码') where user='root';
 
flush privileges;#刷新信息
 
exit; #退出

12、配置外网可以访问

mysql -uroot -p
#输入刚才设置的密码
use mysql;
select host,user from user;
#这个是只有本地可以访问

在这里插入图片描述

update user set host='%' where user ='root';
flush privileges;
查看一下是否配置成功
select host,user from user;

在这里插入图片描述

13、把MySQL为服务并设置开机启动

#复制启动脚本
cp /usr/local/mysql/mysql5.7/support-files/mysql.server  /etc/init.d/mysql
#添加服务
chkconfig --add mysql
#设置开机启动
chkconfig --level 345 mysql on
#查看服务列表
chkconfig --list

#开启
service mysql start
#查看状态
service mysql status
#停止mysql服务
service mysql stop

六、安装RabbitMQ

rabbitmq是erlang语言编写的，安装rabbitmq之前，需要先安装erlang，这里用erlang的源码进行安装，erlang安装包官网下载地址： http://erlang.org/download/.

wget http://erlang.org/download/otp_src_21.1.tar.gz
tar -zxvf otp_src_21.1.tar.gz
cd otp_src_21.1
# 这里要新建一个erlang文件夹，因为erlang编译安装默认是装在/usr/local下的bin和lib中，这里我们将他统一装到/usr/local/erlang中，方便查找和使用。
mkdir -p /usr/local/erlang
 
# 在编译之前，必须安装以下依赖包
yum install -y make gcc gcc-c++ m4 openssl openssl-devel ncurses-devel unixODBC unixODBC-devel java java-devel

./configure --prefix=/usr/local/erlang

erlang的编译需要用到java环境，如果不装，会报错如下。

在这里插入图片描述
以下的两个：APPLICATIONS INFORMATION，DOCUMENTATION INFORMATION是正常的，不影响正常编译。

然后，直接执行make && makeinstall 进行编译安装

make && make install

然后将/usr/local/erlang/bin这个文件夹加入到环境变量中，加载以下即可直接使用。

vim /etc/profile
#########   添加如下内容   ###############
PATH=$PATH:/usr/local/erlang/bin
########################################

source /etc/profile

到此，既安装完成，直接输入erl，得到如下图得安装成功
在这里插入图片描述
OK，安装完erlang后，下面安装rabbitmq，安装之前，需要去官网查看一下rabbitmq版本对erlang版本的一个支持情况，官网地址：

这里，我们安装的erlang是最新的21版本，所以，rabbitmq也要安装最新的3.7.7，3.7.8。然后在官网上，直接下载该版本的安装包，为了方便安装，最好直接使用编译好的二进制文件包，即开即用，不用进行复杂的yum配置等


# 下载源码包
wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.7.8/rabbitmq-server-generic-unix-3.7.8.tar.xz
# 解压
tar -xvf rabbitmq-server-generic-unix-3.7.8.tar.xz -C /usr/local/
# 添加环境变量
vim /etc/profile
------  添加如下内容  ------
PATH=$PATH:/usr/local/rabbitmq_server-3.7.8/sbin
 
 
# 重载一下环境变量
source /etc/profile
 
# 添加web管理插件
rabbitmq-plugins enable rabbitmq_management

默认rabbitmq是没有配置文件的，需要去官方github上，复制一个配置文件模版过来，最新的3.7.0以上的版本可以使用新的key-value形式的配置文件rabbitmq.conf，和原来erlang格式的advanced.config相结合，解决一下key-value形式不好定义的配置。

由于我这里安装的是最新的3.7.8。所以就使用新的配置文件，将配置文件复制到 /usr/local/rabbitmq_server-3.7.8/etc/rabbitmq/ 下。如：
在这里插入图片描述 ok，然后就可以启动rabbitmq服务了，其实没有配置文件也是可以启动服务的。

# 后台启动rabbitmq服务
rabbitmq-server -detached

上面，启用了rabbitmq的管理插件，会有一个web管理界面，默认监听端口15672，将此端口在防火墙上打开，则可以访问web界面：
在这里插入图片描述
添加其他用户

rabbitmqctl add_user admin admin
rabbitmqctl set_permissions -p / admin ".*" ".*" ".*"
rabbitmqctl set_user_tags admin administrator

启用管理插件

rabbitmq-plugins enable rabbitmq_management

limx-csd

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
CentOS7分布式环境搭建

CentOS7分布式环境搭建欢迎使用Markdown编辑器Kafka安装功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入...
复制链接

扫一扫