确定不来看看？CentOS7系统一键安装并配置相关服务（离线模式下rpm的方式安装MySQL8、JDK11、Minio、Redis6.2、gcc环境），帮你省心省力！

一、前言

在企业或个人的服务器环境中，部署和配置各种服务是一项常见而繁琐的任务。特别是在离线环境下，没有互联网连接或网络限制，从头开始安装和配置每个服务可能会非常耗时且复杂。

为了解决这个问题，我为大家提供了一个方便的解决方案，即 CentOS 7 一键安装并配置相关服务的脚本。该脚本旨在为用户提供一个简单的方法，以自动化且高效的方式在 CentOS 7 系统中安装和配置以下服务：MySQL 8、MinIO、Redis 6.2和gcc 环境。

通过使用这个一键安装脚本，用户无需手动下载软件包、解决依赖关系或执行复杂的配置步骤。脚本将自动处理这些任务，并确保每个服务在系统中正确安装和配置。

此外，该脚本适用于离线模式，这意味着用户无需网络连接即可完成服务的安装和配置。它内置了所需的软件包和依赖项，可在没有互联网访问的环境中独立运行。

使用这个一键安装脚本，用户可以节省时间和精力，快速搭建一个功能完善的服务器环境。无论是在企业中部署服务还是在个人项目中使用，这个一键安装脚本都可以让您轻松设置所需的服务，并减少手动操作的繁琐过程。

请注意，脚本提供了默认的安装和配置选项，您可以根据需要进行自定义设置。在运行脚本之前，请确保您具备适当的权限，并仔细阅读脚本中的说明和提示。

开始使用 CentOS 7 一键安装并配置相关服务的脚本，让您的部署过程更加省心省力！

二、MySQL8安装配置脚本

在服务器中新建对应的文件夹，将相关应用的rpm包通关Shell工具上传至服务器中对应的文件夹中


将脚本上传至对应的文件夹中，在执行脚本前，你还需要切换目录

# 切换目录
cd /usr/local/mysql
# 分配执行权限
chmod +x mysql_install\(8.0\).sh

执行以下命令：

./mysql_install\(8.0\).sh

稍作等待程序安装配置，当脚本执行完成后会自动重启，重新连接服务器即可，重新连接进入服务器命令控制台后，执行：

systemctl status mysqld.service

查看mysql运行状态，如下即为安装成功。

扫描二维码关注公众号，回复： 16023460 查看本文章

4、查看初始化密码，执行：

grep "A temporary password is generated for root@localhost: " /var/log/mysql/error.log

执行：

mysql -u root -p

进入MySQL的命令行中，输入上面的临时密码进入

5、修改密码，执行：

ALTER USER 'root'@'localhost' IDENTIFIED BY 'admin123';

具体MySQL8的脚本内容如下：

#! /bin/bash
###MySQL8.0.33 数据库自动安装脚本
# mysql-8.0.33-1.el7.x86_64.rpm-bundle.tar
tarPath=/usr/local/mysql/
rpmPath=/usr/local/mysql/
tarVersion=-8.0.33-1.el7.x86_64
tarFile=mysql${tarVersion}.rpm-bundle

#mysql 安装路径
installPath=/usr/local/mysql/

#my.cnf 配置文件
mysqlcnf=/etc/my.cnf

#mysql serverid 需要设置唯一的id,比如ip+3位数字(配备主从服务器时使用)
#mysqlServerid=1010101

#mysql 密码
mysqlPass="bjyz@123"


#mysql数据目录
dase_default=${installPath}
data_dir=${dase_default}/data

#判断服务是否存在
CheckServiceRunning() 
{
    
    
    if [[ -n `netstat -tlunp|grep -w {
     
     mysqlPort}` || -n `ps -ef|grep mysqld|grep -v grep` || -n `systemctl status mysqld 2>/dev/null` ]]; then
        echo -e "\e[31m mysql已存在！ \e[0m"
        exit 1
    fi
}

#校验是否为root用户
CheckRoot()
{
    
    
    if [ $(id -u) != "0" ]; then
        echo -e "\e[31m 当前不是root用户，禁止操作 \e[0m"
        exit 1
    fi
}

