java开发环境配置(linux docker)

Linux开发环境配置（Docker）

使用的是 VMware + CentOS7

(虚拟机系统安装过程略)

下面命令注意在root用户下运行，避免重复 sudo 省略

复制代码

su - root

Docker

安装Docker

参考：Docker 安装文档

1. 删除老版本

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

2. 安装工具包并设置存储库

sudo yum install -y yum-utils
​
sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

3. 安装docker引擎

sudo yum install docker-ce docker-ce-cli containerd.io

Docker使用

1. 启动docker

sudo systemctl start docker

2. 设置开机启动docker

1. 检查docker版本

docker -v

1. 查看docker已有镜像

sudo docker images

1. 设置docker开机启动

sudo systemctl enable docker

3. 设置国内镜像仓库

参考：阿里云镜像加速服务

# 创建文件
sudo mkdir -p /etc/docker
# 修改配置, 设置镜像
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://vw9qapdy.mirror.aliyuncs.com"]
}
EOF
# 重启后台线程
sudo systemctl daemon-reload
# 重启docker
sudo systemctl restart docker

MySQL of Docker

1. docker安装mysql

sudo docker pull mysql:5.7

2. docker启动mysql

sudo docker run -p 3306:3306 --name mysql \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7

参数：

• -p 3306:3306：将容器的3306端口映射到主机的3306端口

• --name：给容器命名

• -v /mydata/mysql/log:/var/log/mysql：将配置文件挂载到主机/mydata/..

• -e MYSQL_ROOT_PASSWORD=root：初始化root用户的密码为root

查看docker启动的容器:

docker ps

3. 配置mysql

1. 进入挂载的mysql配置目录

cd /mydata/mysql/conf

1. 修改配置文件 my.cnf

vi my.cnf

拷贝以下内容：

