0
0

Linux 部署Java项目

阿里云服务器 初始化云盘后，要更换操作系统操作才能远程登录。

Linux sudo命令以系统管理者的身份执行指令，也就是说，经由 sudo 所执行的指令就好像是 root 亲自执行。

1、安装jdk

把jdk上传至Linux服务器，执行下方解压命令

tar -zxvf /jdk-8u144-linux-x64.tar.gz -C 安装目录
或
wget --no-check-certificate --no-cookies --header "Cookie: oraclelicense=accept-securebackup-cookie" http://download.oracle.com/otn-pub/java/jdk/8u131-b11/d54c1d3a095b4ff2b6607d096fa80163/jdk-8u131-linux-x64.rpm

设置环境变量

设置环境变量 这里采用全局设置方法，就是修改etc/profile，它是是所有用户的共用的环境变量

vi /etc/profile

在文件中添加

export JAVA_HOME=/usr/local/Java/jdk1.8.0_144
export JRE_HOME=/usr/local/Java/jdk1.8.0_144/jre
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME:$CLASSPATH
export PATH=$JAVA_HOME/bin:$PATH

使环境变量设置立即生效

source /etc/profile

2、安装nginx

安装所需插件

(1)、安装gcc
gcc可以编译 C,C++,Ada,Object C和Java等语言

gcc -v    //查看gcc版本 
yum -y install gcc  //安装命令

(2)、pcre、pcre-devel安装
pcre是一个perl库，包括perl兼容的正则表达式库，nginx的http模块使用pcre来解析正则表达式，所以需要安装pcre库。

yum install -y pcre pcre-devel

(3)、zlib安装
zlib库提供了很多种压缩和解压缩方式nginx使用zlib对http包的内容进行gzip，所以需要安装

yum install -y zlib zlib-devel

(4)、安装openssl
openssl是web安全通信的基石，没有openssl，可以说我们的信息都是在裸奔

yum install -y openssl openssl-devel
安装nginx

1、下载nginx安装包

wget http://nginx.org/download/nginx-1.9.9.tar.gz

2、把压缩包解压到usr/local/java

tar -zxvf  nginx-1.9.9.tar.gz

3、切换到cd /usr/local/java/nginx-1.9.9/下
执行三个命令：

./configure //是可执行的脚本文件,用来检测你的安装平台的目标特征的,并生成Makefile文件
make   // 编绎
make install  // 安装

执行完make以后报错

make[1]: *** [objs/Makefile:445: objs/src/core/ngx_murmurhash.o] Error 1
make[1]: Leaving directory '/app/nginx-1.9.9'
make: *** [Makefile:8: build] Error 2
解决办法

找到对应的Maakefile文件（我的在 /nginx/objs/Makefile），将gcc参数中的-Werror去掉 再重新make即可

nginx编译时，make后会产生如下报错

①将/nginx目录下/objs/Makefile中的 -Werrori （有的为Wrror）删除（意思是将所有警告当作错误处理，因此要关闭）。

②立马再次编译的话，是会报另一个错误。
③在nginx目录下输入命令：

vim src/os/unix/ngx_user.c

将下图红框内内容注释，退出保存即可正常编译

cd.current_salt[0]=~salt[0];
方式一：传统方法
一、启动
cd usr/local/nginx/sbin
./nginx
二、重启

更改配置重启nginx

kill -HUP 主进程号或进程号文件路径
或者使用
cd /usr/local/nginx/sbin
./nginx -s reload
判断配置文件是否正确
nginx -t -c /usr/local/nginx/conf/nginx.conf
或者
cd  /usr/local/nginx/sbin
./nginx -t
如果浏览器无法返回，查看阿里云服务器是否启动 80端口

3、安装Redis

1.下载redis安装包

可以在centos中使用wget命令下载redis安装包：

wget http://download.redis.io/releases/redis-4.0.2.tar.gz
2.安装设置

安装包上传到服务器器后放到期望的目录中，或者是在期望的目录中使用wget命令，会自动下载到当前目录。

wget http://download.redis.io/releases/redis-4.0.2.tar.gz
3.tar解压redis包
tar -xzvf redis-4.0.2.tar.gz

#也可以tar -xzvf redis-4.0.2.tar.gz -C 目录 解压到指定目录
#我这里是直接解压到当前目录

4.编译安装

进入到上一步解压后生成的目录中make
这里需要注意的是编译时redis版本过高gcc版本过低会出现编译后src目录中没有redis-server文件最终无法安装成功，如果出现这种问题可以使用以下命令更新一下gcc版本，重新编译安装即可。

#更新gcc版本

yum -y install gcc automake autoconf libtool make
#1、进入目录
cd redis-4.0.2
#2、编译
make
#3、安装
make install
5.修改配置

在解压目录中会有一个redis的配置文件redis.conf，vim编辑改文件。

vim redis.conf
去除ip绑定

在文件第69行会有"bind 127.0.0.1"将他#干掉，这样我们可以通过任意ip地址访问到redis，不同版本位置可能会略有区别，但是相差不大。【:n回车可直接跳转到第n行】

关闭保护模式

redis默认运行在保护模式下，redis的保护模式不允许远程访问，因此，我们需要关闭保护模式，来让我们的redis可以被远程访问。

将protected-mode yes改no即可。

port 6397为redis默认端口，可根据具体需要更改端口。

开启后台启动

redis默认是关闭后台启动的，也就是我们安装完成后一旦启动redis。redis会占用我们的整个终端，这样我们除了执行redis操作，就不能做其他任何事情，所以我们要开启后台启动。

第136行将daemonize no改yes即可。
启动服务端命令

#注意当前是在redis.xx.xx目录中所以需要加上路径

./src/redis-server redis.conf
6.设置redis开机自启动升级为系统服务

redis安装好之后，我们想让redis开机自启动，首先要把redis升级为一个系统服务，redis已经为我们提供好了解决方案。在redis的安装目录中，有一个utils文件夹，该文件夹中有一个install_server.sh文件，我们进入utils目录，执行这个文件。之后我们需要做一些配置，一路回车就可以了。