#拷贝tar包
DecompressionTar()
{
    
    
    if [ ! -e ${tarPath}${tarFile}.tar ]; then
        echo -e "\e[31m ${tarPath}${tarFile}.tar 不存在！请检查后重新执行脚本 \e[0m"
        exit 1
    fi

    #解压并复制到安装目录
    if [ ! -d ${installPath}${tarFile} ]; then
        tar -xvf ${tarPath}${tarFile}.tar -C ${tarPath}
    fi

    echo -e "\e[32m 软件已解压 \e[0m"
}

#检查冲突包，安装包
CheckPackage()
{
    
    
    rpm -qa | grep postfix 1>/dev/null
    if [ $? -eq 0 ]; then
        rpm -ev postfix-2.10.1-9.el7.x86_64
            if [ $? -ne 0 ]; then
            echo -e "\e[31m postfix卸载失败 \e[0m"
            exit 1
            fi
    fi

    rpm -qa | grep mariadb 1>/dev/null
    if [ $? -eq 0 ]; then
        rpm -ev mariadb-libs-5.5.68-1.el7.x86_64
        if [ $? -ne 0 ]; then
            echo -e "\e[31m mariadb卸载失败 \e[0m"
            exit 1
            fi
    fi

    # 一键安装：rpm -ivh *.rpm --nodeps --force
    rpm -ivh ${rpmPath}mysql-community-client-plugins${tarVersion}.rpm
    if [ $? -ne 0 ]; then
        echo -e "\e[31m community-client-plugins安装失败 \e[0m"
    fi

    rpm -ivh ${rpmPath}mysql-community-common${tarVersion}.rpm
    if [ $? -ne 0 ]; then
        echo -e "\e[31m community-common安装失败 \e[0m"
    fi

    rpm -ivh ${rpmPath}mysql-community-libs${tarVersion}.rpm
    if [ $? -ne 0 ]; then
        echo -e "\e[31m community-libs安装失败 \e[0m"
        exit 1
    fi

    rpm -ivh ${rpmPath}mysql-community-client${tarVersion}.rpm
    if [ $? -ne 0 ]; then
        echo -e "\e[31m community-client安装失败 \e[0m"
        exit 1
    fi

    rpm -ivh ${rpmPath}mysql-community-icu-data-files${tarVersion}.rpm
    if [ $? -ne 0 ]; then
        echo -e "\e[31m community-icu-data-files安装失败 \e[0m"
        exit 1
    fi

    rpm -ivh ${rpmPath}mysql-community-server${tarVersion}.rpm
    if [ $? -ne 0 ]; then
        echo -e "\e[31m community-server安装失败 \e[0m"
        exit 1
    fi
}


# 添加读写权限、创建用户组
AssignMySQL() {
    
    
    mkdir -p ${data_dir}                  # 创建数据卷
    mkdir -p /var/log/mysql/              # 创建日志文件夹
    touch /var/log/mysql/error.log        # 创建日志文件
    groupadd mysql                        # 创建 mysql 用户组
    useradd -r -g mysql mysql             # 创建 mysql用户并加入 mysql 用户组
    cat /etc/group                        # 显示/etc/group文件内容，可验证用户组是否创建成功
    cat /etc/passwd                       # 显示/etc/passwd文件内容，可验证用户是否创建成功
    chown -R mysql:mysql /var/lib/mysql/  # 设置目录权限
    chown -R mysql:mysql /usr/local/mysql/data     # 更改属主目录权限
    chown -R mysql:mysql /usr/local/mysql/
    chmod 770 /usr/local/mysql/data
    chmod 770 /var/lib/mysql              # 更改日志目录的权限
    chmod 777 /var/run/mysqld/            # 更改主进程的权限
    chmod 777 /var/log/mysql/
    chmod 777 /var/log/mysql/error.log
    

}

ConfigureMySQL() {
    
    
    # 修改profile文件
    # vim /etc/profile
    # 在文件尾部追加下面的内容
    echo "export PATH=$PATH:/usr/local/mysql/bin:/usr/local/mysql/lib" >> /etc/profile
    # 保存/etc/profile,并应用此文件
    source /etc/profile
}