[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
init_connect='SET collation_connection = utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
​
# Esc
# :wq

1. docker重启mysql使配置生效

docker restart mysql

Redis of Docker

1. docker拉取redis镜像

docker pull redis

2. docker启动redis

1. 创建redis配置文件目录

mkdir -p /mydata/redis/conf
​
touch /mydata/redis/conf/redis.conf

1. 启动redis容器

docker run -p 6379:6379 --name redis \
-v /mydata/redis/data:/data \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf

3. 配置redis持久化

更多redis配置参考：redis配置

echo "appendonly yes"  >> /mydata/redis/conf/redis.conf
​
# 重启生效
docker restart redis

容器随docker启动自动运行

# mysql
docker update mysql --restart=always
​
# redis
docker update redis --restart=always

Docker安装Elasticsearch、Kibana

1. 下载镜像文件

# 存储和检索数据
docker pull elasticsearch:7.4.2
​
# 可视化检索数据
docker pull kibana:7.4.2

2. 配置挂载数据文件夹

# 创建配置文件目录
mkdir -p /mydata/elasticsearch/config
​
# 创建数据目录
mkdir -p /mydata/elasticsearch/data
​
# 将/mydata/elasticsearch/文件夹中文件都可读可写
chmod -R 777 /mydata/elasticsearch/
​
# 配置任意机器可以访问 elasticsearch
echo "http.host: 0.0.0.0" >/mydata/elasticsearch/config/elasticsearch.yml

3. 启动Elasticsearch

命令后面的 \是换行符，注意前面有空格

docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e  "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m -Xmx512m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v  /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.4.2 

• -p 9200:9200 -p 9300:9300：向外暴露两个端口，9200用于HTTP REST API请求，9300 ES 在分布式集群状态下 ES 之间的通信端口；

• -e "discovery.type=single-node"：es 以单节点运行

• -e ES_JAVA_OPTS="-Xms64m -Xmx512m"：设置启动占用内存，不设置可能会占用当前系统所有内存

• -v：挂载容器中的配置文件、数据文件、插件数据到本机的文件夹；

• -d elasticsearch:7.6.2：指定要启动的镜像

访问 IP:9200 看到返回的 json 数据说明启动成功。

4. 设置 Elasticsearch 随Docker启动

# 当前 Docker 开机自启，所以 ES 现在也是开机自启

docker update elasticsearch --restart=always

5. 启动可视化Kibana

docker run --name kibana \
-e ELASTICSEARCH_HOSTS=http://192.168.163.131:9200 \
-p 5601:5601 \
-d kibana:7.4.2

-e ELASTICSEARCH_HOSTS=``http://192.168.163.131:9200: 这里要设置成自己的虚拟机IP地址

浏览器输入192.168.163.131:5601 测试

1. 设置 Kibana 随Docker启动

# 当前 Docker 开机自启，所以 kibana 现在也是开机自启
docker update kibana --restart=always

安装IK分词器

1. 下载

事前准备：

• IK 分词器属于 Elasticsearch 的插件，所以 IK 分词器的安装目录是 Elasticsearch 的 plugins 目录，在我们使用Docker启动 Elasticsearch 时，已经将该目录挂载到主机的 /mydata/elasticsearch/plugins 目录。

• IK 分词器的版本需要跟 Elasticsearch 的版本对应，当前选择的版本为 7.4.2，下载地址为：Github Release 或访问：镜像地址

# 进入挂载的插件目录 /mydata/elasticsearch/plugins
cd /mydata/elasticsearch/plugins
​
# 安装 wget 下载工具
 yum install -y wget
​
# 下载对应版本的 IK 分词器（这里是7.4.2）
wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.4.2/elasticsearch-analysis-ik-7.4.2.zip

这里已经在挂载的 plugins 目录安装好了 IK分词器。现在我们进入到 es 容器内部检查是否成功安装

# 进入容器内部
docker exec -it elasticsearch /bin/bash
​
# 查看 es 插件目录
ls /usr/share/elasticsearch/plugins
​
# 可以看到 elasticsearch-analysis-ik-7.4.2.zip

所以我们之后只需要在挂载的目录/mydata/elasticsearch/plugins下进行操作即可。

2. 解压

# 进入到 es 的插件目录
cd /mydata/elasticsearch/plugins
​
# 解压到 plugins 目录下的 ik 目录
unzip elasticsearch-analysis-ik-7.4.2.zip -d ik
​
# 删除下载的压缩包
 rm -f elasticsearch-analysis-ik-7.4.2.zip 
​
# 修改文件夹访问权限
chmod -R 777 ik/

3. 查看安装的ik插件

# 进入 es 容器内部
docker exec -it elasticsearch /bin/bash
​
# 进入 es bin 目录
cd /usr/share/elasticsearch/bin
​
# 执行查看命令  显示 ik
elasticsearch-plugin list
​
# 退出容器
exit
​
# 重启 Elasticsearch
docker restart elasticsearch

4. 测试 ik 分词器

GET my_index/_analyze

GET my_index/_analyze
{
   "analyzer": "ik_max_word", 
   "text":"蔡徐坤"
}

Docker启动nacos

docker run --name nacos -d -p 8848:8848 --privileged=true \
--restart=always \
-e JVM_XMS=512m \
-e JVM_XMX=2048m \
-e MODE=standalone \
-e PREFER_HOST_MODE=hostname \
-v /home/nacos/logs:/home/nacos/logs \
nacos/nacos-server:1.2.1

Docker 安装 RabbitMQ

docker run -d --name rabbitmq -p 5671:5671 -p 5672:5672 -p 4369:4369 -p  25672:25672 -p 15671:15671 -p 15672:15672 rabbitmq:management

4369,25672(Erlang发现&集群端口)

5672,5671(AMQP端口)

15672 (web管理后台端口)

61613,61614(STOMP协议端口)

1883,8883(MQTT协议端口)

RabbitMQ随docker自动启动

docker update rabbitmq --restart=always

https://www.rabbitmq.com/networking.html

死性队列（死性交换机插件安装）

安装

1. 首先我们将刚下载下来的
rabbitmq_delayed_message_exchange-3.9.0.ez文件上传到RabbitMQ所在服务器
2. 切换到插件所在目录，
执行 docker cp rabbitmq_delayed_message_exchange-3.9.0.ez rabbitmq:/plugins 命令，将刚插件拷贝到容器内plugins目录下
3. 执行 docker exec -it rabbitmq /bin/bash 
命令进入到容器内部，并 cd plugins 进入plugins目录
4. 执行 ls -l|grep delay  命令查看插件是否copy成功
5. 在容器内plugins目录下，执行 rabbitmq-plugins enable rabbitmq_delayed_message_exchange  命令启用插件
6. exit命令退出RabbitMQ容器内部，然后执行 docker restart rabbitmq 命令重启RabbitMQ容器

下载地址:Releases · rabbitmq/rabbitmq-delayed-message-exchange · GitHub

使用版本：rabbitmq_delayed_message_exchange-3.9.0.ez

压力测试工具

jvisualvm: win+R 控制台输入jvisualvm即可

jmeter：官网下载

1、jvisualvm 监控内存泄露，跟踪垃圾回收，执行时内存、cpu 分析，线程分析...

运行：正在运行的

休眠：sleep

等待：wait

驻留：线程池里面的空闲线程

监视：阻塞的线程，正在等待锁

2、安装插件方便查看 gc

Cmd 启动 jvisualvm 工具->插件 如果 503 错误解决： 打开网址 VisualVM: Plugins Centers

cmd 查看自己的 jdk 版本，找到对应的 复制下面查询出来的链接。并重新设置上即可

1、性能指标

响应时间（Response Time: RT） 响应时间指用户从客户端发起一个请求开始，到客户端接收到从服务器端返回的响 应结束，整个过程所耗费的时间。

HPS（Hits Per Second） ：每秒点击次数，单位是次/秒。

TPS（Transaction per Second）：系统每秒处理交易数，单位是笔/秒。

QPS（Query per Second）：系统每秒处理查询次数，单位是次/秒。 对于互联网业务中，如果某些业务有且仅有一个请求连接，那么 TPS=QPS=HPS，一 般情况下用 TPS 来衡量整个业务流程，用 QPS 来衡量接口查询次数，用 HPS 来表 示对服务器单击请求。  无论 TPS、QPS、HPS,此指标是衡量系统处理能力非常重要的指标，越大越好，根据经 验，一般情况下： 金融行业：1000TPS~50000TPS，不包括互联网化的活动 保险行业：100TPS~100000TPS，不包括互联网化的活动 制造行业：10TPS~5000TPS 互联网电子商务：10000TPS~1000000TPS 互联网中型网站：1000TPS~50000TPS 互联网小型网站：500TPS~10000TPS

最大响应时间（Max Response Time） 指用户发出请求或者指令到系统做出反应（响应） 的最大时间。

最少响应时间（Mininum ResponseTime） 指用户发出请求或者指令到系统做出反应（响 应）的最少时间。

90%响应时间（90% Response Time） 是指所有用户的响应时间进行排序，第 90%的响 应时间。

从外部看，性能测试主要关注如下三个指标 吞吐量：每秒钟系统能够处理的请求数、任务数。 响应时间：服务处理一个请求或一个任务的耗时。 错误率：一批请求中结果出错的请求所占比例。

1、JMeter 安装 Apache JMeter - Download Apache JMeter 下载对应的压缩包，解压运行 jmeter.bat 即可

具体使用看官方教程

分布式seata的安装

每一个要使用分布式事务的数据库都需要一个 UNDO_LOG 表。

CREATE TABLE `undo_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(100) NOT NULL,
  `context` varchar(128) NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int(11) NOT NULL,
  `log_created` datetime NOT NULL,
  `log_modified` datetime NOT NULL,
  `ext` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

二、Linux 安装 Seata 0.7.1

cd /mydata

# 创建文件夹
mkdir seata
​
# 进入
cd seata
​
# 下载
wget https://github.com/seata/seata/releases/download/v0.7.1/seata-server-0.7.1.tar.gz
​
# 解压
tar -xvf seata-server-0.1.1.tar.gz

# 修改配置
vi conf/registry.conf

registry {
  # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
  type = "nacos"
​
  nacos {
    serverAddr = "自己的ip:8848"
    namespace = "public"
    cluster = "default"
  }
}

# 切换到bin目录
cd bin/
​
# 启动 seata-server
sh seata-server.sh -p 8091 -h 自己的ip

启动seata需要安装jdk

linux安装jdk，教程略

docker安装seata

下载零时seata

docker pull seataio/seata-server:1.3.0

导出配置

docker run --name seata-server -p 8091:8091 -d  seataio/seata-server:1.3.0


docker cp seata-server:/seata-server /mydata/seata/


docker stop seata-server


docker rm -f seata-server

进入配置文件修改配置

cd /mydata/seata

修改file.conf

transport {
  # tcp udt unix-domain-socket
  type = "TCP"
  #NIO NATIVE
  server = "NIO"
  #enable heartbeat
  heartbeat = true
  #thread factory for netty
  thread-factory {
    boss-thread-prefix = "NettyBoss"
    worker-thread-prefix = "NettyServerNIOWorker"
    server-executor-thread-prefix = "NettyServerBizHandler"
    share-boss-worker = false
    client-selector-thread-prefix = "NettyClientSelector"
    client-selector-thread-size = 1
    client-worker-thread-prefix = "NettyClientWorkerThread"
    # netty boss thread size,will not be used for UDT
    boss-thread-size = 1
    #auto default pin or 8
    worker-thread-size = 8
  }
  shutdown {
    # when destroy server, wait seconds
    wait = 3
  }
  serialization = "seata"
  compressor = "none"
}
service {
  #vgroup->rgroup
  vgroup_mapping.gulimall-order-fescar-service-group = "default"
  #only support single node
  default.grouplist = "127.0.0.1:8091"
  #degrade current not support
  enableDegrade = false
  #disable
  disable = false
  #unit ms,s,m,h,d represents milliseconds, seconds, minutes, hours, days, default permanent
  max.commit.retry.timeout = "-1"
  max.rollback.retry.timeout = "-1"
}

client {
  async.commit.buffer.limit = 10000
  lock {
    retry.internal = 10
    retry.times = 30
  }
  report.retry.count = 5
}

## transaction log store
store {
  ## store mode: file、db
  mode = "file"

  ## file store
  file {
    dir = "sessionStore"

    # branch session size , if exceeded first try compress lockkey, still exceeded throws exceptions
    max-branch-session-size = 16384
    # globe session size , if exceeded throws exceptions
    max-global-session-size = 512
    # file buffer size , if exceeded allocate new buffer
    file-write-buffer-cache-size = 16384
    # when recover batch read size
    session.reload.read_size = 100
    # async, sync
    flush-disk-mode = async
  }

  ## database store
  db {
    ## the implement of javax.sql.DataSource, such as DruidDataSource(druid)/BasicDataSource(dbcp) etc.
    datasource = "dbcp"
    ## mysql/oracle/h2/oceanbase etc.
    db-type = "mysql"
    url = "jdbc:mysql://数据库ip:3306/数据库"
    user = "root"
    password = "root"
    min-conn = 1
    max-conn = 3
    global.table = "global_table"
    branch.table = "branch_table"
    lock-table = "lock_table"
    query-limit = 100
  }
}
lock {
  ## the lock store mode: local、remote
  mode = "remote"

  local {
    ## store locks in user's database
  }

  remote {
    ## store locks in the seata's server
  }
}
recovery {
  committing-retry-delay = 30
  asyn-committing-retry-delay = 30
  rollbacking-retry-delay = 30
  timeout-retry-delay = 30
}

transaction {
  undo.data.validation = true
  undo.log.serialization = "jackson"
}

## metrics settings
metrics {
  enabled = false
  registry-type = "compact"
  # multi exporters use comma divided
  exporter-list = "prometheus"
  exporter-prometheus-port = 9898
}

修改registry.conf

registry {
  # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
  type = "nacos"

  nacos {
    serverAddr = "nacosIP地址:8848"
    namespace = "public"
    cluster = "default"
  }
  eureka {
    serviceUrl = "http://localhost:1001/eureka"
    application = "default"
    weight = "1"
  }
  redis {
    serverAddr = "localhost:6379"
    db = "0"
  }
  zk {
    cluster = "default"
    serverAddr = "127.0.0.1:2181"
    session.timeout = 6000
    connect.timeout = 2000
  }
  consul {
    cluster = "default"
    serverAddr = "127.0.0.1:8500"
  }
  etcd3 {
    cluster = "default"
    serverAddr = "http://localhost:2379"
  }
  sofa {
    serverAddr = "127.0.0.1:9603"
    application = "default"
    region = "DEFAULT_ZONE"
    datacenter = "DefaultDataCenter"
    cluster = "default"
    group = "SEATA_GROUP"
    addressWaitTime = "3000"
  }
  file {
    name = "file.conf"
  }
}

config {
  # file、nacos 、apollo、zk、consul、etcd3
  type = "file"

  nacos {
    serverAddr = "localhost"
    namespace = "public"
    cluster = "default"
  }
  consul {
    serverAddr = "127.0.0.1:8500"
  }
  apollo {
    app.id = "seata-server"
    apollo.meta = "http://192.168.1.204:8801"
  }
  zk {
    serverAddr = "127.0.0.1:2181"
    session.timeout = 6000
    connect.timeout = 2000
  }
  etcd3 {
    serverAddr = "http://localhost:2379"
  }
  file {
    name = "file.conf"
  }
}

启动seata

docker run -d --restart always  --name  seata-server -p 8091:8091  -v /mydata/seata:/seata-server -e SEATA_IP=ip地址 -e SEATA_PORT=8091 seataio/seata-server:1.3.0

Docker 安装使用 nginx

1. 创建要挂载的配置目录

mkdir -p /mydata/nginx/conf

2. 启动临时nginx容器

docker run -p 80:80 --name nginx -d nginx:1.10

3. 拷贝出 Nginx 容器的配置

# 将nginx容器中的nginx目录复制到本机的/mydata/nginx/conf目录
​​​​​​​docker container cp nginx:/etc/nginx /mydata/nginx/conf

# 复制的是nginx目录，将该目录的所有文件移动到 conf 目录
​​​​​​​mv /mydata/nginx/conf/nginx/* /mydata/nginx/conf/

# 删除多余的 /mydata/nginx/conf/nginx目录
​​​​​​​rm -rf /mydata/nginx/conf/nginx

4. 删除临时nginx容器

# 停止运行 nginx 容器
docker stop nginx

# 删除 nginx 容器

docker rm nginx

5. 启动 nginx 容器

docker run -p 80:80 --name nginx \
-v /mydata/nginx/html:/usr/share/nginx/html \

-v /mydata/nginx/logs:/var/log/nginx \

-v /mydata/nginx/conf/:/etc/nginx \

-d nginx:1.10

6. 设置 nginx 随 Docker 启动

docker update nginx --restart=always

Docker 安装使用 Sentinel

# 下载
docker pull bladex/sentinel-dashboard:1.6.3
​
# 运行
docker run --name sentinel  -d -p 8858:8858 -d  bladex/sentinel-dashboard:1.6.3
​
# 开机自启
docker update sentinel --restart=always

小问题

启动项目后访问接口，发现 sentinel 实时监控中一直显示为空白状态，一般是 sentinel 服务器和项目服务器时间不一致造成的，此时就需要同步虚拟机与项目服务器的时间，重启服务器、项目服务器，测试即可。

自动同步时间

# 安装时间同步插件
yum install chrony -y
​
# 启动时间同步
systemctl start chronyd
​
# 开机自启
systemctl enable chronyd

docker 安装 zipkin

docker run -d -p 9411:9411 openzipkin/zipkin
​
docker update zipkin --restart=always