#注意当前是在redis.xx.xx目录中所以需要加上路径
./install_server.sh

#格式：systemctl start 服务名称
#启动redis
systemctl start redisd    
#重启redis
systemctl restart redis
#查看状态
systemctl status redis
#重新加载配置
systemctl daemon-reload
远程连接redis服务器
./redis-cli -h redis服务器IP -p 6379 (默认端口)
1
tips：如果只是连接本地
redis-cli

4、MQTT安装

//EMQX 5.0.16
详见：免费试用 EMQX Cloud 或 EMQX Enterprise | 下载 EMQX
Http接口：
//获取所有客户端列表
http://10.100.0.200:18083/api/v5/clients
//发送消息
http://10.100.0.200:18083/api/v5/publish
验证方式：
1、Basic Auth username:admin passowrd:登录的密码。
如果设备了API密钥，则API key为username,Secret Key为passord
2、Header Key: Authorization, Value: Basic xxxx：。
通过http://10.100.0.200:18083/api-docs/index.html，点击右上角Authorize按钮，再找到publish接口，tryout，请求参数就会包括 value: Basic输入相应的用户名和密码就能获取Authorization value

wget https://www.emqx.com/en/downloads/broker/4.0.13/emqx-centos7-v4.0.13.x86_64.rpm   //下载

sudo yum install emqx-centos7-v4.0.13.x86_64.rpm //安装

sudo emqx start  // 运行

# 启动emqx
./bin/emqx start
 
# 停止emqx
./bin/emqx stop
 
# 重启emqx
./bin/emqx restart
 
# 检查运行状态
./bin/emqx_ctl status
 
# 服务卸载
./bin/emqx uninstall

在云服务器开放相应端口

http://IP:18083/#/

5、安装Docker

手动安装
卸载旧版本

较旧的 Docker 版本称为 docker 或 docker-engine 。如果已安装这些程序，请卸载它们以及相关的依赖项。

sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

1：执行如下命令，确保 yum 包更新到最新

yum update

2：如果安装过旧版本的话,执行如下命令卸载旧版本（没哟可以跳过此步骤）

yum remove docker  docker-common docker-selinux docker-engine

3：安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的

yum install -y yum-utils device-mapper-persistent-data lvm2

4：设置yum源(这里使用的阿里云镜像源地址)

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

5：查看那个yum源最快，可以看到阿里的最快

yum makecache fast

6：查看docker的版本，可以选择指定版本安装

yum list docker-ce --showduplicates | sort -r

7：安装docker

#安装默认稳定版本
yum -y install docker-ce 
#安装指定版本 其中VERSION_STRING 为版本号
sudo yum install docker-ce-<VERSION_STRING>

看到上面内容代表docker已经安装成功了

启动，关闭，开机启动docker

  • 启动dockerservice docker start
  • 验证docker启动成功docker version

看到上面有client和service两部分表示docker安装启动都成功了 ！！！

  • 设置docker开机启动systemctl enable docker
  • 停止dockersystemctl stop docker
  • 查询容器挂载的目录docker inspect 容器id | grep Mounts -A 20

启动docker容器时报错：
iptables failed: iptables --wait -t nat -A DOCKER -p tcp -d 0/0 --dport 5000 -j DNAT --to-destination 172.18.0.4:5000 ! -i br-ff45d935188b: iptables: No chain/target/match by that name. (exit status 1)
解决方案：
重启docker服务。 （注意：重启docker之前务必记录其他容器状态，防止重启docker对其他容器产生影响。）

systemctl restart docker

Docker重启时,自动重启容器

--restart=always
docker打开2375监听端口
  1. 创建一个目录用于存储生成的证书和秘钥mkdir /docker-ca && cd /docker-ca
  2. 使用openssl创建CA证书私钥，期间需要输入两次密码，生成文件为ca-key.pemopenssl genrsa -aes256 -out ca-key.pem 4096 Enter pass phrase for ca-key.pem: Your password
  3. 根据私钥创建CA证书，期间需要输入上一步设置的私钥密码，然后依次输入国家是 CN，省例如是Guangdong、市Guangzhou、组织名称、组织单位、姓名或服务器名、邮件地址，都可以随意填写，生成文件为ca.pem（注意证书有效期）openssl req -new -x509 -days 365 -key ca-key.pem -sha256 -out ca.pem
  4. 创建服务端私钥，生成文件为server-key.pemopenssl genrsa -out server-key.pem 4096
  5. 创建服务端证书签名请求文件，用于CA证书给服务端证书签名。IP需要换成自己服务器的IP地址，或者域名都可以。生成文件server.csropenssl req -subj "/CN=Your server IP" -sha256 -new -key server-key.pem -out server.csr
  6. 配置白名单，用多个用逗号隔开，例如： IP:192.168.0.1,IP:0.0.0.0，这里需要注意，虽然0.0.0.0可以匹配任意，但是仍然需要配置你的服务器IP(不能是域名)，如果省略会造成错误echo subjectAltName = IP:Your server IP,IP:0.0.0.0 >> extfile.cnf
  7. 将Docker守护程序密钥的扩展使用属性设置为仅用于服务器身份验证echo extendedKeyUsage = serverAuth >> extfile.cnf
  8. 创建CA证书签名好的服务端证书，期间需要输入CA证书私钥密码，生成文件为server-cert.pemopenssl x509 -req -days 365 -sha256 -in server.csr -CA ca.pem -CAkey ca-key.pem -CAcreateserial -out server-cert.pem -extfile extfile.cnf
  9. 创建客户端私钥，生成文件为key.pemopenssl genrsa -out key.pem 4096
  10. 创建客户端证书签名请求文件，用于CA证书给客户证书签名，生成文件client.csropenssl req -subj '/CN=client' -new -key key.pem -out client.csr
  11. 要使密钥适合客户端身份验证，请创建扩展配置文件echo extendedKeyUsage = clientAuth >> extfile.cnf
  12. 创建CA证书签名好的客户端证书，期间需要输入CA证书私钥密码，生成文件为cert.pemopenssl x509 -req -days 365 -sha256 -in client.csr -CA ca.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem -extfile extfile.cnf
  13. 删除不需要的文件，两个证书签名请求rm -v client.csr server.csr
  14. 修改证书为只读权限保证证书安全chmod -v 0400 ca-key.pem key.pem server-key.pem chmod -v 0444 ca.pem server-cert.pem cert.pem
  15. 归集服务器证书cp server-*.pem /etc/docker/ && cp ca.pem /etc/docker/