#更新cnf文件
# MySQL8.0在初始化时不支持修改lower_case_table_names参数
# 相关链接：https://blog.csdn.net/qq_26007225/article/details/121172462
UpdateCnf() {
    
    
    cat << EOF > /etc/my.cnf
[mysql]
# 默认字符集
default-character-set=utf8mb4

[client]
port=3306
socket=/var/lib/mysql/mysql.sock

[mysqld]
port = 3306
user = mysql
# 允许外部访问
bind-address=0.0.0.0

# 指定 MySQL 数据库的默认字符集
character-set-server=utf8mb4

# 设置 MySQL 执行中断的超时时间
interactive_timeout = 120
wait_timeout = 120

# 设置 MySQL 数据库的缓存大小
key_buffer_size = 16M
# query_cache_size = 128M

socket = /var/lib/mysql/mysql.sock
datadir = /usr/local/mysql/data
# basedir = /usr/local/mysql/


# 关闭查询缓存
# query_cache_type = 0

# 设置 MySQL 允许访问的最大连接数
max_connections = 1000

# 设置 MySQL 日志级别
log-error=/var/log/mysql/error.log
log_queries_not_using_indexes = 1
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 1


#事务隔离级别，默认为可重复读，mysql默认可重复读级别（此级别下可能参数很多间隙锁，影响性能）
transaction_isolation = READ-COMMITTED

#TIMESTAMP如果没有显示声明NOT NULL，允许NULL值
explicit_defaults_for_timestamp = true


#开启bin log 功能
log-bin=mysql-bin

#binlog 记录内容的方式，记录被操作的每一行
binlog_format = ROW

#设置client连接mysql时的字符集,防止乱码
init_connect='SET NAMES utf8mb4'

#数据库字符集对应一些排序等规则，注意要和character-set-server对应
collation-server = utf8mb4_general_ci

#是否对sql语句大小写敏感，1表示不敏感
lower_case_table_names = 1


[mysqld_safe]
log-error = /var/log/mysql/error.log
pid-file = /var/lib/mysql/mysqld.pid

# lc_messages_dir=/usr/local/mysql/share
# lc_messages=en_US

# include all files from the config directory
EOF

}

