@

• 1.系统版本
• 2.已安装软件
  • (1)常规方式安装的软件
  • (2)docker安装的软件
  • 注意
• 3.修改IP步骤
• 4.Tips
  • 1.防火墙
  • 2.设置jar包开机自启动
    • 方式一（强烈推荐）：service形式
    • 方式二：sh形式
    • 多服务同时启动/关闭
  • 3.编辑文件
  • 4.开机免密登录root
  • 5.设置禁止自动锁屏
  • 6.安装搜狗输入法
  • 7.环境变量配置汇总
  • 8.Docker常用命令
  • 9.升级系统内核
  • 10.Linux查看系统信息命令
  • 11.其他命令
• 5.常规方式安装软件和启动步骤
  • 1.JDK8
  • 2.Maven
  • 3.Tomcat
  • 4.MySQL
  • 5.Redis
  • 6.Zookeeper
  • 7.Kafka
  • 8.nginx
  • 9.Nacos
  • 10.Docker
  • 11.ElasticSearch
  • 12.Elasticsearch-head
  • 13.Kibana
  • 14.Node
  • 15.RocketMQ
  • 16.Grunt
  • 17.OpenResty
  • 18.Python
  • 19.MQTT
• 6.Docker安装软件和启动步骤
  • 1.MySQL
  • 2.Tomcat
  • 3.Redis
  • 4.nginx
  • 5.RocketMQ
    • （1）普通方式
    • （2）docker-compose方式
  • 6.Kafka和Zookeeper
  • 7.ElasticSearch
  • 8.Kibana
  • 9.Nacos
  • 10.Canal
  • 11.MQTT
• 未完待续~~~~

1.系统版本

环境版本：CentOS Linux release 7.9.2009 (Core)，含GNOME桌面。

安装包：CentOS-7-x86_64-DVD-1810.iso

系统内核版本(默认使用第一个)：

• CentOS Linux (5.4.254-1.e17.elrepo.x86_64) 7 (Core)
• CentOS Linux (3.10.0-1160.99.1.e17.x86_64) 7 (Core)
• CentOS Linux (0-rescue-8bb4fc8e956549ef89b281acc8ac2dda) 7 (Core)

硬件参数配置：2核/4G内存/40G存储/1网卡

账户密码：

• 超级管理员：root / root
• 普通用户： test/ test

默认IP：192.168.231.130

2.已安装软件

(1)常规方式安装的软件

所有的软件都在/usr/local/develop目录下, 内部都保留了安装包
对于已经配置了环境变量path的，在任意位置都可以执行命令，不需要去特定的目录下

(2)docker安装的软件

所有容器的主机映射都挂载在/usr/local/develop/docker-app目录下

注意

1. 所有软件都是root账户安装的，操作的时候请使用root用户
2. 本虚拟机默认IP地址是：192.168.231.130。需要将IP修改为192.168.你的VMNet8网段.130才能正常通讯，修改步骤如下：

3.修改IP步骤

0. 确认VMNet8网卡网段

   打开VMWare，点编辑菜单下的虚拟网络编辑器，在弹出的窗口中选择VMNet8，查询窗口左下角的子网IP中第三段，即为我们需要的网卡网段

   获取root权限

   su root
   # 输入root密码，输入的时候没有任何提示，输入完回车就可以了。
   

1. 修改网卡配置文件

   vi /etc/sysconfig/network-scripts/ifcfg-ens33
   

2. 修改文件内容

   快捷键dd可以删一行，多次按键删除所有内容；

   按i<小写>进入插入模式，把下面的内容粘贴

   注意：网段改成你自己VMNet8的，改两个地方

   TYPE=Ethernet
   PROXY_METHOD=none
   BROWSER_ONLY=no
   BOOTPROTO=static
   IPADDR=192.168.你的VMNet8网卡网段.130	 #ip地址
   NETMASK=255.255.255.0		        #子网掩码
   GATEWAY=192.168.你的VMNet8网卡网段.2   #网关
   DNS1=119.29.29.29 			        #dns服务器1
   DNS2=114.114.114.114 		        #dns服务器2
   DEFROUTE=yes
   IPV4_FAILURE_FATAL=no
   IPV6INIT=yes
   IPV6_AUTOCONF=yes
   IPV6_DEFROUTE=yes
   IPV6_FAILURE_FATAL=no
   IPV6_ADDR_GEN_MODE=stable-privacy
   NAME=ens33
   UUID=2c2371f5-ef29-4513-a468-c4904bd11c82
   DEVICE=ens33
   ONBOOT=yes
   

   改完后，按Esc ，再shift+分号，再输入wq保存退出<分号要是英文状态下的，中文无效>

3. 重启网络服务

   systemctl restart network
   

4. 查看IP是否修改成功

   ifconfig
   

5. ping宿主机网络网关/网卡地址（百度），验证网络是否联通

   ping 192.168.你的宿主机网段.1
   ping 你的宿主机IP
   

4.Tips

1.防火墙

1.CentOS：
#开放防火墙 9876 和 10911 端口
firewall-cmd --zone=public --add-port=9876/tcp --permanent
#删除开放的端口号命令
firewall-cmd --zone=public --remove-port=10911/tcp --permanent
#更新防火墙规则（无需断开连接，动态添加规则）
firewall-cmd --reload
#查看防火墙所有开放的端口
firewall-cmd --list-port
#临时关闭防火墙
systemctl stop firewalld
#禁止开机启动
systemctl disable firewalld
#查看firewall的状态
systemctl status firewalld

2.Ubuntu:
#删除指定端口的规则：
sudo ufw delete allow <port_number>
例如，要删除允许的端口 80 的规则：
sudo ufw delete allow 80
#删除指定规则：
sudo ufw delete <rule>
例如，要删除允许所有 ICMP 流量的规则：
sudo ufw delete allow icmp
#删除指定规则及端口：
#如果你想删除一条特定的规则，可以先列出当前的规则并找到规则的编号，然后使用 delete 命令删除它。比如，列出规则：
sudo ufw status numbered
#找到要删除的规则的编号，然后使用 delete 命令删除它：
sudo ufw delete <rule_number>
例如：sudo ufw delete 3

2.设置jar包开机自启动

方式一（强烈推荐）：service形式

#在Linux系统中，每个service都需要一个对应的service文件，保存在“/etc/systemd/system”目录中。可以在该目录下创建一个新的service文件，比如“runtest.service”。

#1.创建service文件
cd /etc/systemd/system
vim xxx.service
#2.添加下面的配置
[Unit]
##表示对该服务的描述
Description=test
##指定该服务应在哪些其他服务启动之后启动
After=syslog.target network.target
[Service]
##工作目录
WorkingDirectory=/usr/local/develop/project
##jdk路径以及启动jar文件命令
ExecStart=/usr/local/develop/jdk8/jdk1.8.0_231/bin/java -jar /usr/local/develop/project/xxx.jar
##指定服务运行的用户和组，可以不指定
#User=root
#Group=root
SuccessExitStatus=143
TimeoutStopSec=10
##服务在故障后是否自动重启，on-failure，表示任何意外的失败，就将重启
Restart=on-failure
##表示 Systemd 重启服务之前，需要等待的秒数
RestartSec=5
[Install]
##指定服务应在哪个target中启动
WantedBy=multi-user.target
#3.启动程序
systemctl start xxx.service
#4.查看状态
systemctl status xxx.service
#5.添加到自启动
systemctl enable xxx.service
#6.重新加载系统管理守护进程 (systemd) 的配置文件
systemctl daemon-reload

此方法用于创建服务，可以使脚本在Linux系统开机后自动运行，但不依托于/etc/rc.d/rc.local 文件

方式二：sh形式

#1.新建启动JAR包的sh文件,此sh文件，命名为startup.sh
touch startup.sh
vim startup.sh
#添加配置，用你的项目名称代替XXX
nohup java -jar xxx.jar > xxx.log  &
#2.编辑文件
vim /etc/rc.d/rc.local
#添加配置
cd /usr/local/develop
sh /usr/local/develop/startup.sh
##说明
第一句为进入你项目所在的目录，我这里把项目放在/usr/local/develop下
第二句执行该目录下的sh文件
如果不提前进入所在目录，直接执行第二句，也会开机自启动，但是日志文件会在根目录下的log文件中。只有先进入，再执行，项目的日志文件才会在develop文件夹下
#develop下文件中有jar包、startup.sh、以及jar包的日志文件logs
#3.设置执行权限
chmod +x /etc/rc.d/rc.local
chmod +x /usr/local/develop/startup.sh
#4.执行命令：reboot，重启服务器
#5.重启后执行命令查看jar包是否自启动成功。
ps -ef |grep jar

多服务同时启动/关闭

#1.编写启动脚本
sudo vim start_xxx_service.sh
#2.将下面的配置粘贴进去
```bash
#!/bin/bash
# 列出所有符合条件(XXX-*.service)的服务 $1代表第一列
services=$(systemctl list-unit-files | grep '^XXX-.*\.service' | awk '{print $1}')
# 启动/关闭每个服务 start/stop
for service in $services; do
	# 检查服务状态
	# --quiet选项确保systemctl只返回状态而不输出任何内容。如果服务未运行，systemctl is-active --quiet将返回非零状态码，因此!运算符表示条件为真。
    if !systemctl is-active --quiet $service; then
        # 如果服务未运行，则启动它
        sudo systemctl start $service
    fi
done
```
#3.设置执行权限
sudo chmod +x start_xxx_service.sh
#4.启动
./start_xxx_service.sh

3.编辑文件

#删除文件：
sudo rm 文件名
sudo rmdir 文件夹名
sudo rm -rf * 删除当前目录下所有文件
#编辑文件：
vim 文件名
#创建文件：
vi 文件名      //创建并进入该文件
touch 文件名   //只是单纯创建，不进入该文件

#linux编辑文件后如何保存退出？
第一步：按ESC(电脑左上角的键)进入Command模式
第二步：输入 :wq (一定要是英文的)
第三步：按下回车键即可保存并退出。
补充：vi编辑时，保存文件过程中，第二步中，冒号后不同的输入对应不同的命令
wq（保存文件并退出）
w（保存文件但不退出）
q（直接退出而不保存文件）
w 文件名（将该文件另存，输入w，空格后输入即为新的文件名）

#修改配置文件只读而无法修改：
sudo chmod 777 文件名    //在文件的所在目录下 执行该命令
sudo chmod 644 文件名    //完成之后要将权限修改回来，否则配置文件不生效

4.开机免密登录root

#该设置针对的是Centos
#1.修改/etc/gdm/custom.conf文件
vim /etc/gdm/custom.conf 
#2.在[daemon]下增加
AutomaticLoginEnable=true 
AutomaticLogin=root
#3.重启虚拟机
reboot

5.设置禁止自动锁屏

几分钟不用Centos，系统就自动锁屏了，这是一种安全措施。但对于大部分人而言，这是没有必要的，每次锁屏后重新解锁非常浪费时间。

解决办法：
（1）打开系统设置，找到“Power” 和"privacy"
（2）根据提示可以设置屏幕关闭和锁屏时间，设置选项“关闭”和“从不”即可搞定。

这样设置后屏幕就不会自动关闭和自动锁屏了。

6.安装搜狗输入法