最终生成文件如下，有了它们我们就可以进行基于TLS的安全访问了

ca.pem CA证书
ca-key.pem CA证书私钥
server-cert.pem 服务端证书
server-key.pem 服务端证书私钥
cert.pem 客户端证书
key.pem 客户端证书私钥

配置Docker支持TLS
修改docker.service文件

vi /usr/lib/systemd/system/docker.service

修改以ExecStart开头的配置，开启TLS认证，并配置好CA证书、服务端证书和服务端私钥

ExecStart=/usr/bin/dockerd --tlsverify --tlscacert=/etc/docker/ca.pem --tlscert=/etc/docker/server-cert.pem --tlskey=/etc/docker/server-key.pem -H tcp\://0.0.0.0:2375 -H unix:///var/run/docker.sock

重新加载daemon

systemctl daemon-reload && systemctl restart docker

重启docker

service docker restart

拷贝8个文件到本地
idea docker要配置：TCP socket:
Engine API URL: https://14.223.93.163:2375
Certificates foler: 本地8个签名文件

由于在使用caliper时，需要用到Docker的监听端口，所以此步骤如下：

1、修改/usr/lib/systemd/system/docker.service，在[service]的ExecStart ，添加 -H tcp://0.0.0.0:2375

ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H fd:// --containerd=/run/containerd/containerd.sock

2、刷新配置文件，重启docker

systemctl daemon-reload
systemctl restart docker
配置镜像加速器

针对Docker客户端版本大于 1.10.0 的用户

您可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://szm81lc6.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

查看系统网络端口2375是否被docker所监听

netstat -tulp

测试是否监听成功

http://ip:2375
启动 Docker。
sudo systemctl start docker

通过运行 hello-world 映像来验证是否正确安装了 Docker Engine-Community 。

sudo docker run hello-world

设置docker开机启动

systemctl enable docker

停止docker

systemctl stop docker
卸载 docker
删除安装包：
yum remove docker-ce
删除镜像、容器、配置文件等内容：
rm -rf /var/lib/docker

2.查看所有镜像
docker images

多了一个镜像

3.启动一个容器
docker run -itd redis:latest

-i 表示交互式 -t 终端 -d 以后台进程的方式启动

4.启动redis

redis-server

5.删除容器及镜像

（1）首先查询容器ID

docker ps -a

(2)关闭容器

docker stop 容器ID 或容器名称

（3）删除容器

docker rm 容器ID或容器名称

（4）查看镜像ID

docker images

（5）删除容器

docker rmi 镜像ID或容器名称

6、安装MySql

1、用 docker search mysql 命令来查看可用版本：
docker search mysql
2、拉取 MySQL 镜像

这里我们拉取官方的最新版本的镜像：

// docker pull mysql:latest
docker pull mysql:5.7
3、查看本地镜像

使用以下命令来查看是否已安装了 mysql：

docker images

在上图中可以看到我们已经安装了最新版本（latest）的 mysql 镜像。

4、运行容器

安装完成后，我们可以使用以下命令来运行 mysql:5.7 容器：

docker run -itd --name mysql-test -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d  mysql:5.7

参数说明：

-p 3306:3306 ：映射容器服务的 3306 端口到宿主机的 3306 端口，外部主机可以直接通过 宿主机ip:3306 访问到 MySQL 的服务。
MYSQL_ROOT_PASSWORD=123456：设置 MySQL 服务 root 用户的密码。

5、安装成功

通过 docker ps 命令查看是否安装成功：

登录MySql
1、获取容器的id
docker ps
2、进入容器
# 把容器id替换成你自己的
docker exec -it id /bin/bash
# 也可以直接使用下面的命令，效果一样
docker exec -it mysql /bin/bash
3、输入用户名密码登录，然后就可以正常使用了

mysql -uroot -p123456

7、docker 安装redis
// 搜索所有redis镜像
docker search redis
// 下载指定版本的Redis镜像 (xxx指具体版本号)
docker pull redis:bullseye  
// 检查当前所有Docker下载的镜像
docker images

创建Redis配置文件
启动前需要先创建Redis外部挂载的配置文件 （ /home/redis/conf/redis.conf ）
之所以要先创建 , 是因为Redis本身容器只存在 /etc/redis 目录 , 本身就不创建 redis.conf 文件
当服务器和容器都不存在 redis.conf 文件时, 执行启动命令的时候 docker 会将 redis.conf 作为目录创建 , 这并不是我们想要的结果

创建目录

mkdir -p /home/redis/conf

创建文件

touch /home/redis/conf/redis.conf

下面可省略
编辑文件

vi redis.conf

加入以下文件

protected-mode no
 
port 6379
 
tcp-backlog 511
 
requirepass 123456
 
timeout 0
 
tcp-keepalive 300
 
daemonize no
 
supervised no
 
pidfile /var/run/redis_6379.pid
 
loglevel notice
 
logfile ""
 
databases 30
 
always-show-logo yes
 
save 900 1
save 300 10
save 60 10000
 
stop-writes-on-bgsave-error yes
 
rdbcompression yes
 
rdbchecksum yes
 
dbfilename dump.rdb
 
dir ./
 
replica-serve-stale-data yes
 
replica-read-only yes
 
repl-diskless-sync no
 
repl-disable-tcp-nodelay no
 
replica-priority 100
 
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
 
appendonly yes
 