#重置密码
ResetPwd()
{
    
    

    # 启动之前初始化
    mysqld --initialize

    # 解决mysqld: File '/usr/local/mysql/data/mysql-bin.index' not found (OS errno 13 - Permission denied)
    sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config

    sleep 2

    ln -s /var/lib/mysql/mysql.sock /tmp  #添加软连接

    
    systemctl start mysqld.service
    systemctl status mysqld.service

    # 从日志中获取mysql初始密码
    pwd=$(grep "A temporary password is generated for root@localhost: " /var/log/mysql/error.log | awk '{print $NF}')
    echo -e "\e[31m 初始密码是: \e[0m${pwd}"
    pwd=${pwd// /}
    echo -e "\e[31m 初始密码是: \e[0m${pwd}"
    
    # 修改密码规则
    mysql -u root --password="${pwd}" -e "SET GLOBAL validate_password.policy=0;" &&
    mysql -u root --password="${pwd}" -e "SET GLOBAL validate_password.length=1;" &&
    
    # 修改密码
    mysql -u root --password="${pwd}" -e "ALTER USER 'root'@'localhost' IDENTIFIED BY '${mysqlPass}';" &&
    
    # 重启服务
    systemctl restart mysqld.service
    
    # 修改密码策略
    # mysql -uroot --password="${mysqlPass}" -e "SET GLOBAL validate_password.policy=STRONG;"
    
    # 重启 MySQL 服务
    # systemctl restart mysqld.service
    
    # 设置密码复杂度
    mysql -u root --password="${mysqlPass}" -e "USE mysql; UPDATE user SET Host='%' WHERE user='root';" &&
    
    # 刷新退出
    mysql -u root --password="${mysqlPass}" -e "flush privileges;"
    
    # 设置开启自启
    systemctl enable mysqld.service
    systemctl daemon-reload

    
    # 若需要,关闭防火墙并永久停用
    systemctl stop firewalld.service
    systemctl disable firewalld.service
}

#开启远程访问
# RemoteConnection()
# {
    
    
#     mysql -uroot -p${mysqlPass} -e "use mysql;"
#     mysql -uroot -p${mysqlPass} -e "update user set host='%' where user='root';"
#     mysql -uroot -p${mysqlPass} -e "flush privileges;"
#     mysql -uroot -p${mysqlPass} -e "grant all privileges on *.* to 'root'@'%' IDENTIFIED BY '${mysqlPass}' WITH GRANT OPTION;"
#     mysql -uroot -p${mysqlPass} -e "flush privileges;"
# }

main()
{
    
    
    ##1.判断是否已安装mysql
    CheckServiceRunning

    ##2.判断是否为ROOT用户
    CheckRoot

    ##3.拷贝tar包
    DecompressionTar

    ##4.检查冲突包，安装包
    CheckPackage

    ##5.添加读写权限、创建用户组
    AssignMySQL

    ##5.配置mysql
    ConfigureMySQL

    ##6.更新cnf文件
    UpdateCnf

    ##7.重置密码
    ResetPwd

    ##8.开启远程访问
    # RemoteConnection
    
    echo -e "\e[32m mysql安装完成 \e[0m"

    sleep 3

    echo -e "\e[32m CentOS7系统即将重启，加载MySQL配置...... \e[0m"

    systemctl enable mysqld.service
    systemctl start mysqld.service
    systemctl status mysqld.service


    reboot
}

main

三、JDK11配置安装

cd 到相应目录，执行：

cd /usr/local/jdk11/

2、赋予脚本执行的权限，执行：

# 赋予执行权限
chmod +x jdk11_install.sh
# 查看权限组
ll

3、执行：

# 执行脚本
./jdk11_install.sh
# 查看java版本
java -version

根据程序中提示进行操作，安装完成后如下所示

JDK11安装的具体脚本内容：

#!/bin/bash

# JDK 安装包路径
jdkPath=/usr/local/jdk11/

# JDK 安装路径
installPath=/usr/local/jdk11/jdk-11.0.19

# JDK 安装包名称
jdkFile=jdk-11.0.19_linux-x64_bin.tar.gz


# 检查是否有root权限运行此脚本
CheckRoot() {
    
     
    if [ $(id -u) != "0" ]; then 
        echo -e "\e[31m 当前不是 root 用户，禁止操作 \e[0m" 
        exit 1 
    fi 
} 

# 检查服务是否正在运行
checkServiceRunning() {
    
    
    if [[ -n $(java -version 2>&1 | grep "openjdk version") ]]; then
        echo -e "\e[31m JDK 服务已存在！\e[0m"

        read -p "是否卸载现有的 JDK 1.8 服务？ (y/n): " choice
        case "$choice" in
            y|Y )
                # 执行卸载 JDK 1.8 的操作
                echo "正在卸载 JDK 1.8 服务..."
                rpm -qa | grep java | xargs rpm -e --nodeps
                echo "JDK 1.8 服务已卸载"
                ;;
            n|N )
                echo "取消卸载 JDK 1.8 服务"
                exit 1
                ;;
            * )
                echo "无效的输入，取消卸载 JDK 1.8 服务"
                exit 1
                ;;
        esac
    fi
}

# 检查JDK压缩包是否被解压
installJDK() {
    
    
    if [ ! -e $jdkFile ]; then
        echo "JDK tar包不存在！！！"
        exit 1
    fi
    cd $installPath
    mkdir jdk-11.0.19
    tar -xzvf $jdkFile -C $installPath --strip-components 1
}


# 配置Java环境变量
configureJDK() {
    
    
    echo "export JAVA_HOME=$installPath" >> /etc/profile
    echo "export PATH=\$PATH:\$JAVA_HOME/bin" >> /etc/profile
    echo "export CLASSPATH=.:\$JAVA_HOME/jre/lib/rt.jar:\$JAVA_HOME/lib/dt.jar:\$JAVA_HOME/lib/tools.jar" >> /etc/profile
    echo "export CLASSPATH=\$JAVA_HOME/lib/" >> /etc/profile
    source /etc/profile
}