#创建安装目录,并上传安装包
cd /usr/local/develop
mkdir sogoupinyin
cd sogoupinyin
#1、切换root权限。
su root
#2、更新yum，更新比较耗时，不更新没试行不，自行斟酌是否跳过这一步。
yum update
#3、卸载ibus。
rpm -e --nodeps ibus
#4、安装epel源。
#yum -y install epel-release
#5、安装fcitx。
yum -y install fcitx fcitx-configtool
#6、安装拼音输入法。
yum -y install fcitx-pinyin
#7、安装依赖包。
yum -y install dpkg
yum -y install qtwebkit
#8、下载搜狗输入法。
wget http://cdn2.ime.sogou.com/dl/index/1524572264/sogoupinyin_2.2.0.0108_amd64.deb
#9、安装alien。
yum -y install alien
#10、deb包 转 rpm包 (在deb包目录下或指定deb包目录)。
alien -r --scripts sogoupinyin_2.2.0.0108_amd64.deb
#11、安装转换的rpm包。
rpm -ivh --force sogoupinyin-2.2.0.0108-2.x86_64.rpm
#12、复制搜狗拼音库。
cp /usr/lib/x86_64-linux-gnu/fcitx/fcitx-sogoupinyin.so /usr/lib64/fcitx/
13、修改权限。
chown -R 776 /usr/share/fcitx-sogoupinyin/
#14、添加QT依赖。
yum install fcitx-qt5 fcitx-configtool -y
#15、配置修改/etc/profile。
vim /etc/profile 
//添加下列内容到文件末尾
export XIM_PROGRAM=fcitx
export GTK_IM_MODULE=fcitx
export QT_IM_MODULE=fcitx
export XMODIFIERS="@im=fcitx"
#16、弹出输入法配置框。
fcitx -r; fcitx-configtool
#17、添加开机自启动，依次点击左上角：应用程序->附件->优化->开机自启动，然后点击加号添加fcitx。
#18、reboot重启虚拟机。
#19、使用ctrl+space 快捷键 或 点击右上角键盘图标切换到搜狗输入法，安装完成。

7.环境变量配置汇总

##########################################环境变量配置################################################

#JDK8配置
export JAVA_HOME=/usr/local/develop/jdk8/jdk1.8.0_231
export PATH=${JAVA_HOME}/bin:$PATH
export CLASSPATH=.:${JAVA_HOME}/jre/lib/rt.jar:${JAVA_HOME}/lib/dt.jar:${JAVA_HOME}/lib/tools.jar

#MAVEN配置
export MAVEN_HOME=/usr/local/develop/maven/apache-maven-3.6.3
export PATH=$PATH:$MAVEN_HOME/bin

#Tomcat配置
export TOMCAT_HOME=/usr/local/develop/tomcat/apache-tomcat-9.0.29
export PATH=$PATH:$TOMCAT_HOME/bin

#Redis配置
export REDIS_HOME=/usr/local/develop/redis/redis-6.2.4
export PATH=$PATH:$REDIS_HOME/bin

#zookeeper配置
export ZOOKEEPER_HOME=/usr/local/develop/zookeeper/apache-zookeeper-3.5.6-bin
export PATH=$PATH:$ZOOKEEPER_HOME/bin
export ZK_LOG_DIR=/usr/local/develop/zookeeper/apache-zookeeper-3.5.6-bin/logs

#kafka配置
export KAFKA_HOME=/usr/local/develop/kafka/kafka_2.12-2.2.1
export PATH=$PATH:$KAFKA_HOME/bin

#nginx配置
#export NGINX_HOME=/usr/local/nginx
#export PATH=$PATH:$NGINX_HOME/sbin

#nodejs配置
export NODE_HOME=/usr/local/develop/nodejs/node-v12.13.1-linux-x64
export PATH=$PATH:$NODE_HOME/bin

#RocketMQ配置
export ROCKETMQ_HOME=/usr/local/develop/rocketmq/rocketmq-all-5.1.3-bin-release
export PATH=$PATH:$ROCKETMQ_HOME/bin
export NAMESRV_ADDR=127.0.0.1:9876

#openresty配置
export OPENRESTY_HOME=/usr/local/openresty/nginx
export PATH=${OPENRESTY_HOME}/sbin:$PATH

#elasticsearch配置
export ELASTICSEARCH_HOME=/usr/local/develop/elasticsearch/elasticsearch-7.4.0/
export PATH=:$PATH:${ELASTICSEARCH_HOME}/bin

#kibana配置
export KIBANA_HOME=/usr/local/develop/kibana/kibana-7.4.0-linux-x86_64
export PATH=:$PATH:${KIBANA_HOME}/bin

#搜狗输入法配置
export XIM_PROGRAM=fcitx
export GTK_IM_MODULE=fcitx
export QT_IM_MODULE=fcitx
export XMODIFIERS="@im=fcitx"

####################################################################################################

8.Docker常用命令

#通过命令启动docker：
systemctl start docker  # 启动docker服务
systemctl stop docker  # 停止docker服务
systemctl restart docker  # 重启docker服务
systemctl status docker  # 查看docker服务状态
systemctl enable docker  # docker自启动
#最终确认docker是否是自启动：
#输出为 enabled 则为自启动,输出为 disabled 则不是自启动
systemctl is-enabled docker

#查看docker版本：
docker -v
#删除容器的命令，删除前如果容器在运行中，要先停止
docker rm 容器名
#如果你不知道容器的名称，可以使用docker ps -a命令查看所有容器，其中包括其名称和ID。
docker ps -a
#查看正在运行的容器
docker ps
#进入容器的命令
docker exec -it 容器名称 /bin/bash
#运行容器
docker start 容器名称
#停止容器
docker stop 容器名称
#给容器重命名
docker rename 旧容器名 新容器名
--------------------------------------------------------------------------------------------------------------
#制作新的镜像(将docker中已经配置好的容器导出为新镜像)
docker commit 容器id 新镜像名称
#查看镜像的id
docker images
#导出镜像为tar格式的包
docker save 镜像id > /路径/xxx.tar
#加载镜像到docker中
docker load < xxx.tar
#给镜像重命名
docker tag 镜像id 新镜像名称:版本
--------------------------------------------------------------------------------------------------------------
#查看镜像：
docker images 或 docker image ls
#删除镜像：
docker rmi 镜像名或者镜像id
#查看卷：
docker volume ls
#查看容器详细信息，容器的ip
docker inspect 容器id/容器名称
#查看容器启动日志
docker logs 容器id/容器名称
--------------------------------------------------------------------------------------------------------------
#开启容器自启动
#在docker启动容器时可以增加参数
docker run –-restart=always
#容器已经启动,通过update命令进行修改
docker update –-restart=always <CONTAINER ID>
#关闭自启
#容器关闭自启动：
docker update --restart=no <CONTAINER ID>
#取消所有容器自启动
docker update --restart=no $(docker ps -q)
#容器是否是自启动：
#输出 always 或者 unless-stopped，说明该容器被配置为自启动。如果返回no，则说明容器没有被配置为自启动。
docker inspect --format '{{ .HostConfig.RestartPolicy.Name }}' <container_name_or_id>
--------------------------------------------------------------------------------------------------------------
#查看所有当前可用的Docker网络
docker network ls
#删除网络
docker network rm 网络名称
#查看所有未使用的网络并删除
docker network prune
#创建自定义网络（默认是桥接模式）
## 方式一
docker network create 网络名称
## 方式二：指定IP和网关
docker network create --subnet=172.10.0.0/16 --gateway=172.10.0.1 网络名称
## 方式三：创建网络并绑定物理网卡，网络模式 macvlan bridge
docker network create -d macvlan  --subnet=172.16.86.0/24  --gateway=172.16.86.1  -o parent=eth0 网络名称
#解除容器绑定的网络
docker network disconnect 网络名称 容器名称
#为容器重新指定网络
docker network connect 网络名称 容器名称
#为容器重新指定网络和ip
docker network connect  网络名称 容器名称 --ip 192.168.252.10
--------------------------------------------------------------------------------------------------------------
#容器文件复制到本地目录
docker cp 容器名称:容器中的目录 本地目录的路径
例：docker cp tomcat:/usr/local/tomcat/conf /usr/local/develop/docker-app/tomcat
#容器文件映射到本地目录(挂载)
docker run -v 本地目录的路径:容器中的目录 容器名称或者容器id
例：docker run -v /usr/local/develop/docker-app/tomcat/conf:/usr/local/tomcat/conf tomcat
--------------------------------------------------------------------------------------------------------------

9.升级系统内核

#1.查看系统版本
cat /etc/redhat-release
#2.查看当前默认使用的内核版本
uname -r
#3.查看现有内核启动顺序
awk -F\' '$1=="menuentry " {print $2}' /etc/grub2.cfg
#4.更源仓库,时间会比较长一点。
yum -y update
#5.导入密钥
rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org
#6.安装yum源
rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-3.el7.elrepo.noarch.rpm
#7.查看可以安装的内核版本
yum --disablerepo="*" --enablerepo="elrepo-kernel" list available
#8.安装最新版内核
yum -y --enablerepo=elrepo-kernel install kernel-lt
#9.编辑grub文件，把GRUB_DEFAULT=saved改成GRUB_DEFAULT=0
vim /etc/default/grub
#或者，设置好新的内核启动项
grub2-set-default 0
#10.根据/etc/default/grub自动生成开机配置文件
grub2-mkconfig -o /boot/grub2/grub.cfg
#11.重启机器生效
reboot
#12.再次看看更新好了没
uname -r

10.Linux查看系统信息命令