appendfilename "appendonly.aof"
 
no-appendfsync-on-rewrite no
 
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
 
aof-load-truncated yes
 
aof-use-rdb-preamble yes
 
lua-time-limit 5000
 
slowlog-max-len 128
 
notify-keyspace-events ""
 
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
 
list-max-ziplist-size -2
 
list-compress-depth 0
 
set-max-intset-entries 512
 
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
 
hll-sparse-max-bytes 3000
 
stream-node-max-bytes 4096
stream-node-max-entries 100
 
activerehashing yes
 
hz 10
 
dynamic-hz yes
 
aof-rewrite-incremental-fsync yes
 
rdb-save-incremental-fsync yes
创建Redis容器并启动
本次执行命令：
docker run --name redis -p 6379:6379 \
-v /home/redis/data:/data \
-v /home/redis/conf/redis.conf:/etc/redis/redis.conf \
-d redis:bullseye redis-server /etc/redis/redis.conf

–name redis 启动容器的名字
-d 后台运行
-p 6379:6379 将容器的 6379(后面那个) 端口映射到主机的 6379(前面那个) 端口
–restart unless-stopped 容器重启策略
-v /home/redis/data:/data 将Redis储存文件夹挂在到主机
-v /home/redis/conf/redis.conf:/etc/redis/redis.conf 将配置文件夹挂在到主机
-d redis:bullseye 启动哪个版本的 Redis (本地镜像的版本)
redis-server /etc/redis/redis.conf Redis 容器中设置 redis-server 每次启动读取 /etc/redis/redis.conf 这个配置为准
--appendonly yes 在Redis容器启动redis-server服务器并打开Redis持久化配置
\ shell 命令换行

查看Redis是否运行
// 查看Docker运行中的容器
docker ps 
docker ps | grep redis

// 要有0.0.0.0:6379->6379/tcp 表示启动成功
4175589105d7   redis:bullseye   "docker-entrypoint.s…"   21 seconds ago   Up 20 seconds   0.0.0.0:6379->6379/tcp              redis

// 如启动失败
// –name 给容器起别
// -p  端口映射，宿主机：容器
// -v  目录挂载
// -d  后台启动  redis:相应版本
docker run --name myredis -p 6379:6379 -d redis:bullseye
进入Redis容器
// 通过 Docker 命令进入 Redis 容器内部
// -it 容器名字
docker exec -it redis /bin/bash
docker exec -it redis bash
// 进入 Redis 控制台
redis-cli
// 添加一个变量为 key 为 name , value 为 bella 的内容
> set name bella
// 查看 key 为 name 的 value 值
> get name
//安装redis镜像时没有设定密码，我们这里可以进行设置
config set requirepass 密码

// 查看设置的密码
config get requirepass

// 提示密码错误
NOAUTH Authentication required

// auth 密码 来进行验证
auth 123456
 
// 或者也可以直接通过Docker Redis 命令进入Redis控制台 (上面两个命令的结合)
// exec -it 容器名称
docker exec -it redis redis-cli
springboot配置Docker

IDEA安装Docker插件

setting-plugin-docker

配置Docker信息
TCP socket

Engine API URL: tcp://xx.xx.xx.xx:2375

connection successful 表示连接成功
如连接失败，需开放2375端口

docker设置端口2375

配置启动文件

1)、sudo vim /lib/systemd/system/docker.service

2)、修改下面语句

ExecStart=/usr/bin/dockerd -H unix://

ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock

在web项目src/main/resources 下新建Dockerfile

#基础镜像使用java
FROM openjdk:8-jre
#作者
MAINTAINER xkw
#VOLUME 指定临时文件目录为/tmp
#在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp
#将jar包添加到容器中并命名为app.jar
ADD *.jar app.jar

#暴露8088端口作为服务端口
EXPOSE 8088
#中文编码
ENV LANG C.UTF-8
ENV LANGUAGE zh_CN.UTF-8
ENV LC_ALL C.UTF-8
#运行jar包
ENTRYPOINT [ "java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/app.jar" ]

# docker启动项目
#docker run -e TZ="Asia/Shanghai" -v /home/project/ecg_algorithm/files/ecgData:/home/project/ecg_algorithm/files/ecgData -v /home/project/ecg_algorithm/logs:/logs --privileged=true -p 9092:9092 --name ecg-web -d ecg-web

编辑docker
在build DockerFile 选择上方文件，

在pom.xml文件中添加
<build>
        <finalName>${project.name}</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <includeSystemScope>true</includeSystemScope>
                   <!--指定启动的Application-->
                   <mainClass>cn.com.star.update.DeviceUpdateApplication</mainClass>
                </configuration>
            </plugin>

            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>

                <!--将插件绑定在某个phase执行-->
                <executions>
                    <execution>
                        <id>build-image</id>
                        <!--将插件绑定在package这个phase上。也就是说，
                        用户只需执行mvn package ，就会自动执行mvn docker:build-->
                        <phase>package</phase>
                        <goals>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>

                <configuration>
                    <!--指定生成的镜像名,这里是我们的项目名-->
                    <imageName>${project.artifactId}</imageName>
                    <!--指定标签 这里指定的是镜像的版本，我们默认版本是latest-->
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>
                    <!-- 指定我们项目中Dockerfile文件的路径-->
                    <dockerDirectory>${project.basedir}/src/main/resources</dockerDirectory>
                    <!--指定远程docker 地址-->
                    <dockerHost>http://123.57.57.46:2375</dockerHost>
                    <!-- 这里是复制 jar 包到 docker 容器指定目录配置 -->
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <!--jar包所在的路径  此处配置的即对应项目中target目录-->
                            <directory>${project.build.directory}</directory>
                            <!-- 需要包含的 jar包 ，这里对应的是 Dockerfile中添加的文件名　-->
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>

                </configuration>
            </plugin>

        </plugins>
    </build>