# 主函数
main() {
    
    
    # 检查是否有root权限运行此脚本
    CheckRoot

    # 检查服务是否正在运行
    checkServiceRunning

    # 安装 JDK
    installJDK

    # 配置环境变量
    configureJDK

    # 检查JDK版本
    java -version

    echo -e "\e[32m JDK 11 安装完成！ \e[0m"
}

# 执行主函数
main

四、Minio的配置安装

1、cd 到相应目录，执行：

cd /usr/local/minio

2、赋予执行的权限，执行：

# 赋予脚本执行的权限
chmod +x minio_install.sh
# 查看权限组
ll

3、执行：

./minio_install\(8.0\).sh

稍作等待程序安装配置，出现如下图即为安装成功：

4、查看状态，执行：

systemctl status minio.service

如下图：

图中红圈内容为Minio的后台访问地址，第一行中9000为固定端口，第二行为动态端口，若在初始化之前需修改端口，使用“vim minio_install.sh”（按i进入编辑状态，修改脚本中ConfigureMinio()的方法）；若运行之后修改端口，则使用“vim /etc/default/minio/minioEnv”，修改端口，接着使用“systemctl restart minio.service”，重启之后查看状态“systemctl status minio.service”

# 编辑脚本内容
vim minio_install.sh
# 编辑minio的运行环境
vim /etc/default/minio/minioEnv
# 重启minio服务
systemctl restart minio.service

此外在执行脚本之前，需要改账号密码的，使用Shell连接工具编辑minio_install.sh脚本，找到accessKey和secretKey，修改即可。
Minio的具体脚本内容：

#!/bin/bash 
### Minio 安装启动脚本 
 
# Minio 安装包路径
tarPath=/usr/local/
rpmPath=/usr/local/minio/
tarVerion=-20230518000536.0.0.x86_64
tarFile=minio${tarVerion}.rpm

# Minio 安装路径 
installPath=/usr/local/minio/ 
 
# Minio 配置文件路径 
configPath=/etc/default/minio/
 
# Minio Access Key 
accessKey=minioAdmin
 
# Minio Secret Key 
secretKey=minioAdmin
 
# Minio 端口号 
minioPort=9000
 
# Minio 日志路径 
logPath=/var/log/minio.log 

# Minio 数据存储路径 
dataPath=${installPath}/data

# Minio 服务名称 
serviceName=minio.service

# 设置 MINIO_VOLUMES 变量的值
MINIO_VOLUMES="/usr/local/minio/data"

# 判断服务是否存在
checkServiceRunning() {
    
    
    if [[ -n $(netstat -tlunp | grep -w $minioPort) || -n $(ps -ef | grep minio | grep -v grep) || -n $(systemctl status minio 2>/dev/null) ]]; then
        echo -e "\e[31m Minio服务已经存在! \e[0m"
        exit 1
    fi
}


# 添加执行权限、创建用户组
AssignMinio() {
    
    
    mkdir /mnt/data                     # 创建数据磁盘目录
    mkdir /usr/local/minio/data         # 创建数据卷
    chmod 770 /usr/local/minio/data     # 添加执行权限
    
    groupadd minio-user                 # 创建 minio-user 用户组
    useradd -g minio-user minio-user    # 创建 minio-user 用户并加入 minio-user 用户组
    cat /etc/group                      # 显示/etc/group文件内容，可验证用户组是否创建成功
    cat /etc/passwd                     # 显示/etc/passwd文件内容，可验证用户是否创建成功
    chown -R minio-user:minio-user ${MINIO_VOLUMES}   # 设置 /usr/local/minio/data 目录的所有者为 minio-user 用户及所属组
}
 
# 检查是否为 root 用户 
CheckRoot() {
    
     
    if [ $(id -u) != "0" ]; then 
        echo -e "\e[31m 当前不是 root 用户，禁止操作 \e[0m" 
        exit 1 
    fi 
} 
 
# 创建 Minio 配置文件目录 
CreateConfigDir() {
    
     
    if [ ! -d $configPath ]; then 
        mkdir -p $configPath 
    fi 
} 
 
# 创建 Minio 数据存储目录 
CreateDataDir() {
    
     
    if [ ! -d $dataPath ]; then 
        mkdir -p $dataPath 
    fi 
} 
 