#查看CPU的相关信息。
lscpu
#查看内存的使用情况，-h 参数是为了让信息更易读。
free -h
#查看磁盘的使用情况，-h 参数同样有用。
df -h
#查看块设备（例如磁盘和分区）。
lsblk
#查看磁盘分区表。
fdisk -l
#查看内核版本和系统架构。
uname -a
#查看系统的主机名和相关配置。
hostnamectl
#查看CentOS系统的版本信息。
cat /etc/*release
#查看详细的内存信息。
cat /proc/meminfo
#查看详细的CPU信息
cat /proc/cpuinfo

11.其他命令

#windows端口占用
#查看占用端口(9200)的pid
netstat -ano|findstr 8080
#杀死pid为18468的进程
taskkill /f /pid "18468"
#linux端口占用
#要查看特定端口的占用情况，例如查看端口 8080，可以使用：
sudo lsof -i :8080
#杀死PID为23612的进程，可以使用 kill 或 kill -9 命令，其中 -9 是一个更强制的终止信号
sudo kill 23612
sudo kill -9 23612
--------------------------------------------------------------------------------------------------------------
#java占用程序
ps -ef|grep java
#查看磁盘具体占用
df -h
#查看内存占用
free -h

5.常规方式安装软件和启动步骤

1.JDK8

#1.先卸载open-jdk
rpm -qa | grep java #查询openjdk对应的版本信息
rpm -e --nodeps java-1.7.0-openjdk-1.7.0.45-2.4.3.3.el6.x86_64 #逐个卸载，后面复制粘贴版本信息即可
#2.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir jdk8
cd jdk8
#3.解压安装包
tar -xzvf jdk-8u231-linux-x64.tar.gz -C /usr/local/develop/jdk8
#4.修改环境变量
vim /etc/profile 
复制到文件的最末尾：
export JAVA_HOME=/usr/local/develop/jdk8/jdk1.8.0_231
export PATH=${JAVA_HOME}/bin:$PATH
export CLASSPATH=.:${JAVA_HOME}/jre/lib/rt.jar:${JAVA_HOME}/lib/dt.jar:${JAVA_HOME}/lib/tools.jar
#5.刷新配置文件
source /etc/profile
#6.查看java版本信息
java -version

2.Maven

#1.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir maven
cd maven
#2.解压安装包
tar -xzvf apache-maven-3.6.3-bin.tar.gz -C /usr/local/develop/maven
#3.解压完毕以后，新建一个repository仓库，用于存放Maven下载下来的jar包
mkdir maven_local_repository
#4.编辑settings.xml文件
vi apache-maven-3.6.3/conf/settings.xml
#5.设置Maven仓库，就是我刚才新建的文件夹
<localRepository>/usr/local/develop/maven/maven_local_repository</localRepository>
#6.配置为阿里云镜像地址 
<mirror>
   <id>nexus-aliyun</id>
   <mirrorOf>central</mirrorOf>
   <name>Nexus aliyun</name>
   <url>https://maven.aliyun.com/repository/public</url>
</mirror>
#7.配置环境变量
vim /etc/profile
#添加下面的配置
export MAVEN_HOME=/usr/local/develop/maven/apache-maven-3.6.3
export PATH=$PATH:$MAVEN_HOME/bin
#8.运行以下命令使profile文件生效 
source /etc/profile
#9.检查环境配置是否成功
mvn -v

3.Tomcat

#1.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir tomcat
cd tomcat
#2.解压安装包
tar -xzvf apache-tomcat-9.0.29.tar.gz -C /usr/local/develop/tomcat
#3.配置环境path
vim /etc/profile
#添加下面的配置
#Tomcat配置
export TOMCAT_HOME=/usr/local/develop/tomcat/apache-tomcat-9.0.29
export PATH=$PATH:$TOMCAT_HOME/bin
#4.运行以下命令使profile文件生效 
source /etc/profile
#5.启动/关闭 Tomcat
tomcat 解压缩后就可以使用了，用 cd 命令切换到 tomcat 主目录下的 bin 目录
./startup.sh
./shutdown.sh
由于已经配置了环境变量了，在任意位置都可以执行命令
在浏览器中访问 tomcat，要关闭linux的防火墙

4.MySQL

#1.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir mysql
cd mysql
#2.解压安装包
tar -xvf mysql-5.7.27-1.el7.x86_64.rpm-bundle.tar -C /usr/local/develop/mysql
#3.安装客户端
rpm -ivh mysql-community-client-5.7.27-1.el7.x86_64.rpm --force --nodeps
#4.安装服务端
rpm -ivh mysql-community-server-5.7.27-1.el7.x86_64.rpm --force --nodeps
#5.修改mysql默认字符集
vi /etc/my.cnf
添加如下内容：
[mysqld]
character-set-server=utf8
collation-server=utf8_general_ci
-- 在文件最下方添加
[client]
default-character-set=utf8
#6.启动mysql服务，在Linux中MySQL安装好了之后系统会自动的注册一个服务，服务名称叫做mysqld，所以可以通过以下命令操作MySQL：
启动 MySQL 服务：systemctl start mysqld
重启 MySQL 服务：systemctl restart mysqld
关闭 MySQL 服务：systemctl stop mysqld
#7.登录mysql，rpm安装MySQL会自动生成一个随机密码，可在/var/log/mysqld.log这个文件中查找该密码
查看初始密码：cat /var/log/mysqld.log
mysql -u root -p （密码  敲回车）
密码类似ohHmyrmQE1!D
在A temporay password is generated for root@localhost: ****密码**** ;root@localhost:后面的就是初始密码
#8.修改mysql登录密码
set global validate_password_policy=0;
set global validate_password_length=1;
set password=password('密码');
#9.授予远程连接权限
//授权
grant all privileges on *.* to 'root' @'%' identified by '密码';
//刷新
flush privileges;
#10.关闭Linux系统防火墙
systemctl stop firewalld
systemctl disable firewalld
#11.重启mysql服务
systemctl restart mysqld
#12.使用navicat工具连接mysql

修改全局时区设置可能需要数据库服务器重启才能生效：
-- 查看当前时区设置
SELECT @@global.time_zone, @@session.time_zone;
-- 修改时区设置为 '+08:00'，表示东八区
SET GLOBAL time_zone = '+08:00';
SET time_zone = '+08:00';

5.Redis

(1)安装

#1.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir redis
cd redis
#2.解压安装包
tar -xzvf redis-6.2.4.tar.gz -C /usr/local/develop/redis
#3.redis是c语言开发，安装redis需要先将官网下载的源码进行编译，编译依赖gcc环境，如果没有gcc环境，需要安装gcc,需要输入以下命令
yum install gcc
#4.进入redis-6.2.4,使用make命令进行编译将.c文件编译成.o文件
cd redis-6.2.4
make
编译成功之后会出现“It's a good idea to run 'make test'”的提示
#5.使用命令 进行安装 
make PREFIX=/usr/local/develop/redis/redis-6.2.4 install
安装完成会出现一个bin目录，里面的结构如下：
redis-benchmark   ----性能测试工具
redis-check-aof   ----AOF文件修复工具
redis-check-rdb   ----RDB文件检查工具（快照持久化文件）
redis-cli         ----命令行客户端
redis-sentinel    ----哨兵
redis-server      ----redis服务器启动命令
#6.修改配置文件
cd /usr/local/develop/redis/redis-6.2.4
vim redis.conf
进入后使用编辑模式进行修改以下部分
将bind 127.0.0.1 -::1 替换为bind  0.0.0.0
将 daemonize on  替换成  daemonize yes

(2)启动

cd /usr/local/develop/redis/redis-6.2.4
如果输入以下第一个命令无法启动  提示./redis.conf没有权限  在输入命令这个命令即可
chmod 777 redis.conf
#启动redis服务 
bin/redis-server ./redis.conf
#查看已经启动的redis服务关闭redis服务
ps -ef|grep redis
#redis的客户端
bin/redis-cli

#关闭redis命令,需要先退出redis客户端
#退出redis客户端
exit
#关闭redis
bin/redis-cli shutdown
#查看关于redis 的进程
ps -ef|grep redis

6.Zookeeper

(1)安装

#1.环境准备
ZooKeeper服务器是用Java创建的，必须安装jdk
#2.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir zookeeper
cd zookeeper
#3.解压安装包
tar -xzvf apache-zookeeper-3.5.6-bin.tar.gz -C /usr/local/develop/zookeeper
#4.配置zoo.cfg
#进入到conf目录
cd /usr/local/develop/zookeeper/apache-zookeeper-3.5.6-bin/conf
#拷贝
cp zoo_sample.cfg zoo.cfg
#创建zooKeeper存储目录
cd /usr/local/develop/zookeeper/apache-zookeeper-3.5.6-bin/logs
mkdir zkData
#修改zoo.cfg
vim /usr/local/develop/zookeeper/apache-zookeeper-3.5.6-bin/conf/zoo.cfg
#进入修改页面后修改dataDir=/usr/local/develop/zookeeper/apache-zookeeper-3.5.6-bin/logs/zkData
#5.设置环境变量
vim /etc/profile 
#zookeeper配置
export ZOOKEEPER_HOME=/usr/local/develop/zookeeper/apache-zookeeper-3.5.6-bin
export PATH=$PATH:$ZOOKEEPER_HOME/bin
export ZK_LOG_DIR=/usr/local/develop/zookeeper/apache-zookeeper-3.5.6-bin/logs
#6.使配置生效：
source /etc/profile

(2)启动

cd /usr/local/develop/zookeeper/apache-zookeeper-3.5.6-bin/bin
#启动
./zkServer.sh start
#关闭
./zkServer.sh stop
#查看ZooKeeper状态
./zkServer.sh status

7.Kafka

(1)安装

#1.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir kafka
cd kafka
#2.解压安装包
tar -xzvf kafka_2.12-2.2.1.tgz -C /usr/local/develop/kafka
#3.配置环境变量
vim /etc/profile 
#kafka配置
export KAFKA_HOME=/usr/local/develop/kafka/kafka_2.12-2.2.1
export PATH=$PATH:$KAFKA_HOME/bin
#4.使配置生效：
source /etc/profile
5.配置config中的server.properties文件
cd /usr/local/develop/kafka/kafka_2.12-2.2.1/config
vim server.properties
#broker.id属性在kafka集群中必须要是唯⼀
broker.id=0
#kafka部署的机器ip和提供服务的端⼝号
listeners=PLAINTEXT://192.168.231.130:9092 
#kafka的消息存储⽂件
log.dir=/usr/local/develop/kafka/kafka_2.12-2.2.1/logs/kafka-logs
#kafka连接zookeeper的地址
zookeeper.connect=192.168.231.130:2181

#另外：
kafka安装包内集成的有zookeeper，其实不用单独安装zookeeper。kafka在2.8之后就可以不用zookeeper来管理节点了
#配置zookeeper:
cd /usr/local/develop/kafka/kafka_2.12-2.2.1/config
vim zookeeper.properties
dataDir=/usr/local/develop/kafka/kafka_2.12-2.2.1/logs/zookeeper-logs

(2)启动

#启动
#先启动zookeeper，再启动kafka
cd /usr/local/develop/kafka/kafka_2.12-2.2.1/bin
zookeeper-server-start.sh ../config/zookeeper.properties
kafka-server-start.sh ../config/server.properties
#查看kafka进程
ps -ef | grep kafka
#停止后台运行
kafka-server-stop.sh
#验证kafka是否可以正常使用 ,运行kafka生产者发送消息
kafka-console-producer.sh --topic topic_1 --broker-list localhost:9092
#另打开窗口消费者消费消息
kafka-console-consumer.sh --bootstrap-server localhost:9092 - -topic topic_1 --from-beginning

注意:
Java或者kafka_tool连接不上虚拟机的kafka解决方法：
首先，关闭防火墙
其次在config/server.properties的配置文件中，要把这两行注释打开
listeners=PLAINTEXT://:9092
advertised.listeners=PLAINTEXT://192.168.231.129:9092

8.nginx

(1)安装

#1.安装nginx依赖
#安装gcc
yum install gcc-c++
#安装PCRE pcre-devel
yum install -y pcre pcre-devel
#安装zlib
yum install -y zlib zlib-devel
#安装Open SSL
yum install -y openssl openssl-devel
#2.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir nginx
cd nginx
#3.解压安装包
tar -xzvf nginx-1.18.0.tar.gz -C /usr/local/develop/nginx
#编译 执行命令 考虑到后续安装ssl证书 添加两个模块  如不需要直接执行./configure即可
cd nginx-1.18.0
./configure --with-http_stub_status_module --with-http_ssl_module
#执行make命令(要是执行不成功请检查最开始安装的四个依赖有没有安装成功)
make
#执行make install命令
make install

(2)启动

执行完上面的所有命令后，会在/usr/local目录下生成一个nginx文件夹
cd /usr/local/nginx/sbin
#配置环境
vim /etc/profile 
#nginx配置
export NGINX_HOME=/usr/local/nginx
export PATH=$PATH:$NGINX_HOME/sbin
#使配置生效：
source /etc/profile

# 默认配置文件启动
./nginx
# 指定配置文件启动
./nginx -c  /usr/local/nginx/conf/nginx.conf
cd /usr/local/nginx/sbin
# 停止指令
./nginx -s stop
# 或
./nginx -s quit
# 重启命令
./nginx -s reload
# 查看nginx进程
ps -ef|grep nginx

#设置开机自启动nginx
#编辑
vim /etc/rc.local
#最底部增加这一行
/usr/local/nginx/sbin/nginx
#若要修改监听端口，可打开nginx的配置文件进行修改。
# 打开配置文件
vi /usr/local/nginx/conf/nginx.conf

9.Nacos

#1.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir nacos
cd nacos
#2.解压安装包
tar -xzvf nacos-server-2.2.3.tar.gz -C /usr/local/develop/nacos
#3.启动
cd /usr/local/develop/nacos/nacos/bin
sh startup.sh -m standalone
#4.验证是否启动成功
#访问地址 默认账号密码是nacos/nacos
http://ip:8848/nacos
#关闭
sh shutdown.sh

#Nacos的默认端口是8848，如果你电脑上的其它进程占用了8848端口，请先尝试关闭该进程。
#如果无法关闭占用8848端口的进程，也可以进入nacos的conf目录，修改配置文件中的端口：
#进入nacos配置文件目录
cd /usr/local/develop/nacos/nacos/conf
#编辑nacos配置文件
vim application.properties

10.Docker

1.yum安装
#1.1如果之前安装过旧版本的Docker，可以使用下面命令卸载：
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine \
                  docker-ce
#1.2安装docker，需要虚拟机联网，安装yum工具
yum install -y yum-utils \
           device-mapper-persistent-data \
           lvm2 --skip-broken
#1.3然后更新本地镜像源：
# 设置docker镜像源
yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

yum makecache fast
#1.4然后输入命令：docker-ce为社区免费版本。稍等片刻，docker即可安装成功。
yum install -y docker-ce
#启动docker前，一定要关闭防火墙！！
# 关闭防火墙
systemctl stop firewalld
# 禁止开机启动防火墙
systemctl disable firewalld
#通过命令启动docker：
systemctl start docker  # 启动docker服务
systemctl stop docker  # 停止docker服务
systemctl restart docker  # 重启docker服务
systemctl status docker  # 查看docker服务状态
#然后输入命令，可以查看docker版本：
docker -v

2.rpm安装
https://download.docker.com/1inux/centos/7/x86_64/stable/Packages/
找到最新的rpm包，然后：
yum -y install docker-ce-20.10.19-3.el7.x86_64.rpm
运行docker：
systemctl start docker

3.二进制安装
https://download.docker.com/linux/static/stable/x86_64/
#3.1找到最新的包下载，然后解压：
tar -zxvf docker-20.10.3.tgz
#3.2进入解压目录，将docker相关命令拷贝到 /usr/bin：
cp docker/* /usr/bin/
#3.3将docker加入系统服务使用systemctl控制：
vim /etc/systemd/system/docker.service
#3.4添加下面的内容
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target
[Service]
Type=notify
ExecStart=/usr/bin/dockerd
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s
[Install]
WantedBy=multi-user.target
#3.5添加执行权限
chmod +x /etc/systemd/system/docker.service
#3.6重载配置文件
systemctl daemon-reload
#3.7运行docker：
systemctl start docker
#3.8添加自启动
systemctl enable docker.service

注意：

docker官方镜像仓库网速较差，我们需要设置国内镜像服务：

参考阿里云的镜像加速文档：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

11.ElasticSearch

(1)安装

#1.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir elasticsearch
cd elasticsearch
#2.解压安装包
tar -xzvf elasticsearch-7.4.0-linux-x86_64.tar.gz -C /usr/local/develop/elasticsearch
#3.创建普通用户(本linux中已经创建过了普通用户test，所以可以跳过此步骤)
#因为安全问题，Elasticsearch 不允许root用户直接运行，所以要创建新用户，在root用户中创建新用户,执行如下命令
useradd test# 新增test用户
passwd  test# 为test用户设置密码
#4.为新用户授权，如下图
chown -R test:test/usr/local/develop/elasticsearch/elasticsearch-7.4.0 #文件夹所有者
将/usr/local/develop/elasticsearch/elasticsearch-7.4.0文件夹授权给test用户，由下图可见，我们的文件夹权限赋给了test
#5.修改elasticsearch.yml文件
vim /usr/local/develop/elasticsearch/elasticsearch-7.4.0/config/elasticsearch.yml 
# ======================== Elasticsearch Configuration =========================
cluster.name: my-application
node.name: node-1
network.host: 0.0.0.0
http.port: 9200
cluster.initial_master_nodes: ["node-1"]
#cluster.name：配置elasticsearch的集群名称，默认是elasticsearch。建议修改成一个有意义的名称
#node.name：节点名，elasticsearch会默认随机指定一个名字，建议指定一个有意义的名称，方便管理
#network.host：设置为0.0.0.0允许外网访问
#http.port：Elasticsearch的http访问端口
#cluster.initial_master_nodes：初始化新的集群时需要此配置来选举master

#ES默认不开启跨域访问，需要添加以下配置：
#配置
#开启cors跨域访问支持，默认为false 
http.cors.enabled: true
#跨域访问允许的域名地址，(允许所有域名)以上使用正则
http.cors.allow-origin: "*"

#6.修改配置文件
# 切换到root用户
su root
#6.1. ===最大可创建文件数太小=======
vim /etc/security/limits.conf
# 在文件末尾中增加下面内容
test soft nofile 65536
test hard nofile 65536
# =====
vim /etc/security/limits.d/20-nproc.conf
# 在文件末尾中增加下面内容
test soft nofile 65536
test hard nofile 65536
*  hard    nproc     4096
# 注：* 代表Linux所有用户名称	
#6.2. ===最大虚拟内存太小=======
vim /etc/sysctl.conf
# 在文件中增加下面内容
vm.max_map_count=655360
# 重新加载，输入下面命令：
sysctl -p

(2)启动

su test  # 切换到test用户启动
cd /usr/local/develop/elasticsearch/elasticsearch-7.4.0/bin
./elasticsearch #启动
#在访问elasticsearch前，请确保防火墙是关闭的


#安装ik分词器!!!!!
cd /usr/local/develop/elasticsearch/elasticsearch-7.4.0/plugins/
#创建ik目录并进入
mkdir ik-7.10.0
cd ik-7.10.0
#上传安装包并解压，然后删除安装包
unzip elasticsearch-analysis-ik-7.10.0.zip
rm elasticsearch-analysis-ik-7.10.0.zip
#修改配置文件
vim plugin-descriptor.properties
# 修改下面的内容
elasticsearch.version=你的es的版本(本文中是7.4.0)

重点几个关注下即可:
number" : "7.4.0" 表示elasticsearch版本
lucene_version" : "8.2.0" 表示lucene版本
name ： 默认启动的时候指定了 ES 实例名称
cluster_name ： 默认名为 elasticsearch

12.Elasticsearch-head

下载地址：https://github.com/mobz/elasticsearch-head/releases

#1.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir elasticsearch-head
cd elasticsearch-head
#2.解压安装包
tar -xzvf elasticsearch-head-5.0.0.tar.gz -C /usr/local/develop/elasticsearch-head
#3.进入目录
cd elasticsearch-head-5.0.0
#在运行之前我们需要修改下elasticsearch.yml，因为ES默认不开启跨域访问，需要添加以下配置：
vim /usr/local/develop/elasticsearch/elasticsearch-7.4.0/config/elasticsearch.yml
#加入下面两个配置
#开启cors跨域访问支持，默认为false 
http.cors.enabled: true
#跨域访问允许的域名地址，(允许所有域名)以上使用正则
http.cors.allow-origin: "*"
#4.安装
npm install
#5.运行服务
npm run start
#或者后台启动
nohup npm run-script start &
#6.访问head
浏览器输入ip:port:9100，如下图

13.Kibana

#配合ElasticSearch使用
#1.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir kibana
cd kibana
#2.解压安装包
tar -xzvf kibana-7.4.0-linux-x86_64.tar.gz -C /usr/local/develop/kibana
#3.修改配置文件
vim /usr/local/develop/kibana/kibana-7.4.0-linux-x86_64/config/kibana.yml
# 在文件中修改下面内容
server.port: 5601
server.host: "0.0.0.0"
server.name: "kibana-itcast"
elasticsearch.hosts: ["http://127.0.0.1:9200"]
elasticsearch.requestTimeout: 99999
i18n.locale: "zh_CN"
#server.port：http访问端口
#server.host：ip地址，0.0.0.0表示可远程访问
#server.name：kibana服务名
#elasticsearch.hosts：elasticsearch地址
#elasticsearch.requestTimeout：请求elasticsearch超时时间，默认为30000，此处可根据情况设置
#i18n.locale: 汉化
#4、启动kibana
由于kibana不建议使用root用户启动，如果用root启动，需要加--allow-root参数
# 切换到kibana的bin目录
cd /usr/local/develop/kibana/kibana-7.4.0-linux-x86_64/bin
# 启动
./kibana --allow-root

14.Node

cd /usr/local
mkdir develop
cd develop
mkdir nodejs
cd nodejs
#1.执行wget命令下载Node
wget https://nodejs.org/dist/v12.13.1/node-v12.13.1-linux-x64.tar.xz
#2.解压
tar -xvf node-v12.13.1-linux-x64.tar.xz -C /usr/local/develop/nodejs
#3.设置软连接
#解压文件的 bin 目录底下包含了 node、npm 等命令，我们可以使用 ln 命令来设置软连接：
ln -s bin/npm /usr/local/develop/nodejs/node-v12.13.1-linux-x64/bin/
ln -s bin/node /usr/local/develop/nodejs/node-v12.13.1-linux-x64/bin/
#4.配置环境变量
vim /etc/profile
export NODE_HOME=/usr/local/develop/nodejs/node-v12.13.1-linux-x64
export PATH=$PATH:$NODE_HOME/bin
#5.运行以下命令使profile文件生效 
source /etc/profile
#6.查看版本信息
node -v

15.RocketMQ

(1)安装

#1.创建安装目录,并上传安装包
cd /usr/local
mkdir develop
cd develop
mkdir rocketmq
cd rocketmq
#2.解压安装包
unzip -d /usr/local/develop/rocketmq rocketmq-all-5.1.3-bin-release.zip
#如果没有安装 unzip，可以执行下面命令安装 
yum install -y unzip zip
#3.进入rocketmq安装目录
cd rocketmq-all-5.1.3-bin-release
#4.创建存放数据的目录
mkdir -p store store/commitlog store/consumequeue
#5.进入conf目录
cd conf
#6.编辑broker.conf文件
vi broker.conf
# 在broker.conf文件中追加下面内容
listenPort=10911
namesrvAddr=localhost:9876
storePathRootDir=/usr/local/develop/rocketmq/rocketmq-all-5.1.3-bin-release/store
storePathCommitLog=/usr/local/develop/rocketmq/rocketmq-all-5.1.3-bin-release/store/commitlog
storePathConsumerQueue=/usr/local/develop/rocketmq/rocketmq-all-5.1.3-bin-release/store/consumequeue
#7.修改内存大小（这步不是必须的，如果你的机器内存足够，可以跳过这步，笔者机器内存只有1g，因此需要修改内存大小）
#进入bin目录
cd /usr/local/develop/rocketmq/rocketmq-all-5.1.3-bin-release/bin
#编辑runbroker.sh文件和runserver.sh文件，修改内存大小
#编辑runbroker.sh文件，将 8g 修改为 512m
vi runbroker.sh
#编辑runserver.sh文件，都修改为 512m
vi runserver.sh
#8.配置环境变量
vim /etc/profile
export ROCKETMQ_HOME=/usr/local/develop/rocketmq/rocketmq-all-5.1.3-bin-release
export PATH=$PATH:$ROCKETMQ_HOME/bin
export NAMESRV_ADDR=127.0.0.1:9876
#运行以下命令使profile文件生效 
source /etc/profile
#9.开放防火墙 9876 和 10911 端口
firewall-cmd --zone=public --add-port=9876/tcp --permanent
firewall-cmd --zone=public --add-port=10911/tcp --permanent
#更新防火墙规则（无需断开连接，动态添加规则）
firewall-cmd --reload
#查看防火墙所有开放的端口
firewall-cmd --list-port

(2)启动

#在 bin 目录下，执行下面命令
nohup命令可以将程序以忽略挂起信号的方式运行起来，被运行的程序的输出信息将不会显示到终端。&>后面指定隐藏的启动信息输出到指定文件，如果不指定默认输出到当前目录的nohup.out
#1.启动nameserver,下面命令任选其一
nohup sh mqnamesrv &> namesrv-out.txt
sh mqnamesrv
#2.启动 broker,下面命令任选其一
nohup sh mqbroker -n localhost:9876 -c ../conf/broker.conf &> broker-out.txt
./mqbroker -n localhost:9876 -c ../conf/broker.conf
#启动过程中会在/root/logs/rocketmqlogs/产生日志文件
tail -f ~/logs/rocketmqlogs/broker.log

#测试发送消息
#使⽤bin/tools.sh⼯具验证消息的发送，默认会发1000条消息
./tools.sh org.apache.rocketmq.example.quickstart.Producer 
#使⽤bin/tools.sh⼯具验证消息的接收
./tools.sh org.apache.rocketmq.example.quickstart.Consumer 

#关闭
sh mqshutdown broker
sh mqshutdown namesrv

16.Grunt

#安装grunt（运行在Node.js上面的任务管理器（task runner）），为了获得Grunt的更多产品特性，需要全局安装Grunt's 命令行接口（CLI），使用npm进行安装，如下：
npm install -g grunt-cli
#查看grunt版本
grunt --version
输出grunt版本信息，表示安装成功。

17.OpenResty

# 1.安装
首先你的Linux虚拟机必须联网
# **1）安装开发库**
首先要安装OpenResty的依赖开发库，执行命令：
yum install -y pcre-devel openssl-devel gcc --skip-broken
# **2）安装OpenResty仓库**
#你可以在你的 CentOS 系统中添加 `openresty` 仓库，这样就可以便于未来安装或更新我们的软件包（通过 `yum check-update` 命令）。运行下面的命令就可以添加我们的仓库：
yum-config-manager --add-repo https://openresty.org/package/centos/openresty.repo
#如果提示说命令不存在，则运行：
yum install -y yum-utils 
#然后再重复上面的命令
# **3）安装OpenResty**
#然后就可以像下面这样安装软件包，比如 `openresty`：
yum install -y openresty
# **4）安装opm工具**
#opm是OpenResty的一个管理工具，可以帮助我们安装一个第三方的Lua模块。
#如果你想安装命令行工具 `opm`，那么可以像下面这样安装 `openresty-opm` 包：
yum install -y openresty-opm
# **5）目录结构**
#默认情况下，OpenResty安装的目录是：/usr/local/openresty

看到里面的nginx目录了吗，OpenResty就是在Nginx基础上集成了一些Lua模块。
# **6）配置nginx的环境变量**
#打开配置文件：
vi /etc/profile
#在最下面加入两行：
export NGINX_HOME=/usr/local/openresty/nginx
export PATH=${NGINX_HOME}/sbin:$PATH

#NGINX_HOME：后面是OpenResty安装目录下的nginx的目录
#然后让配置生效：
source /etc/profile

# 2.启动和运行
#OpenResty底层是基于Nginx的，查看OpenResty目录的nginx目录，结构与windows中安装的nginx基本一致：
#所以运行方式与nginx基本一致：
# 启动nginx
nginx
# 重新加载配置
nginx -s reload
# 停止
nginx -s stop
#nginx的默认配置文件注释太多，影响后续我们的编辑，这里将nginx.conf中的注释部分删除，保留有效部分。
修改`/usr/local/openresty/nginx/conf/nginx.conf`文件，内容如下：
#user  nobody;
worker_processes  1;
error_log  logs/error.log;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;

    server {
        listen       8081;
        server_name  localhost;
        location / {
            root   html;
            index  index.html index.htm;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}
#在Linux的控制台输入命令以启动nginx：
nginx
#然后访问页面：http://192.168.231.130:8081，注意ip地址替换为你自己的虚拟机IP

# 3.备注
加载OpenResty的lua模块：
```nginx
#lua 模块
lua_package_path "/usr/local/openresty/lualib/?.lua;;";
#c模块     
lua_package_cpath "/usr/local/openresty/lualib/?.so;;";  
```

#common.lua
```lua
-- 封装函数，发送http请求，并解析响应
local function read_http(path, params)
    local resp = ngx.location.capture(path,{
        method = ngx.HTTP_GET,
        args = params,
    })
    if not resp then
        -- 记录错误信息，返回404
        ngx.log(ngx.ERR, "http not found, path: ", path , ", args: ", args)
        ngx.exit(404)
    end
    return resp.body
end
-- 将方法导出
local _M = {  
    read_http = read_http
}  
return _M
```

#释放Redis连接API：
```lua
-- 关闭redis连接的工具方法，其实是放入连接池
local function close_redis(red)
    local pool_max_idle_time = 10000 -- 连接的空闲时间，单位是毫秒
    local pool_size = 100 --连接池大小
    local ok, err = red:set_keepalive(pool_max_idle_time, pool_size)
    if not ok then
        ngx.log(ngx.ERR, "放入redis连接池失败: ", err)
    end
end
```

#读取Redis数据的API：
```lua
-- 查询redis的方法 ip和port是redis地址，key是查询的key
local function read_redis(ip, port, key)
    -- 获取一个连接
    local ok, err = red:connect(ip, port)
    if not ok then
        ngx.log(ngx.ERR, "连接redis失败 : ", err)
        return nil
    end
    -- 查询redis
    local resp, err = red:get(key)
    -- 查询失败处理
    if not resp then
        ngx.log(ngx.ERR, "查询Redis失败: ", err, ", key = " , key)
    end
    --得到的数据为空处理
    if resp == ngx.null then
        resp = nil
        ngx.log(ngx.ERR, "查询Redis数据为空, key = ", key)
    end
    close_redis(red)
    return resp
end
```

#开启共享词典：
```nginx
# 共享字典，也就是本地缓存，名称叫做：item_cache，大小150m
lua_shared_dict item_cache 150m; 
```

18.Python

#1.在Linux上安装Python需要先安装前置依赖程序。
yum install wget zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gcc make zlib zlib-devel libffi-devel -y
#2.创建安装目录
mkdir /usr/local/develop/python
cd /usr/local/develop/python
#3.进入官方网址https://www.python.org/，点击最上面的Downloads按钮，再点击Linux/UNIX按钮，选择Python Source Releases下面的最新版，滑到最下面，在Files文件列表中选择Gzipped source tarball在上面右键复制链接地址
#执行下面的命令下载安装包，后面为刚刚复制的地址
wget https://www.python.org/ftp/python/3.12.0/Python-3.12.0.tgz
#4.解压
tar -xvf Python-3.12.0.tgz
#5.配置
cd Python-3.12.0
./configure --prefix=/usr/local/develop/python/python3.12.0
#6.编译
make && make install
#7.执行下面的命令，会看到centos默认自带的python版本为2.7.5，我们要替换成最新版的
/usr/bin/python
#8.删除系统自带的老版本(python2)的软链接
rm -f /usr/bin/python
#9.创建软链接替换老版本
ln -s /usr/local/develop/python/python3.12.0/bin/python3.12 /usr/bin/python
#10.验证安装
python

#注意：
#创建软链接后，会破坏yum程序的正常使用（只能使用系统自带的python2）
#将这2个文件的第一行，从#!/usr/bin/python修改为#!/usr/bin/python2
vi /usr/bin/yum
vi /usr/libexec/urlgrabber-ext-down

19.MQTT

(1)安装软件

#1.输入以下指令
yum install gcc-c++
yum install cmake
yum install openssl-devel
#2.新建文件
新建个mqtt文件夹，下载mosquitto，下个不高不低的版本，并解压：
mkdir /usr/local/develop/mqtt
cd mqtt
wget http://mosquitto.org/files/source/mosquitto-1.4.10.tar.gz
tar -xzvf mosquitto-1.4.10.tar.gz
但这里还不能编译安装mosquitto
下面的三款扩展性软件，不安装也不影响mosquitto的使用：
#4、安装c-areas（支持异步DNS查找的库）
wget http://c-ares.haxx.se/download/c-ares-1.10.0.tar.gz
tar xvf c-ares-1.10.0.tar.gz
cd c-ares-1.10.0
./configure
make
sudo make install
#5、安装lib-uuid（支持为每个连接客户端生成唯一uuid）
yum install libuuid-devel
#6、安装libwebsockets（支持需使用websocket的应用）
wget https://github.com/warmcat/libwebsockets/archive/v1.3-chrome37-firefox30.tar.gz
tar zxvf v1.3-chrome37-firefox30.tar.gz
cd libwebsockets-1.3-chrome37-firefox30
mkdir build
cd build
cmake .. -DLIB_SUFFIX=64
make install
#7、修改mosquitto的配置
我们修改一下mosquitto的配置：
cd mosquitto-1.4.10
vim config.mk
将里面的WITH_SRV:=yes和WITH_UUID:=yes都用#号注释掉
#8、安装mosquitto
接下来编译安装mosquitto：
make
sudo make install
注意： 如果在后续使用过程中找不到libmosquitto.so.1的话，在mqtt目录下输入以下指令修改一下libmosquitto.so的位置：
sudo ln -s /usr/local/lib/libmosquitto.so.1 /usr/lib/libmosquitto.so.1
sudo ldconfig

(2)安全配置

#1、创建用户
sudo groupadd test
sudo useradd -g test test
#2、程序配置
创建配置文件
mv  /etc/mosquitto/mosquitto.conf.example  /etc/mosquitto/mosquitto.conf
#3、修改默认配置
#3.1.关闭匿名用户登录
打开mosquitto.conf文件（ /etc/mosquitto/mosquitto.conf ），找到allow_anonymous节点，这个节点作用是，是否开启匿名用户登录。去掉前面的#，改为false。

#3.2.设置用户密码文件路径
找到password_file节点，这个节点是告诉服务器你要配置的用户将存放在哪里。打开此配置并指定pwfile.example文件路径（注意是绝对路径），在669行左右。
password_file /etc/mosquitto/pwfile 或者 /pwfile.example

#3.3.配置topic和用户
acl_file /etc/mosquitto/aclfile.example
#3.4.添加用户信息
终端输入，最后面的是用户名，之后自动弹出密码和确认密码，输入即可。（注意第二次创建用户时不用加 -c 如果加 -c 会把第一次创建的用户覆盖。）
mosquitto_passwd -c /etc/mosquitto/pwfile test
然后进入到/etc/mosquitto/mosquitto.conf 将下面两个用户名和密码加上。

(3)连接测试

#启动
需要切换到test用户才能启动
su test
cd /usr/local/sbin
./mosquitto -v -d  #-d后台启动 -v代码调试模式（verbose）可以输出更多的信息

1.下载客户端软件安装包，点击安装包直接安装 [MQTTX](https://mqttx.app/?spm=a2c6h.13046898.publish-article.21.25b16ffawphRSS)
2.界面一开始是英文，可以显示中文
3.主要填写名称，Client ID，服务器地址这三项，连接

6.Docker安装软件和启动步骤

1.MySQL

#1.在宿主机创建挂载容器的目录映射,创建目录用于存储数据信息
cd /usr/local/develop
mkdir docker-app
cd docker-app
mkdir mysql
cd mysql
#2.搜索mysql镜像
docker search mysql
#3.拉取mysql镜像
docker pull mysql:5.7
#4.创建容器，设置端口映射、目录映射
docker run -id \
-p 3306:3306 \
--name=mysql5 \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/var/log \
-v $PWD/data:/var/lib/mysql \
-v $PWD/file:/var/lib/mysql-files \
-e MYSQL_ROOT_PASSWORD=root \
-e TZ=Asia/Shanghai \
mysql:5.7
#参数说明：
- **-p 3306:3306**：将容器的 3306 端口映射到宿主机的 3306 端口。
- **-v $PWD/conf:/etc/mysql/conf.d**：将主机当前目录下的 conf/my.cnf 挂载到容器的 /etc/mysql/my.cnf。配置文件目录
- **-v $PWD/logs:/var/log**：将主机当前目录下的 logs 目录挂载到容器的 /var/log。日志目录
- **-v $PWD/data:/var/lib/mysql** ：将主机当前目录下的data目录挂载到容器的 /var/lib/mysql 。数据目录
- **-v $PWD/file:/var/lib/mysql-files** ：将主机当前目录下的file目录挂载到容器的 /var/lib/mysql-files 。导出sql文件的默认位置
- **-e MYSQL_ROOT_PASSWORD=root：**初始化 root 用户的密码。
#5.进入容器，操作mysql
docker exec -it mysql /bin/bash
mysql -u root -p
输入密码
#6.使用外部机器连接容器中的mysql
#7.启动容器命令
docker start mysql
#8.停止容器
docker stop mysql

----------------------------------------------------------------------------------------
#注意：
docker中安装了两个版本的MySQL，分别是5.7和8.0.27，都在/usr/local/develop/docker-app/mysql目录下

###mysql报错group by###
修改数据库配置文件my.cnf（永久生效）
mysql5的版本：在[mysqld]模块下新增一行配置：
sql-mode='STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION'
mysql8的版本：在[mysqld]模块下新增一行配置：
sql-mode="STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION"

#从数据库导出sql数据命令
SELECT *
INTO OUTFILE '/var/lib/mysql-files/file.csv'
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'
LINES TERMINATED BY '\n'
FROM 表名
WHERE DATE(timestamp) = '2024-03-15' AND TIME(`timestamp`) BETWEEN '08:00:00' and '09:00:00'; 

修改全局时区设置可能需要数据库服务器重启才能生效：
-- 查看当前时区设置
SELECT @@global.time_zone, @@session.time_zone;
-- 修改时区设置为 '+08:00'，表示东八区
SET GLOBAL time_zone = '+08:00';
SET time_zone = '+08:00';

2.Tomcat

#1.在宿主机创建挂载容器的目录映射,创建目录用于存储数据信息
cd /usr/local/develop
mkdir docker-app
cd docker-app
mkdir tomcat
cd tomcat
#2.搜索镜像
docker search tomcat
#3.拉取镜像
docker pull tomcat:10.0.14
#4.先创建一个简单的容器
docker run -d -p 8080:8080 --name tomcat tomcat
#说明
#-d后台运行 -p指定端口号
#docker run -d -p 宿主机端口:容器端口 --name 容器名 镜像名
-------------------------------------------------------------------------------------------------
#5.解决访问tomcat404报错
#进入容器
docker exec -it tomcat /bin/bash
#以列表形式查看文件
ls -l
#查看webapps发现里面没东西，查看webapps.dist发现里面有东西(examples)，因此删除webapps，将webapps.dist重命名为webapps
rmdir webapps
mv webapps.dist webapps
exit #退出容器
-------------------------------------------------------------------------------------------------
#6.复制容器内的默认配置文件到本地
docker cp tomcat:/usr/local/tomcat/conf /usr/local/develop/docker-app/tomcat
docker cp tomcat:/usr/local/tomcat/logs /usr/local/develop/docker-app/tomcat
docker cp tomcat:/usr/local/tomcat/webapps /usr/local/develop/docker-app/tomcat
#7.删除之前创建的容器
docker stop tomcat
docker rm tomcat
#8.创建最终的容器，并指定映射的配置文件
docker run -d -p 8080:8080 --name tomcat \
-v /usr/local/develop/docker-app/tomcat/conf:/usr/local/tomcat/conf \
-v /usr/local/develop/docker-app/tomcat/logs:/usr/local/tomcat/logs \
-v /usr/local/develop/docker-app/tomcat/webapps:/usr/local/tomcat/webapps \
tomcat
#9.启动容器命令
docker start tomcat
#10.停止容器
docker stop tomcat

3.Redis

cd /usr/local/develop/docker-app
mkdir redis
cd redis
#1. 搜索redis镜像
docker search redis
#2. 拉取redis镜像
docker pull redis
#因为 docker 安装运行 redis容器，是没有配置文件的，需要自己手动创建一个 redis.conf 文件
mkdir conf data log
vim conf/redis.conf
[粘贴或者上传redis.conf配置文件]
进入后使用编辑模式进行修改以下部分
将bind 127.0.0.1 -::1 替换为bind  0.0.0.0
将 daemonize on  替换成  daemonize yes
#3. 创建容器，设置端口映射
docker run -id --name redis -p 6379:6379 \
-v /usr/local/develop/docker-app/redis/conf/redis.conf:/usr/local/etc/redis/redis.conf \
-v /usr/local/develop/docker-app/redis/data/:/data \
-v /usr/local/develop/docker-app/redis/log/redis.log:/var/log/redis.log \
redis 
#4. 使用工具连接redis

4.nginx

#1.在宿主机创建挂载容器的目录映射,创建目录用于存储数据信息
cd /usr/local/develop
mkdir docker-app
cd docker-app
mkdir nginx
cd nginx
#2.搜索nginx镜像
docker search nginx
#3..拉取nginx镜像
docker pull nginx
#4. 先创建一个简单的容器，设置端口映射
docker run -id --name nginx -p 80:80 nginx
#4.复制容器内的默认配置文件到本地
mkdir -p conf logs html
docker cp nginx:/etc/nginx/nginx.conf /usr/local/develop/docker-app/nginx/conf/nginx.conf
docker cp nginx:/var/log/nginx /usr/local/develop/docker-app/nginx/logs
docker cp nginx:/usr/share/nginx/html /usr/local/develop/docker-app/nginx/html
#5.删除之前创建的容器
docker stop nginx
docker rm nginx
#6.修改配置文件
vim conf/nginx.conf
#7.创建最终的容器，并指定映射的配置文件
docker run -id --name nginx -p 80:80 \
-v /usr/local/develop/docker-app/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
-v /usr/local/develop/docker-app/nginx/logs:/var/log/nginx \
-v /usr/local/develop/docker-app/nginx/html:/usr/share/nginx/html \
nginx

#另外：挂载容器内的文件映射到本地
docker run -v /usr/local/develop/docker-app/nginx/conf/nginx.conf:/etc/nginx/nginx.conf nginx
docker run -v /usr/local/develop/docker-app/nginx/logs:/var/log/nginx nginx
docker run -v /usr/local/develop/docker-app/nginx/html:/usr/share/nginx/html nginx 

5.RocketMQ

（1）普通方式

#1.在宿主机创建挂载容器的目录映射,创建目录用于存储数据信息
cd /usr/local/develop
mkdir docker-app
cd docker-app
mkdir rocketmq
cd rocketmq
#2.搜索rocketmq镜像
docker search rocketmq
#3..拉取rocketmq镜像
docker pull rocketmqinc/rocketmq
docker pull pangliang/rocketmq-console-ng
#4.创建namesrv需要挂载的目录
mkdir -p /usr/local/develop/docker-app/rocketmq/logs /usr/local/develop/docker-app/rocketmq/store
#5.启动namesrv容器
docker run -d -p 9876:9876 --name rmqnamesrv \
-v /usr/local/develop/docker-app/rocketmq/logs:/home/rocketmq/logs \
-v /usr/local/develop/docker-app/rocketmq/store:/home/rocketmq/store \
rocketmq:4.4.0 \
sh mqnamesrv
#6.创建broker容器需要挂载的目录
mkdir /usr/local/develop/docker-app/rocketmq/conf
#7. 创建broker.conf文件
touch /usr/local/develop/docker-app/rocketmq/conf/broker.conf
cd conf
vim broker.conf
#添加下面的内容
brokerClusterName = DefaultCluster
brokerName = broker-a
brokerId = 0
deleteWhen = 04
fileReservedTime = 48
brokerRole = ASYNC_MASTER
flushDiskType = ASYNC_FLUSH
brokerIP1 = 192.168.231.130 #这里需要根据自己服务器IP替换
#8.启动broker容器
docker run -d -p 10911:10911 -p 10909:10909 --name rmqbroker --link rmqnamesrv:namesrv \
-e "NAMESRV_ADDR=namesrv:9876" \
-v /usr/local/develop/docker-app/rocketmq/logs:/home/rocketmq/logs \
-v /usr/local/develop/docker-app/rocketmq/store:/home/rocketmq/store \
-v /usr/local/develop/docker-app/rocketmq/conf/broker.conf:/opt/rocketmq-4.4.0/conf/broker.conf \
rocketmq:4.4.0 \
sh mqbroker -n namesrv:9876
#9.创建RocketMQ-console可视化工具
docker run -d \
--name rmqconsole \
-e "JAVA_OPTS=-Drocketmq.namesrv.addr=192.168.231.130:9876 \
-Dcom.rocketmq.sendMessageWithVIPChannel=false" \
-p 8080:8080 \
pangliang/rocketmq-console-ng
#10. 查看启动状态
docker ps -a
#11.浏览器预览

（2）docker-compose方式

#1.安装docker-compose
yum install docker-compose
#2.新建配置文件docker-compose.yml
cd /usr/local/develop/docker-app/rocketmq
vim docker-compose.yml
#3.加入下面的配置
```yml
version: '3'
services:
  namesrv:
  	#通过docker images查看镜像名称
    image: rocketmqinc/rocketmq
    #容器起名
    container_name: rocketmq-namesrv
    #指定端口
    ports:
      - 9876:9876
    #指定挂载路径
    volumes:
      - /home/test/develop/docker-app/rocketmq/logs:/home/rocketmq/logs
      - /home/test/develop/docker-app/rocketmq/store:/home/rocketmq/store
    #执行命令
    command: sh mqnamesrv
  broker:
    image: rocketmqinc/rocketmq
    container_name: rocketmq-broker
    ports:
      - 10909:10909
      - 10911:10911
      - 10912:10912
    volumes:
      - /home/test/develop/docker-app/rocketmq/logs:/home/rocketmq/logs
      - /home/test/develop/docker-app/rocketmq/store:/home/rocketmq/store
      - /home/test/develop/docker-app/rocketmq/conf/broker.conf:/opt/rocketmq-4.4.0/conf/broker.conf
    command: sh mqbroker -n namesrv:9876 -c /opt/rocketmq-4.4.0/conf/broker.conf
    depends_on:
      - namesrv
    #下面的JAVA_HOME为容器内的路径
    environment:
      - JAVA_HOME=/usr/lib/jvm/jre
  console:
    image: styletang/rocketmq-console-ng
    container_name: rocketmq-console
    ports:
      - 8080:8080
    depends_on:
      - namesrv
    environment:
      - JAVA_OPTS= -Dlogging.level.root=info   -Drocketmq.namesrv.addr=rocketmq-namesrv:9876 
      - Dcom.rocketmq.sendMessageWithVIPChannel=false
```
#4.在配置文件所在目录执行启动命令
docker-compose up -d   #-d后台运行，可不加

6.Kafka和Zookeeper

#1.首先安装zookeeper
docker pull wurstmeister/zookeeper
#2.安装kafka
docker pull wurstmeister/kafka 
#3.先简单启动zookeeper
docker run -d --name zookeeper -p 2181:2181 -e TZ="Asia/Shanghai" wurstmeister/zookeeper
#4.复制容器内文件到宿主机
docker cp zookeeper:/opt/zookeeper-3.4.13/conf /home/test/develop/docker-app/zookeeper
docker cp zookeeper:/opt/zookeeper-3.4.13/data /home/test/develop/docker-app/zookeeper
#5.删除zookeeper
docker stop zookeeper
docker rm zookeeper
#6.创建最终的zookeeper
docker run -d --name zookeeper -p 2181:2181 \
-v /home/test/develop/docker-app/zookeeper/conf:/opt/zookeeper-3.4.13/conf \
-v /home/test/develop/docker-app/zookeeper/data:/opt/zookeeper-3.4.13/data \
-v /etc/localtime:/etc/localtime \
-e TZ="Asia/Shanghai" \
wurstmeister/zookeeper
#7.先简单启动kafka
docker run -d --name kafka -p 9092:9092 \
--link zookeeper:zookeeper \
-e KAFKA_BROKER_ID=0 \
-e KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181 \
-e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.186.128:9092 \
-e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 \
-e TZ="Asia/Shanghai" \
-v /etc/localtime:/etc/localtime \
wurstmeister/kafka
#8.复制容器内文件到宿主机
docker cp kafka:/opt/kafka_2.13-2.8.1/config /home/test/develop/docker-app/kafka
#9.删除kafka
docker stop kafka
docker rm kafka
#10.创建最终的kafka
docker run -d --name kafka -p 9092:9092 \
--link zookeeper:zookeeper \
-e KAFKA_BROKER_ID=0 \
-e KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181 \
-e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.186.128:9092 \
-e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 \
-e TZ="Asia/Shanghai" \
-v /etc/localtime:/etc/localtime \
-v /home/test/develop/docker-app/kafka/config:/opt/kafka_2.13-2.8.1/config \
-v /home/test/develop/docker-app/kafka/logs:/kafka \
wurstmeister/kafka
说明：
--link zookeeper:zookeeper: 连接到名为“zookeeper”的另一个Docker容器，并且在当前的容器中可以通过zookeeper这个别名来访问它。
-e KAFKA_BROKER_ID=0     在kafka集群中，每个kafka都有一个BROKER_ID来区分自己
-e KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181: 配置zookeeper管理kafka的路径
-e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.186.128:9092: 把kafka的地址端口注册给zookeeper，这里ip需要更改
-e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092: 配置kafka的监听端口
-v /etc/localtime:/etc/localtime 容器时间同步虚拟机的时间
注意：
如果更改config中server.properties的配置，更改的配置是不会生效的，会被-e配置覆盖掉
#11.进入kafka容器
docker exec -it kafka /bin/bash
#12.进入kafka的bin目录下
cd  /opt/kafka/bin
#13.创建一个新主题（test-kafka)来存储事件
./kafka-topics.sh --create --topic test-kafka --bootstrap-server localhost:9092
#14.测试消费消息：
./kafka-console-consumer.sh --topic test-kafka --from-beginning --bootstrap-server localhost:9092
#15.测试生产消息：
./kafka-console-producer.sh --topic test-kafka --bootstrap-server localhost:9092

7.ElasticSearch

#1.安装
docker pull elasticsearch:8.2.0
#2.启动
docker run -it elasticsearch:8.2.0 /bin/bash
#先简单启动 看一下我们要挂载一些什么样的目录,这个不是我们最终的启动命令。通过ls和pwd命令我们大概知道了es的关键目录大概是以下三个。
#存放配置相关的：/usr/share/elasticsearch/config
#存放数据相关的：/usr/share/elasticsearch/data
#存放插件相关的：/usr/share/elasticsearch/plugins
#3.退出容器
exit 或者 ctrl+c
#4.最终构建容器命令
docker run \
--name elasticsearch \
--privileged=true \
-p 9200:9200 \
-p 9300:9300 \
-v /usr/local/develop/docker-app/elasticsearch/config:/usr/share/elasticsearch/config \
-v /usr/local/develop/docker-app/elasticsearch/data:/usr/share/elasticsearch/data \
-v /usr/local/develop/docker-app/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-e ES_JAVA_OPTS="-Xms512m -Xmx512m" \
-e "discovery.type=single-node" \
-d elasticsearch:8.2.0
--------------------------------------------------------------------------------------------------------------
#启动之后如果发现没成功启动容器，通过docker logs es看到以下错误，那么就是咋们自己创建的挂载目录可能权限不够高。
Exception in thread "main" java.nio.file.NoSuchFileException: /usr/share/elasticsearch/config/jvm.options
#给三个挂载目录进行chmod 777
chmod 777 /usr/local/develop/docker-app/elasticsearch/config
chmod 777 /usr/local/develop/docker-app/elasticsearch/data
chmod 777 /usr/local/develop/docker-app/elasticsearch/plugins
#直接先启动一个简单的es容器
docker run -d --name es -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:8.2.0
#将容器里的config文件夹的东西拷贝到宿主机上
docker cp es:/usr/share/elasticsearch/config /usr/local/develop/docker-app/elasticsearch
#删除临时容器
docker stop es
docker rm -f es
#修改elasticsearch.yml文件,将true都改为false
vim /usr/local/develop/docker-app/elasticsearch/config/elasticsearch.yml
#重新启动elasticsearch
docker start elasticsearch

--------------------------------------------------------------------------------------------------------------
#添加新用户
#1.先进入容器
docker exec -it elasticsearch /bin/bash
#2.添加test用户
./bin/elasticsearch-users useradd test 
#3.赋角色权限： 这一步要执行，不然无法访问
./bin/elasticsearch-users roles -a superuser test （超级管理员角色）
./bin/elasticsearch-users roles -a kibana_system test （kibana的用户角色）

#给自己创建的用户修改密码
./bin/elasticsearch-users passwd test

#生成超级管理员elastic的密码，随机的密码
docker exec -it elasticsearch /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic
#如果忘记密码，重置elastic的密码
docker exec -it elasticsearch /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic -i
--------------------------------------------------------------------------------------------------------------
#给elasticsearch设置用户名和密码，elastic默认为超级管理员
#1.编辑挂载的配置文件
cd /usr/local/develop/docker-app/elasticsearch/config
vim elasticsearch.yml
#添加如下内容
http.cors.enabled: true
http.cors.allow-origin: "*"
http.cors.allow-headers: Authorization
xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true
#2.先启动es
docker start elasticsearch
#3.进入es
docker exec -it elasticsearch /bin/bash
#4.执行下面命令，会提示你如果确定开启密码的话，需要设置以下六种账户的密码，按y回车，然后密码都设置成elastic，账号也为elastic
./bin/elasticsearch-setup-passwords interactive
#5.完成以上的设置后，需要再次重启ES容器，重启后，输入ES的访问地址：http://192.168.231.130:9200发现已经提示让你输入账号密码了

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#elasticsearch.yml最终的样子如下：
cluster.name: "docker-cluster"
network.host: 0.0.0.0
#开启跨域
http.cors.enabled: true
#所有人访问
http.cors.allow-origin: "*"
xpack.security.enabled: true
xpack.security.enrollment.enabled: true 
xpack.security.http.ssl:
  enabled: false 
  keystore.path: certs/http.p12
xpack.security.transport.ssl:
  enabled: true
  verification_mode: certificate
  keystore.path: certs/transport.p12
  truststore.path: certs/transport.p12

8.Kibana

#1.拉取镜像
docker pull kibana:8.2.0
#2.创建容器挂载的目录,并进入目录
mkdir /usr/local/develop/docker-app/kibana/config
cd config
#3.创建配置文件
vi kibana.yml
添加如下配置：
#设置Kibana映射端口
server.port: 5601
#设置网关地址
server.host: "0.0.0.0"
#设置Kibana实例对外展示的名称
server.name: "kibana"
#设置ES集群地址
#如果elasticsearch加入了自定义的网络network(es_kibana)，就用network里的地址
#可以通过命令(docker inspect 容器id)查看，Networks->IPAddress地址就是
elasticsearch.hosts: ["http://192.168.231.130:9200"]
#设置请求超时时长
elasticsearch.requestTimeout: 120000
#设置页面语言
i18n.locale: "zh-CN"
#设置es的普通用户的用户名密码，普通用户的创建步骤在第7条ElasticSearch中有介绍
elasticsearch.username: "test"
elasticsearch.password: "test"

xpack.monitoring.ui.container.elasticsearch.enabled: true
----------------------------------------------------------------------------------------------------
#4.创建容器
docker run -d --network es_kibana --privileged=true \
--name kibana -p 5601:5601 \
-v /usr/local/develop/docker-app/kibana/config/kibana.yml:/usr/share/kibana/config/kibana.yml \
-e "I18N_LOCALE=zh-CN" \
kibana:8.2.0
#5.访问测试http://ip:5601

#生成超级管理员elastic的密码
docker exec -it elasticsearch /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic
#如果忘记密码，重置elastic的密码
docker exec -it elasticsearch /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic -i
#生成enrollment-token（目前只发现kibana登录需要使用）
docker exec -it elasticsearch /usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana

9.Nacos

在docker中安装nacos，很详细_docker安装nacos-CSDN博客

#1.搜索可以使用的镜像
docker search nacos
#2.拉取镜像
docker pull nacos/nacos-server
#3.创建挂载目录
mkdir -p /usr/local/develop/docker-app/nacos/logs   #新建logs目录
mkdir -p /usr/local/develop/docker-app/nacos/data  
mkdir -p /usr/local/develop/docker-app/nacos/conf
#4.先简单启动nacos容器
docker run --name nacos -d -p 8848:8848 -e MODE=standalone  nacos/nacos-server
#5.复制容器的相关文件到挂载目录
docker cp nacos:/home/nacos/conf/ /usr/local/develop/docker-app/conf
docker cp nacos:/home/nacos/data/ /usr/local/develop/docker-app/data
docker cp nacos:/home/nacos/logs/ /usr/local/develop/docker-app/logs
#6.建库建表
创建数据库nacos_config，执行conf目录下的mysql-schema.sql文件
#7.修改conf下的配置文件application.properties,先备份在修改
```properties
# spring
server.servlet.contextPath=/nacos
server.contextPath=/nacos
server.port=8848
# server.tomcat.accesslog.max-days=30
server.tomcat.accesslog.pattern=%h %l %u %t "%r" %s %b %D %{User-Agent}i %{Request-Source}i
server.tomcat.accesslog.enabled=false
# default current work dir
# server.tomcat.basedir=file:.
#*************** Config Module Related Configurations ***************#
### Deprecated configuration property, it is recommended to use `spring.sql.init.platform` replaced.
spring.datasource.platform=mysql
spring.sql.init.platform=mysql
nacos.cmdb.dumpTaskInterval=3600
nacos.cmdb.eventTaskInterval=10
nacos.cmdb.labelTaskInterval=300
nacos.cmdb.loadDataAtStart=false

#  这里必须为公网或服务器内网地址，我这里是服务器的内网地址，容器内部没有mysql，绝对不能使用 127.0.0.1和localhost
#  如果nacos启动失败，Nacos Server did not start because dumpservice bean construction failure : No DataSource set
#  加上 &serverTimezone=UTC ，再不行就加上 &allowPublicKeyRetrieval=true
#  将connectTimeout 和 socketTimeout 分别加个0，避免出现超时异常
db.num=1
db.url.0=jdbc:mysql://192.168.186.128:3306/huishi-config?characterEncoding=utf8&connectTimeout=10000&socketTimeout=30000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=root

### The auth system to use, currently only 'nacos' and 'ldap' is supported:
# 鉴权类型，默认为nacos
nacos.core.auth.system.type=nacos

# 是否开启鉴权功能，默认为false
nacos.core.auth.enabled=false

# Base64加密前密码  TcmxJw05k$-_zcx.)8EtFC^D^F1W!IPr
# Base64加密后密码  VGNteEp3MDVrJC1femN4Lik4RXRGQ15EXkYxVyFJUHI=
# 加密网站：https://www.qqxiuzi.cn/bianma/base64.htm
# 自定义密钥，在自定义密钥时，推荐将配置项设置为Base64编码的字符串，且原始密钥长度不得低于32字符。同nacos.core.auth.plugin.nacos.token.secret.key
nacos.core.auth.default.token.secret.key=VGNteEp3MDVrJC1femN4Lik4RXRGQ15EXkYxVyFJUHI=

### worked when nacos.core.auth.system.type=nacos
### The token expiration in seconds:
# 用户登陆临时accessToken的过期时间，默认18000
nacos.core.auth.plugin.nacos.token.expire.seconds=18000
### The default token:

# 默认鉴权插件用于生成用户登陆临时accessToken所使用的密钥，在2.2.1后无默认值，必须执行此变更，否则无法启动；其他版本为建议设置。
nacos.core.auth.plugin.nacos.token.secret.key=VGNteEp3MDVrJC1femN4Lik4RXRGQ15EXkYxVyFJUHI=
### Turn on/off caching of auth information. By turning on this switch, the update of auth information would have a 15 seconds delay.
nacos.core.auth.caching.enabled=false

# 关闭使用user-agent判断服务端请求并放行鉴权的功能
nacos.core.auth.enable.userAgentAuthWhite=false

# 用于替换useragent白名单的身份识别key，不可为空，2.2.1后无默认值，必须执行此变更，否则无法启动
nacos.core.auth.server.identity.key=nacosKey
# 用于替换useragent白名单的身份识别value，不可为空，2.2.1后无默认值，必须执行此变更，否则无法启动
nacos.core.auth.server.identity.value=nacosValue

## spring security config
### turn off security
nacos.security.ignore.urls=/,/error,/**/*.css,/**/*.js,/**/*.html,/**/*.map,/**/*.svg,/**/*.png,/**/*.ico,/console-fe/public/**,/v1/auth/**,/v1/console/health/**,/actuator/**,/v1/console/server/**
# metrics for elastic search
management.metrics.export.elastic.enabled=false
management.metrics.export.influx.enabled=false
nacos.naming.distro.taskDispatchThreadCount=10
nacos.naming.distro.taskDispatchPeriod=200
nacos.naming.distro.batchSyncKeyCount=1000
nacos.naming.distro.initDataRatio=0.9
nacos.naming.distro.syncRetryDelay=5000
nacos.naming.data.warmup=true
```
#8.删除先前创建的nacos容器
docker stop nacos
docker rm nacos
#9.运行nacos，创建最终的nacos容器
docker run \
--name nacos -d \
-p 8848:8848 \
-p 7848:7848 \
-p 9848:9848 \
-p 9849:9849 \
--privileged=true \
--restart=always \
-e JVM_XMS=256m \
-e JVM_XMX=256m \
-e MODE=standalone \
-e PREFER_HOST_MODE=hostname \
-v /usr/local/develop/docker-app/nacos/conf:/home/nacos/conf \
-v /usr/local/develop/docker-app/nacos/logs:/home/nacos/logs \
-v /usr/local/develop/docker-app/nacos/data:/home/nacos/data \
nacos/nacos-server
#10.检查是否启动
docker ps
#11.访问地址 默认账号密码是nacos/nacos
http://ip:8848/nacos

注意：服务注册时报错 Client not connected, current status:STARTING
该错误明确地指向了客户端与服务器之间的连接障碍。为了确保流畅的连接，两者之间的通信参数和网络环境都需要满足特定的条件
在网上查了一堆解决方案，网络、服务器状态、防火墙、日志分析，都没有发现问题
之后发现Nacos2.0版本相比1.X新增了gRPC的通信方式，因此需要增加3个端口。新增端口是在配置的主端口(server.port)基础上，进行一定偏移量自动生成。

10.Canal

# 安装和配置Canal
下面我们就开启mysql的主从同步机制，让Canal来模拟salve
# 1.开启MySQL主从
Canal是基于MySQL的主从同步功能，因此必须先开启MySQL的主从功能才可以。
这里以之前用Docker运行的mysql为例：
## 1.1.开启binlog
打开mysql容器挂载的日志文件，我的在`/usr/local/develop/docker-app/mysql/conf`目录:
修改文件：
vi /usr/local/develop/docker-app/mysql/conf/my.cnf
添加内容：
log-bin=/var/lib/mysql/mysql-bin
binlog-do-db=redis_mult_cache
配置解读：
- `log-bin=/var/lib/mysql/mysql-bin`：设置binary log文件的存放地址和文件名，叫做mysql-bin，名字随便取
- `binlog-do-db=redis_mult_cache`：指定对哪个database记录binary log events，这里记录redis_mult_cache这个库

最终效果：
[mysqld]
skip-name-resolve
character_set_server=utf8
datadir=/var/lib/mysql
server-id=1000
log-bin=/var/lib/mysql/mysql-bin
binlog-do-db=redis_mult_cache
## 1.2.设置用户权限
接下来添加一个仅用于数据同步的账户，出于安全考虑，这里仅提供对redis_mult_cache这个库的操作权限。
在mysql控制台，或者Navicat中新建查询：
create user canal@'%' IDENTIFIED by 'canal';
GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT,SUPER ON *.* TO 'canal'@'%' identified by 'canal';
FLUSH PRIVILEGES;
重启mysql容器即可
docker restart mysql
测试设置是否成功：在mysql控制台，或者Navicat中，输入命令：
show master status;

# 2.安装Canal
## 2.1.创建网络
我们需要创建一个网络，将MySQL、Canal、MQ放到同一个Docker网络中：
docker network create mysql_canal
让mysql加入这个网络：
docker network connect mysql_canal mysql
## 2.3.安装Canal
将canal的镜像压缩包上传到虚拟机，然后通过命令导入：
docker load -i canal.tar
然后运行命令创建Canal容器：
docker run -p 11111:11111 --name canal \
-e canal.destinations=test \
-e canal.instance.master.address=mysql:3306  \
-e canal.instance.dbUsername=canal  \
-e canal.instance.dbPassword=canal  \
-e canal.instance.connectionCharset=UTF-8 \
-e canal.instance.tsdb.enable=true \
-e canal.instance.gtidon=false  \
-e canal.instance.filter.regex=redis_mult_cache\\..* \
--network mysql_canal \
-d canal:latest
说明:
- `-p 11111:11111`：这是canal的默认监听端口
- `-e canal.destinations=test`：这是给canal集群起个名字
- `-e canal.instance.master.address=mysql:3306`：数据库地址和端口，如果不知道mysql容器地址，可以通过`docker inspect 容器id`来查看
- `-e canal.instance.dbUsername=canal`：数据库用户名
- `-e canal.instance.dbPassword=canal` ：数据库密码
- `-e canal.instance.filter.regex=redis_mult_cache\\..*`：要监听redis_mult_cache库下所有的表

表名称监听支持的语法：
mysql 数据解析关注的表，Perl正则表达式.
多个正则之间以逗号(,)分隔，转义符需要双斜杠(\\) 
常见例子：
1.  所有表：.*   or  .*\\..*
2.  canal schema下所有表： canal\\..*
3.  canal下的以canal打头的表：canal\\.canal.*
4.  canal schema下的一张表：canal.test1
5.  多个规则组合使用然后以逗号隔开：canal\\..*,mysql.test1,mysql.test2 

11.MQTT

#1.新建目录
mkdir -p /usr/local/develop/docker-app/mqtt/config
mkdir -p /usr/local/develop/docker-app/mqtt/data
mkdir -p /usr/local/develop/docker-app/mqtt/log
#2.创建配置文件
#存放基本配置
touch /usr/local/develop/docker-app/mqtt/config/mosquitto.conf
#存放用户密码配置文件
touch /usr/local/develop/docker-app/mqtt/config/pwfile.conf
#日志目录
touch /usr/local/develop/docker-app/mqtt/log/mosquitto.log
#3.修改配置文件
vi /usr/local/develop/docker-app/mqtt/config/mosquitto.conf
#添加下面的内容，下面的所有路径,指向的都是docker的路径，不需要修改！！！：
```conf
persistence true
persistence_location /mosquitto/data
log_dest file /mosquitto/log/mosquitto.log
listener 1883
#协议模式，可以不指定
#protocol websockets
# 关闭匿名模式
allow_anonymous false
#指定密码文件
password_file /mosquitto/config/pwfile.conf
```
#4.修改文件权限
chmod -R 755 /usr/local/develop/docker-app/mqtt
chmod -R 777 /usr/local/develop/docker-app/mqtt/log #日志目录要最大权限
#5.启动命令
docker run -it --name=mqtt --privileged  -p 1883:1883 -p 9001:9001 \
-v /usr/local/develop/docker-app/mqtt/config/mosquitto.conf:/mosquitto/config/mosquitto.conf  \
-v /usr/local/develop/docker-app/mqtt/data:/mosquitto/data \
-v /usr/local/develop/docker-app/mqtt/log:/mosquitto/log \
-v /usr/local/develop/docker-app/mqtt/config/pwfile.conf:/mosquitto/config/pwfile.conf -d  \
eclipse-mosquitto 
#命令详解：
1883是应用的端口，9001是管理程序的端口。要将宿主机和容器之间的文件关系进行映射，
冒号前面的是宿主机配置，冒号后面是容器配置
比如：-p 1883:1883  前面是宿主机端口 ，后面是容器端口，因此需要在宿主机的防火墙中放开1883这个端口。其他配置都是类似，需要了解。

#好多网上的启动命令没有这一句话：-v /docker/mosquitto/config/pwfile.conf:/mosquitto/config/pwfile.conf
#就会报找不到文件的错误：Error: Unable to open log file /mosquitto/log/mosquitto.log for writing.
#一定记得把宿主机的文件目录和容器的目录映射起来，这样在启动的时候，就不会报错。

#6.账号密码修改,进入容器
docker exec -it mqtt sh
mosquitto_passwd -b /mosquitto/config/pwfile.conf test test  #设置账号密码
exit退出容器
#7.重启容器
docker restart mqtt
#8.客户端访问

未完待续~~~~

如果这份博客对大家有帮助，希望各位给南山寺夜雨一个免费的点赞

标签：develop,--,安装,usr,conf,Linux,docker,local,常用软件
From： https://www.cnblogs.com/yuetong-develop/p/18317764