在idea中Edit Configuration中添加docker,build-dockFile（选择建好的DockFile，Context-folder(web/traget),Image tag(表示版本号：web:v1.0,Run端口配置 8888 8888,hostIP为空，Protocol：tcp)）,点击Modify选择Bind mount，挂载路径：/home/project/ecg_algorithm/files/ecgData:/home/project/ecg_algorithm/files/ecgData /home/project/ecg_algorithm/logs:/home/project/ecg_algorithm/logs 然后点击 Run即可一键部署

执行Maven右侧选项卡Lifecyle ——>clean ——> packages 打包，打包顺序从下往上，即最底层的依赖到最上层依次依序
执行命令：

docker run --name 容器名称 -p 8088:8088 -d 镜像名称:版本号
idea docker中文乱码的解决办法：
1、打开IDEA-HELP-Edit Custom VM  Options；
2、添加代码“-Dfile.encoding=UTF-8”；
3、重启IDEA即可。
查询docker实时日志
docker logs -f 容器名称
docker安装nginx

1.搜索nginx镜像

docker search nginx

2.拉取镜像

docker pull nginx

3、启动nginx

docker run --name mynginx -d -p 80:80 nginx:latest

4、挂载配置文件
创建挂载目录

# 创建挂载目录
mkdir -p /home/nginx/{conf,log,html}

把Nginx容器中的文件复制
nginx.conf 复制到主机

# 生成容器
docker run --name nginx -p 9001:80 -d nginx
# 将容器nginx.conf文件复制到宿主机（复制容器文件必须先启动容器）
docker cp nginx:/etc/nginx/nginx.conf /home/nginx/conf/nginx.conf
# 将容器conf.d文件夹下内容复制到宿主机
docker cp nginx:/etc/nginx/conf.d /home/nginx/conf/conf.d
# 将容器中的html文件夹复制到宿主机
docker cp nginx:/usr/share/nginx/html /home/nginx/

停止刚刚创建的nginx容器

docker stop 容器名称

删除nginx容器

docker rm 窗器ID

修改nginx/conf.d/default.conf文件,添加项目部署文件

server {
    # 替换http请求的内部端口
    listen       9092; 
    # 窗口映射外部访问端口
    listen  [::]:8093;    
    server_name  localhost;
    client_max_body_size 2048M;
    proxy_set_header Host $host:$server_port;
    proxy_set_header X-Forwarded-For $remote_addr;
    proxy_set_header X-Forwarded-Host $server_name;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Forwarded-Scheme $scheme;

    #charset koi8-r;
    
    #access_log  logs/host.access.log  main;

    # 前端
    location /  {
        root         /home/project/ecg_algorithm/front/;
        index        index.html;
    }

    # 服务端
    location ^~ /api/ {
        proxy_set_header Host $host:$server_port;
    proxy_set_header X-Forwarded-For $remote_addr;
    proxy_set_header X-Forwarded-Host $server_name;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Forwarded-Scheme $scheme;
        # 对应docker项目IP:Port   
        proxy_pass http://10.100.0.200:9092/;
        index /;
        client_max_body_size  100m;
    }

    # 上传的文件
    location /picture/ {
        # 替换项目文件存储的目录
        alias /home/project/ecg_algorithm/files/;
    }

    #location ~* \.(eot|otf|ttf|woff|svg)$ {
    #    add_header Access-Control-Allow-Origin *;
    #}

error_page   500 502 503 504  /50x.html;
       location = /50x.html {
    root   html;
    }
}

重新创建容器(把80端口映射到80，9002映射到8093端口，并挂载目录)
9002内部端口 8093指映射的外部端口，必须和default.conf文件对应好,
要把挂载的files和前端项目路径挂载出去，要和nginx.conf保持一致

docker run -p 80:80 -p 8093:9092 --restart=always --name nginx -v  /home/project/ecg_algorithm/files:/home/project/ecg_algorithm/files -v  /home/project/ecg_algorithm/front:/home/project/ecg_algorithm/front -v  /home/nginx/conf/nginx.conf:/etc/nginx/nginx.conf  -v /home/nginx/conf/conf.d:/etc/nginx/conf.d -v /home/nginx/log:/var/log/nginx -v /home/nginx/html:/usr/share/nginx/html -d nginx:latest

重启nginx
(修改default.conf文件后必须要重启nginx)

docker restart nginx
安装MQTT
  1. 拉取镜像docker pull emqx/emqx:5.0.4 docker run -d --name emqx -p 1883:1883 -p 8083:8083 -p 8084:8084 -p 8883:8883 -p 18083:18083 emqx/emqx:5.0.4#docker pull registry.cn-hangzhou.aliyuncs.com/synbop/emqttd:2.3.6
  2. 运行镜像
–name 名字
-p 18083 服务器启动端口
-p 1882 TCP端口
-p 8083 WS端口
-p 8084 WSS端口
-p 8883 SSL端口
-d 指定容器
docker run --name emq -p 18083:18083 -p 1883:1883 -p 8084:8084 -p 8883:8883 -p 8083:8083 -d registry.cn-hangzhou.aliyuncs.com/synbop/emqttd:2.3.6
  1. 进入emq服务页面 在浏览器输入机器IP:18083 就可以进入emqtt页面
9、Docker安装rabbitmq
docker pull rabbitmq
#运行
docker run -d --hostname my-rabbit --name rabbit -p 15672:15672 -p 5672:5672 rabbitmq
# 进入容器内部
docker exec -it 容器id /bin/bash
#运行
rabbitmq-plugins enable rabbitmq_management
10、Docker安装Mongodb
<!--1.pull中文版镜像-->

docker pull mongo:4

<!--2.创建目录-->

mkdir -p /mydata/mongodb/datadb

<!--3.修改目录权限-->

chmod 777 /mydata/mongodb/datadb

<!--4.运行-->

<!--准备好目录之后， 就可以开始运行 Docker 镜像了：-->

docker run -d --name mongodb -v /mydata/mongodb/datadb:/data/db -p 27017:27017 -e MONGO_INITDB_ROOT_USERNAME=admin -e MONGO_INITDB_ROOT_PASSWORD=admin --privileged=true mongo:4