# 安装 Minio
InstallMinio() {
    
    
    if [ ! -e $tarFile ]; then
        echo "Minio rpm package不存在！！！"
        exit 1
    fi
    rpm -ivh $tarFile
    if [ $? -ne 0 ]; then
        echo "Minio 安装失败！！！"
        exit 1
    fi
}
 
# 配置 Minio 
ConfigureMinio() {
    
     
    cat << EOF > ${configPath}/minioEnv
#######
MINIO_ROOT_USER="${accessKey}"
MINIO_ROOT_PASSWORD="${secretKey}"
MINIO_VOLUMES="/usr/local/minio/data"
MINIO_OPTS="--console-address :9999 --address 0.0.0.0:9000"
######
EOF
}

# 创建 Minio 服务 
CreateMinioService() {
    
     
    cat << EOF > /etc/systemd/system/$serviceName
######
[Unit] 
Description=Minio 
Documentation=https://docs.min.io
Wants=network-online.target 
After=network-online.target 
AssertFileIsExecutable=/usr/local/bin/minio
 
[Service]
WorkingDirectory=/usr/local/minio

User=minio-user
Group=minio-user
PermissionsStartOnly=true

EnvironmentFile=/etc/default/minio/minioEnv

ExecStartPre=/bin/bash -c "if [ -n \"${MINIO_VOLUMES}\" ]; then echo \"Variable MINIO_VOLUMES not set in /etc/default/minio/minioENV"; exit 1; fi"
ExecStart=/usr/local/bin/minio server /usr/local/minio/data

StandardOutput=journal
StandardError=inherit

# Specifies the maximum file descriptor number that can be opened by this process*
LimitNOFILE=65536
# Disable timeout logic and wait until process is stopped*
TimeoutStopSec=0
# SIGTERM signal is used to stop Minio*
KillSignal=SIGTERM
SendSIGKILL=no
SuccessExitStatus=0
 
[Install] 
WantedBy=multi-user.target

######
EOF
} 
 
# 启动 Minio 服务 
StartMinioService() {
    
     
    systemctl daemon-reload
    systemctl enable $serviceName
    systemctl start $serviceName
    systemctl restart $serviceName
    systemctl status $serviceName
} 
 
# 主函数 
main() {
    
     
    # 检查是否为 root 用户 
    CheckRoot

    # 添加执行权限
    AssignMinio
 
    # 创建 Minio 配置文件目录 
    CreateConfigDir 
 
    # 创建 Minio 数据存储目录 
    CreateDataDir 
 
    # 安装 Minio 
    InstallMinio 
 
    # 配置 Minio 
    ConfigureMinio 
 
    # 创建 Minio 服务 
    CreateMinioService 
 
    # 启动 Minio 服务 
    StartMinioService 
 
    echo -e "\e[32m Minio 安装完成 \e[0m" 
} 
 
# 执行主函数
main

五、安装gcc环境

1、cd 到相应目录，执行：

cd /usr/local/gcc

2、查看是否有gcc的环境，没有gcc的环境，如下图：

3、安装gcc环境，执行：rpm -ivh *.rpm --nodeps --force，如下图：

4、查看gcc版本及环境，执行：gcc -v

六、Redis的配置安装脚本

1、cd 到相应目录，执行：

cd /usr/local/redis

2、赋予执行的权限，执行：

chmod +x redis_install.sh

3、执行：./redis_install(8.0).sh，稍作等待程序安装配置，当脚本执行完成后会自动重启，重新连接服务器即可，重新连接进入服务器命令控制台后，执行：systemctl status redis.service，查看redis运行状态，如下即为安装启动成功。

具体脚本内容如下：

#!/bin/bash

# Redis 安装路径
installPath=/usr/local/redis/

# Redis 压缩包路径
tarPath=/usr/local/redis/redis-6.2.13.tar.gz

# 检查是否为 root 用户
checkRoot() {
    
    
    if [ "$(id -u)" != "0" ]; then
        echo -e "\e[31m 当前不是 root 用户，禁止操作 \e[0m" 
        exit 1
    fi
}