<!---d 后台运行容器-->

<!----name mongodb 运行容器名-->

<!---v /mydata/mongodb/datadb:/data/db 挂载目录-->

<!---p 27017:27017：将27017映射到外部端口27017 将容器的27017端口映射到主机的27017端口，27017是和宿主机的通信接口，所有docker内部容器的连接使用27017接口，集群配置需连接容器内部27017端口，故最好保持前后端口一致-->

<!---e MONGO_INITDB_ROOT_USERNAME=admin 指定用户名-->

<!---e MONGO_INITDB_ROOT_PASSWORD=admin 指定密码-->

<!----privileged=true 使得容器内的root拥有真正的root权限。否则，container内的root只是外部的一个普通用户权限-->

<!--5.查看mongodb日志-->

docker logs mongodb

<!--6、mongodb随 docker 自启动-->

docker update mongodb --restart=always

<!--注意：这里的 gitlab 是容器的名字，不是镜像的名字。-->

<!--7 启动|停止|重启-->

docker start mongodb

docker stop mongodb

docker restart mongodb

<!--注意：这里的 mongodb 是容器的名字，不是镜像的名字。-->

<!--8、进入mongodb (optional)-->

docker exec -it mongodb /bin/bash

<!--按Ctrl+D或输入exit退出。-->
11、安装Mongodb
#下载
mkdir /opt/src
cd /opt/src
wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-5.0.8.tgz
tar zxf mongodb-linux-x86_64-rhel70-5.0.8.tgz -C /opt
mv /opt/mongodb-linux-x86_64-rhel70-5.0.8  /opt/mongodb-5.0.8
#配置环境变量
vi /etc/profile
 
#文件最后添加此配置（第一种）
export MONGODB_HOME=/opt/mongodb-5.0.8
export PATH=$PATH:${MONGODB_HOME}/bin

#刷新配置文件，使之生效
source /etc/profile

#建立日志和数据文件夹
cd /opt/mongodb-5.0.8/
mkdir data logs
#在mongodb-5.0.8 下的bin建立配置文件夹
cd /opt/mongodb-5.0.8/bin
vi mongodb.conf
# 输入如下配置
port=27017 #端口
bind_ip=0.0.0.0 #默认是127.0.0.1
dbpath=/opt/mongodb-5.0.8/data #数据库存放
logpath=/opt/mongodb-5.0.8/logs/mongodb.log #日志文件
fork=true #设置后台运行
#auth=true #开启认证
#启动mongodb
cd /opt/mongodb-5.0.8/bin
mongod --config mongodb.conf

#启动完可以先本地测试一下连接
mongo
use admin
# 创建用户名和密码
db.createUser({user: "admin",pwd: "admin",roles: [{ role: "userAdminAnyDatabase", db: "admin" }]})
# 用户名和密码登录
db.auth('admin','admin')
#创建数据库
use ai_monitor_dev
#设置数据库用户名和密码
db.createUser({user:"xkw",pwd:"xkw123",roles:[ {role:"readWrite",db:"ai_monitor_dev" } ]})
12、搭建Mqtt集群(非docker安装)

用局域网ip，或云服务器私有ip，集群服务器处于同个区域
EMQX集群搭建
要在两台服务器 192.168.1.195 192.168.1.101 上部署 EMQX 集群

需要步骤：
把emqx-centos7-v4.0.13.x86_64.rpm 上传到服务器
执行安装命令：rmp -ivh emqx-centos7-v4.0.13.x86_64.rpm
1.安装Erlang（基于Erlang互联）

2.开启emqx集群模式、集群配置

1.安装Erlang

wget https://packages.erlang-solutions.com/erlang-solutions-1.0-1.noarch.rpm

rpm -Uvh erlang-solutions-1.0-1.noarch.rpm

（上述失败时：yum -y install epel-release）

sudo yum install erlang

检验：erl

2（1）配置 192.168.1.195 节点

vi /etc/emqx/emqx.conf

修改集群模式为 static

cluster.discovery = static

#####设置节点发现列表

cluster.static.seeds = emqx@192.168.1.195,emqx@192.168.1.101

设置节点名称，请注意，节点标识必须和上面节点发现列表中的一致，否则将无法实现集群节点发现

node.name = emqx@192.168.1.195

emqx重启：

/usr/bin/emqx restart

（2）配置 192.168.1.101 节点

vi /home/emqx/emqx/etc/emqx.conf

修改集群模式为 static

cluster.discovery = static

设置节点发现列表

cluster.static.seeds = emqx@192.168.1.195,emqx@192.168.1.101

设置节点名称，请注意，节点标识必须和上面节点发现列表中的一致，否则将无法实现集群节点发现

node.name = emqx@192.168.1.101

emqx重启

/home/emqx/emqx/bin/emqx restart

进入emqx控制台，查看集群节点情况：

部署项目jar

1、在idea中打包选择 maven-lifecycle-package,先打依赖包再打主项目jar。
2、修改DockFile文件
monitor_center-0.0.1-SNAPSHOT.jar 表示架包名称
monitor_center 拷贝到data目录下并重新命名
8773指项目内部端口

FROM openjdk:8 MAINTAINER xh ADD monitor_center-0.0.1-SNAPSHOT.jar /data/monitor_center.jar EXPOSE 8773 ENTRYPOINT ["java","-jar","/data/monitor_center.jar"]

2、修改dockerstart 文件

#!/bin/sh

WORKSPACE=''
PROJECT=''
# 替换项目路径
TARGET='/home/project/ai_monitor' #DockerFile路径
#替换项目名称
NAME='monitor_center' #项目名称
#替换项目端口
PORT='8775' #容器暴露端口
EXPORT='8775' #主机暴露端口
CID=$(docker ps -a | grep "$NAME" | awk '{print $1}')
#修改Jar包名对应上方架包命名
CONTAINER_NAME='monitor_center' #Jar包名

echo ===容器ID $CID

# 以下为jenkins用复制jar脚本 start
#cd $WORKSPACE$PROJECT
#echo ===当前路径
#pwd

#echo ===复制文件开始===

#cp $CONTAINER_NAME*.jar $TARGET

#echo ===复制文件结束===

# end

# docker操作
cd $TARGET

echo ===当前路径
pwd

if [ "$CID" ]; then
echo "存在容器$NAME, CID-$CID"
echo ===停止docker容器===

docker stop $NAME

echo ===删除docker容器===
docker rm $NAME
docker rmi $NAME
fi

echo ===构建docker镜像开始===
docker build -f Dockerfile . -t $NAME
echo ===构建docker镜像结束===

echo ===启动docker容器===
# 替换项目文件存储路径 -v 把容器内日志文件挂载在/home/project/ai_monitor/logs 冒号":"前面的目录是宿主机目录，后面的目录是容器内目录

docker run -e TZ="Asia/Shanghai" -v /home/project/ai_monitor/files:/home/project/ai_monitor/files -v /home/project/ai_monitor/logs:/logs --privileged=true -p $PORT:$PORT --name $NAME -d $NAME

3、修改nginx文件
cd /usr/local/nginx/conf/
vi nginx.conf
:w! 不保存退出 :wq!保存退出

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    #AI监护仪
    server {
        # 替换http请求的外部端口
        listen       8093;
        server_name  localhost;
        client_max_body_size 2048M;
        proxy_set_header Host $host:$server_port;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header X-Forwarded-Host $server_name;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Scheme $scheme;

        #charset koi8-r;
        
        #access_log  logs/host.access.log  main;

        # 前端
        location /  {
            root         /home/project/ai_monitor/front/;
            index        index.html;
        }

        # 服务端
        location ^~ /api/ {
            proxy_set_header Host $host:$server_port;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header X-Forwarded-Host $server_name;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Scheme $scheme;
            proxy_pass http://123.60.101.61:8775/;
            index /;
            client_max_body_size  100m;
        }

        # 上传的文件
        location /picture/ {
            # 替换项目文件存储的目录
            alias /home/project/ai_monitor/files/;
        }

        #location ~* \.(eot|otf|ttf|woff|svg)$ {
        #    add_header Access-Control-Allow-Origin *;
        #}

    error_page   500 502 503 504  /50x.html;
           location = /50x.html {
        root   html;
        }
    }  

    server {
        listen       80;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }

    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}
}

4、启动dockerstart文件

sh dockerstart.sh

#查询实时日志
docker logs -f 容器名称

5、重启nginx

#进入到nginx/sbin/
cd /usr/local/nginx/sbin/

#检查配置文件语法
./nginx -t
/nginx/ -tc /usr/local/nginx/conf/nginx.conf
nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful
# 重新加载
/nginx/ -s reload

查询日志文件

#外部访问文件时文件夹必须授权
chmod 777 文件夹
#进入内部容器
docker exec -it 容器id /bin/bash
#日志文件保存在根目录
cd /
cd logs/
# 挂载目录 -v
docker run  -v /home/project/ai_monitor/files:/home/project/ai_monitor/files -v /home/project/ai_monitor/logs:/logs --privileged=true -p $PORT:$PORT --name $NAME -d $NAME

Linux常用命令

#查询当前所在目录
pwd
# 查询java进程
ps -ef | grep java
# 列出目前所有的正在内存当中的程序
ps -aux
# 定位文件目录
whereis 文件名
#  查找文件
find / -name '文件名'
<!--下载文件命令：-->
docker cp containerID(CONTAINERNAME)：容器内要拷贝的文件或文件夹路径 要拷贝到宿主机内的目标路径
示例： docker cp mykenkins:/logs /home/project/
mv myfile mydir  #移动目录或文件
cp myfile myfir  #复制目录或文件
docker安装rockerMQ

#拉取镜像

#服务
docker pull foxiswho/rocketmq:server-4.7.0
#代理
docker pull foxiswho/rocketmq:broker-4.7.0

创建目录

mkdir /opt/rocketmq-server
mkdir /opt/rocketmq-broker/conf -p

创建代理配置文件
[root@localhost opt]# cat /opt/rocketmq-broker/conf/broker.conf

namesrvAddr=192.168.1.200:9876
brokerClusterName = DefaultCluster
brokerName = broker-a
brokerId = 0
deleteWhen = 04
fileReservedTime = 48
brokerRole = ASYNC_MASTER
flushDiskType = ASYNC_FLUSH
brokerIP1 = 192.168.1.200
listenPort=10911

启动服务

#启动rocketmq-server
docker run -d \
--restart=always \
--name rmqnamesrv \
-p 9876:9876 \
-v /opt/rocketmq-server/logs:/root/logs \
-v /opt/rocketmq-server/store:/root/store \
-e "MAX_POSSIBLE_HEAP=100000000" \
foxiswho/rocketmq:server-4.7.0 \
sh mqnamesrv

#如报错
#docker: Error response from daemon: driver failed programming external connectivity on endpoint rmqnamesrv (ab8f847cc722d9c07c6ad8cfb29880fe2e27080af158e5a684bbac87a1c3fa86):  (iptables failed: iptables --wait -t nat -A DOCKER -p tcp -d 0/0 --dport 9876 -j DNAT --to-destination 172.17.0.5:9876 ! -i docker0: iptables: No chain/target/match by that name.
#解决方法：输入指令   重启docker服务及可重新生成自定义链DOCKER
systemctl restart docker     

#启动rocketmq-broker
docker run -d  \
--restart=always \
--name rmqbroker \
--link rmqnamesrv:namesrv \
-p 10911:10911 \
-p 10909:10909 \
-v  /opt/rocketmq-broker/logs:/root/logs \
-v  /opt/rocketmq-broker/store:/root/store \
-v /opt/rocketmq-broker/conf/broker.conf:/opt/rocketmq-4.7.0/conf/broker.conf \
-e "NAMESRV_ADDR=namesrv:9876" \
-e "MAX_POSSIBLE_HEAP=200000000" \
-e "autoCreateTopicEnable=true" \
foxiswho/rocketmq:broker-4.7.0 \
sh mqbroker -c /opt/rocketmq-4.7.0/conf/broker.conf