# 解压 Redis 压缩包
extractRedis() {
    
    
    echo "解压Redis压缩包中..."
    mkdir -p $installPath
    tar -xvzf $tarPath -C $installPath
    echo "Redis压缩包解压完成！！！"
}

# 编译和安装 Redis
compileAndInstallRedis() {
    
    
    echo "Compiling and installing Redis..."
    cd ${installPath}/redis-6.2.13
    make
    sleep 10s
    make install PREFIX=/usr/local/redis
    echo "Redis安装完成！！！"
}


# 配置 Redis 为后台运行
configureRedis() {
    
    
    echo "Configuring Redis..."
    # 配置Redis环境变量
    echo "export PATH=$PATH:/usr/local/redis/bin" >> /etc/profile
    # 设置环境变量生效
    source /etc/profile
    cp ${installPath}/redis-6.2.13/redis.conf /usr/local/redis/bin

    cd /usr/local/redis/bin
    # sed -i 's/^daemonize no$/daemonize yes/' redis.conf
    sed -i 's/bind 127.0.0.1/# bind 127.0.0.1/g' redis.conf
    sed -i 's/daemonize no/daemonize yes/g' redis.conf
    sed -i 's/protected-mode yes/protected-mode no/g' redis.conf


    # 创建并编辑redis.service文件
cat > /usr/lib/systemd/system/redis.service << EOF
[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
EOF

    echo "Redis 配置完成！！！"
}

# 启动 Redis 服务
startRedis() {
    
    
    echo "启动Redis服务中...."
    cd /usr/local/redis/bin
    ./redis-server redis.conf
    echo "Redis服务启动完成"
}

# 设置 Redis 服务开机自启
enableRedisOnStartup() {
    
    
    echo "Redis服务配置开机自启中...."
    cp /usr/local/redis/redis-6.2.13/redis_init_script /etc/init.d/redis
    sed -i "s@^REDISPORT=.*@REDISPORT=6379@" /etc/init.d/redis
    sed -i "s@^REDISCONF=.*@REDISCONF=${installPath}bin/redis.conf@" /etc/init.d/redis
    chmod +x /etc/init.d/redis
    chkconfig --add redis
    chkconfig redis on
    echo "Redis服务开机自启服务配置完成！！！"
}

# 主函数
main() {
    
    
    # 检查是否为 root 用户
    checkRoot

    # 解压 Redis 压缩包
    extractRedis

    # 编译和安装 Redis
    compileAndInstallRedis

    # 配置 Redis 为后台运行
    configureRedis

    # 启动 Redis 服务
    startRedis

    # 设置 Redis 服务开机自启
    enableRedisOnStartup

    echo "Redis 安装且配置完成!!!"

    sleep 3

    echo -e "\e[32m CentOS7系统即将重启，加载Redis配置...... \e[0m"

    reboot
}

# 执行主函数
main

Redis配置安装脚本2，脚本内容如下：

#!/bin/bash


# 进入redis安装目录
cd /usr/local/redis

# 解压Redis源代码
tar -xvf redis-6.2.13.tar.gz -C /usr/local/redis

# 进入解压后的源代码目录
cd redis-6.2.13

# 编译Redis
make

sleep 40

# 指定安装目录并进行安装
make install PREFIX=/usr/local/redis

sleep 10

# 拷贝配置文件到bin目录
cp /usr/local/redis/redis-6.2.13/redis.conf /usr/local/redis/bin

# 进入bin目录
cd /usr/local/redis/bin/

# 修改配置文件
sed -i 's/bind 127.0.0.1/# bind 127.0.0.1/g' redis.conf
sed -i 's/daemonize no/daemonize yes/g' redis.conf
sed -i 's/protected-mode yes/protected-mode no/g' redis.conf

# 创建并编辑redis.service文件
cat > /usr/lib/systemd/system/redis.service << EOF
[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
EOF

# 启动Redis服务
./redis-server redis.conf

# 等待Redis启动
sleep 5

# 查看进程
ps -ef | grep redis

# 开机自动启动
systemctl enable redis.service

# 启动redis服务
systemctl start redis.service

# 查看服务状态
systemctl status redis.service

reboot