#启动RocketMQ的管理工具rocketmq-console
docker run -itd -e "JAVA_OPTS=-Drocketmq.namesrv.addr=192.168.1.200:9876 -Dcom.rocketmq.sendMessageWithVIPChannel=false" -p 8082:8080 -t styletang/rocketmq-console-ng:latest
docker启动nacos（单机模式、集群模式）

1.拉取nacos镜像

docker pull nacos/nacos-server:v2.1.2

2.将nacos容器中的文件拷贝到主机上，以便挂载
2.1.先以单机模式运行nacos

docker run -d --name nacos -p 8848:8848 nacos/nacos-server:v2.1.2

查看运行过程：docker logs -f nacos

2.2.将nacos文件拷贝到主机上的/app目录下

docker cp nacos:/home/nacos /app

ps：nacos在docker中的默认存放位置为/home/nacos

2.3.删除nacos容器

docker rm -f nacos

3.创建nacos数据库
找到/app/nacos/config下的mysql-schema.sql文件，复制里面的内容在mysql中运行，然后会自动生成数据表

4.运行nacos
4.1.以单机模式运行nacos，并使用mysql存储信息

docker run -d --name nacos \
-p 8848:8848 \
-p 9848:9848 \
-p 9849:9849 \
--restart=always \
-v /app/nacos/logs:/home/nacos/logs \
-v /app/nacos/data:/home/nacos/data \
-v /app/nacos/config:/home/nacos/config \
-e MODE=standalone \
-e SPRING_DATASOURCE_PLATFORM=mysql \
-e MYSQL_SERVICE_HOST=192.168.0.200 \  #数据库地址
-e MYSQL_SERVICE_PORT=3306 \
-e MYSQL_SERVICE_DB_NAME=nacos_2.1.2 \ #数据库名称
-e MYSQL_SERVICE_USER=root \   
-e MYSQL_SERVICE_PASSWORD=RUI2ghlmcl \
nacos/nacos-server:v2.1.2

4.2.以集群模式运行nacos，并使用mysql存储信息

docker run -d  \
-p 8848:8848 \
-p 9848:9848 \
-p 9849:9849 \
--restart=always \
-v /app/nacos/logs:/home/nacos/logs \
-v /app/nacos/data:/home/nacos/data \
-v /app/nacos/config:/home/nacos/config \
-e MODE=cluster \
-e NACOS_SERVERS='10.100.0.200:8848 10.100.0.205:8848' \
-e SPRING_DATASOURCE_PLATFORM=mysql \
-e MYSQL_SERVICE_HOST=192.168.0.200 \
-e MYSQL_SERVICE_PORT=3306 \
-e MYSQL_SERVICE_DB_NAME=nacos_2.1.2 \
-e MYSQL_SERVICE_USER=root \
-e MYSQL_SERVICE_PASSWORD=RUI2ghlmcl \
-e TZ=Asia/Shanghai \
--name nacos-cluster nacos/nacos-server:v2.1.2

nacos2

docker run -d --name nacos-cluster \
-p 8848:8848 \
-p 9848:9848 \
-p 9849:9849 \（9848、9849为nacos2.X新增端口，不加的话SpringBoot服务会注册失败）
–net host \（从桥接模式改成主机模式，用主机的ip地址，不然注册服务可能会出错）
–restart always \（前面为两个短杠，记得修改）
-v /app/nacos/logs:/home/nacos/logs \
-v /app/nacos/data:/home/nacos/data \
-v /app/nacos/config:/home/nacos/config \
-e MODE=cluster \
-e NACOS_SERVERS=192.168.137.134:8848 \（此处为指向其他集群服务的ip地址，如果有多个ip则用单引号括起来）
-e SPRING_DATASOURCE_PLATFORM=mysql \
-e MYSQL_SERVICE_HOST=192.168.137.134 \
-e MYSQL_SERVICE_PORT=3306 \
-e MYSQL_SERVICE_DB_NAME=nacos \
-e MYSQL_SERVICE_USER=root \
-e MYSQL_SERVICE_PASSWORD=数据库密码 \
-e TZ=Asia/Shanghai \（不加时间注册服务时可能会报错）
nacos/nacos-server:v2.1.2
创建文件服务器（用于生成url访问）

1、CentOS7中安装httpd

yum install httpd

httpd -version

2、修改配置
httpd的配置文件是/etc/httpd/conf/httpd.conf

vi /etc/httpd/conf/httpd.conf
#服务端口设置为8000
Listen 8000
service httpd start ：启动
service httpd restart：重新启动
service httpd stop ：停止服务
systemctl enable httpd ：开机自启动

3、测试
在配置文件中可以发现，服务器默认的访问路径在/var/www/html目录下。进入/var/www/html目录，新建一个test.sh文件，输入hello

查询开放端口
netstat -anp

1、开启防火墙

systemctl start firewalld

2、开放指定端口

firewall-cmd --zone=public --add-port=1935/tcp --permanent

命令含义：
--zone #作用域
--add-port=1935/tcp #添加端口，格式为：端口/通讯协议
--permanent #永久生效，没有此参数重启后失效

3、重启防火墙

firewall-cmd --reload

访问nacos客户端
http://10.100.0.200:8848/nacos

标签： linux java 运维
本文转载自: https://blog.csdn.net/u014575452/article/details/140003149
版权归原作者 不放棄 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Linux 部署Java项目”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

docker无法搜索和拉取镜像

visual studio之安装详解

【Linux】版本控制器git、调试器gdb/cgdb

面试题：RabbitMQ（一）

Vllm进行Qwen2-vl部署（包含单卡多卡部署及爬虫请求）

MySQL wait_timeout参数介绍

Python毕业设计选题：基于django+vue的企业it资产管理系统

文章导航