一、docker的安装及常用容器的生成

1.1、卸载旧版本docker

用root账号执行：

yum remove docker \
docker-client \
docker-client-latest \
docker- common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-sqlinux \
docker-engine-selinux \
docker-engine \
docker-ce

1.2、安装必备工具

查看当前linux的版本号(centos7才能装)

cat /etc/redhat-release

uname -a

设置stable镜像仓库
官方：（巨坑：外网根本连不上）

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

推荐：阿里云

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

安装gcc相关

yum -y install gcc

yum -y install gcc-c++

yum install -y yum-utils

安装Docker-ce

在新主机首次安装 Docker Engine-Community之前，需要设置Docker仓库，之后，您可以从仓库安装和更新 Docker。
设置仓库，需要安装所需的软件包。yum-utils 提供了 yum-config-manager ，并且 device mapper
存储驱动程序需要 device-mapper-persistent-data 和 lvm2。 Device Mapper 是
Linux2.6 内核中支持逻辑卷管理的通用设备映射机制，它为实现用于存储资源管理的块设备驱动提供了一个高度模块化的内核架构。
LVM（Logical Volume Manager）逻辑卷管理。
它是对磁盘分区进行管理的一种机制，建立在硬盘和分区之上的一个逻辑层，用来提高磁盘管理的灵活性。通过LVM可将若干个磁盘分区连接为一个整块的卷组(Volume
Group)，形成一个存储池。可以在卷组上随意创建逻辑卷(Logical
Volumes)，并进一步在逻辑卷上创建文件系统，与直接使用物理存储在管理上相比，提供了更好灵活性。
device-mapper-persistent-data 和 lvm2 两者都是Device Mapper所需要的。

安装yum工具
yum install -y yum-utils device-mapper-persistent-data lvm2

1.3、告诉linux去哪里下载安装docker

设置stable镜像仓库(阿里云)

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

更新yum软件包索引: yum makecache fast

1.4、安装docker

方式一，不指定版本 安装最新版 官网：yum -y install docker-ce docker-ce-cli containerd.io
方式二，指定版本 安装指定版本： yum install -y docker-ce-20.10.7 docker-ce-cli-20.10.7 containerd.io-1.4.6

查看版本：docker version
启动：systemctl start docker
停止：systemctl stop docker
状态：systemctl status docker
docker在服务器开机自启动：systemctl enable docker
卸载：
yum remove docker-ce docker-ce-li containerd.io
rm -rf /var/lib/docker
rm -rf /var/lib/containerd

1.5、配置镜像加速

登录阿里云: https://www.aliyun.com/
新版阿里云镜像加速器地址 https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors
登录后点击控制台，选择左边的
产品与服务--->容器与镜像服务--->镜像加速器 --->centos
依次执行：(在root账号下)

1、mkdir -p /etc/docker
2、tee /etc/docker/daemon.json <<-‘EOF’ {
“registry-mirrors”: [“https://xxxxxx.mirror.aliyuncs.com”]
}
EOF
3、systemctl daemon-reload
4、 systemctl restart docker

遇到阿里云镜像加速器失效，无论怎么拉取都显示连接拒绝。解决办法，换华为云：

华为云 登录华为云 产品–容器–容器镜像服务SWR — 控制台 — 镜像资源 —镜像中心 — 右上角有个镜像加速器
点击就可以看到自己的镜像加速地址

1.6、docker开机自启动设置

设置容器在docker重启时自动启动(以mysql为例)：
容器在docker启动时跟随启动：docker update mysql --restart=always
取消开机自启动：docker update mysql --restart=no
docker在服务器开机自启动：systemctl enable docker

进入容器内部的系统，修改容器内容
docker exec -it 容器id /bin/bash

1.7、安装docker-compose

1.7.1 版本查询git地址：

https://github.com/docker/compose/releases/

1.7.2 安装docker-compose命令:

curl -L https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
其中1.27.4是版本号可以更改，例如2.2.2

1.7.3 授权

chmod +x /usr/local/bin/docker-compose

1.7.4 检查版本

1.27.4的查询方法 docker-compose -version
2.2.2的查询方法 docker-compose version

二、docker安装常用镜像

2.1 docker安装mysql

步骤1：创建文件夹

 mkdir -p /mydata/mysql/log /mydata/mysql/data /mydata/mysql/conf

步骤2：创建简单数据库(需要拷贝配置)

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

步骤3：复制配置文件到宿主机

docker cp sample-mysql:/etc/mysql/. /mydata/mysql/conf

步骤4：删除mysql

docker rm -f sample-mysql

步骤5：安装mysql

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=000000 \
-d mysql:5.7

参数解释： docker run是启动一个容器
-p 3306:3306 :是宿主机的3306 对应docker容器内部的3306端口
--name mysql: 是给容器起一个名字
-v /mydata/mysql/log:/var/log/mysql: 其中-v的意思是挂在文件夹， 把docker内的/var/log/mysql下面的内容挂在到宿主机的/mydata/mysql/log,记得提前创建好文件目录
-e MYSQL_ROOT_PASSWORD=123456 :是设置mysql的参数 root账号的密码是多少
-d mysql:5.7 :其中-d是后台运行，mysql:5.7是mysql的版本号
进入容器内部：docker exec -it mysql /bin/bash
退出：exit

例如：进入/mydata/mysql/conf直接vim my.cnf 编辑(改变mysql的编码格式)：
[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

这个时候可以 进入容器内部docker exec -it mysql /bin/bash cd /etc/mysql/查看my.cnf
cat my.cnf 就可以看到文件内容与宿主机一致

Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied 解决办法：在挂载目录后多加一个--privileged=true参数即可

2.2 docker 安装mysql8.0.20

提前创建目录：

2.21 创建目录

/mydata/mysql/data
/mydata/mysql/logs
/mydata/mysql/conf
/mydata/mysql/mysql-files

2.22 授予权限

chown -R 999:999 /mydata/mysql/data;
chown -R 999:999 /mydata/mysql/logs;
chown -R root:root /mydata/mysql/conf;
chmod 644 /mydata/mysql/conf/my.cnf;
chown -R 999:999 /mydata/mysql/mysql-files;
chmod -R 755 /mydata/mysql/mysql-files;

2.23 创建配置文件

vim /data/mysql/conf/my.cnf
内容如下：

[mysqld]
# 基础设置
user=mysql
port=3306
basedir=/usr/local/mysql
datadir=/var/lib/mysql
socket=/var/run/mysqld/mysqld.sock
pid-file=/var/run/mysqld/mysqld.pid

# 字符集
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
skip-name-resolve

# 日志设置
log-error=/var/log/mysql/error.log
slow-query-log=1
slow-query-log-file=/var/log/mysql/slow.log
long_query_time=2
log-bin=/var/log/mysql/mysql-bin.log
server-id=1
binlog_format=row

# 连接相关
max_connections=200
max_connect_errors=1000
back_log=50
max_allowed_packet=64M

# InnoDB 设置
innodb_data_home_dir=/var/lib/mysql
innodb_log_group_home_dir=/var/lib/mysql
innodb_buffer_pool_size=1G
innodb_log_file_size=256M
innodb_log_buffer_size=16M
innodb_flush_log_at_trx_commit=1
innodb_lock_wait_timeout=50
innodb_flush_method=O_DIRECT
innodb_file_per_table=1

# 其他
default-storage-engine=INNODB

[client]
default-character-set=utf8mb4

[mysql]
default-character-set=utf8mb4

2.24 创建容器

docker run -d \
  --name mysql8 \
  --restart=always \
  -p 3307:3306 \
  -e MYSQL_ROOT_PASSWORD=123456 \
  -v /mydata/mysql/conf/my.cnf:/etc/mysql/my.cnf \
  -v /mydata/mysql/data:/var/lib/mysql \
  -v /mydata/mysql/logs:/var/log/mysql \
  -v /mydata/mysql/mysql-files:/var/lib/mysql-files \
  mysql:8.0.20 \
  --default-authentication-plugin=mysql_native_password \
  --character-set-server=utf8mb4 \
  --collation-server=utf8mb4_unicode_ci

2.3、docker安装redis

拉取：docker pull redis
创建配置文件夹：mkdir -p /mydata/redis/conf
创建配置文件：touch /mydata/redis/conf/redis.conf

创建并启动容器：

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

配置redis：

在 /mydata/redis/conf目录下创建redis.conf 编辑： save 900 1 save 300 10 save 60 10000
设置redis连接密码，如果配置了连接密码，客户端在连接redis是需要通过AUTH <password>命令提供密码，默认关闭。例如： requirepass 420188
appendonly yes
指定跟新日志文件名默认为appendonly.aof appendfilename “appendonly.aof”
指定更新日志的条件，有三个可选参数

• -no：表示等操作系统进行数据缓存同步到磁盘(快)，
• always：表示每次更新操作后手动调用fsync()将数据写到磁盘(慢， 安全)，
• everysec：表示每秒同步一次(折衷，默认值)；
  appendfsync everysec
  重启即可 设置密码完毕

示例：redis.conf

save 900 1
save 300 10
save 60 10000
requirepass 420188
appendonly yes

2.4、docker 安装elasticsearch

2.4.1 拉取镜像 拉取es：docker pull elasticsearch:7.9.3

2.4.2 创建文件夹

mkdir -p /mydata/elasticsearch/config 
mkdir -p /mydata/elasticsearch/data

给文件夹赋权: chmod -R 777 /mydata/elasticsearch/ 保证权限

2.4.3 在宿主机创建elasticsearch.yml文件夹

 echo "http.host: 0.0.0.0" >> /mydata/elasticsearch/config/elasticsearch.yml

2.4.4 创建容器

docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms128m -Xmx256m" \
-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.9.3 

解释：ES_JAVA_OPTS 是设置es的内存占用，
-v是目录挂在到宿主机，前面是宿主机后面是docker里面的路径
-e 是修改参数 plugins是插件目录比如我们放入分词器 执行去问
⑤给目录赋予可读可写可执行权限 chmod -R 777 elasticsearch/
⑥启动 docker start 容器号 (记得开房防火墙端口参看nginx那篇的写法)

2.5、docker安装kibana

2.5.1 拉取kibana:docker pull kibana:7.9.3

2.5.2 创建容器

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

2.6、docker安装nginx

2.6.1

随便启动一个nginx实例，只是为了复制出配置，放到docker里作为镜像的统一配置 docker run -p 80:80 --name nginx -d nginx:1.10

在mydata目录 也就是与nginx平级的目录执行： docker container cp nginx:/etc/nginx . 注意：这句话的意思是把虚拟机的nginx的配置文件拷贝到宿主机的nginx目录下，注意结尾是空格 点
停掉nginx容器 docker stop nginx
移动配置文件(都是在mydata目录下执行) mv nginx conf mkdir nginx mv conf nginx/
移除容器 docker rm nginx

2.6.2 重新创建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 解决nginx中文乱码是在server中配置:charset utf-8; 注意：# 注意一下这个路径映射到了/usr/share/nginx/html，我们在nginx配置文件中是写/usr/share/nginx/html，不是写/mydata/nginx/html
我在/mydata/nginx/html下准备了一个index.html文件 在conf下的nginx.conf的配置

server {
       listen       80;
        server_name  localhost;
                charset utf-8;
        location / {
            root   /usr/share/nginx/html;
            index  index.html index.htm;
         }

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

 这里root的路径docker中的路径/usr/share/nginx/html，不是宿主机的路径

2.7、docker安装portainer

2.7.1 拉取镜像 docker pull portainer/portainer
2.7.2 创建数据卷： docker volume create portainer_data
2.7.3 创建并运行容器
创建文件夹
mkdir -p /mydata/portainer/data

docker run -d -p 8000:8000 -p 9000:9000 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v /mydata/portainer/data:/data portainer/portainer 

参数说明：
-d：容器在后台运行；
-p 9000:9000 ：宿主机9000端口映射容器中的9000端口
-v /var/run/docker.sock:/var/run/docker.sock ：把宿主机的Docker守护进程(Docker daemon)默认监听的Unix域套接字挂载到容器中；
-v /mydata/portainer/data:/data 把宿主机/mydata/portainer/data数据卷挂载到容器/data目录
12.4 访问主机+9000端口即可看到图形化界面(服务器记得打开9000端口的防火墙) 单机版本选择“Local"，点击Connect即可连接到本地docker

2.8、docker安装tomcat

① docker pull tomcat

② docker run -d --name=tomcat8080 -p 8080:8080 -v /mydata/tomcat/webapps:/usr/local/tomcat/webapps/ tomcat

2.9、docker安装nacos

①拉取镜像 pull nacos/nacos-server:2.0.3
②创建目录并授权
mkdir -p /home/soft/nacos/logs
mkdir -p /home/soft/nacos/conf
chmod 777 /home/soft/nacos
③在conf目录创建文件application.properties touch application.properties
④ 配置application.properties中的内容

server.servlet.contextPath=/nacos
### Default web server port:
server.port=8848
 
#*************** Config Module Related Configurations ***************#
### If use MySQL as datasource:
spring.datasource.platform=mysql
### Count of DB:
db.num=1
### Connect URL of DB:
db.url.0=jdbc:mysql://192.168.183.129:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=420188
### Connection pool configuration: hikariCP
db.pool.config.connectionTimeout=30000
db.pool.config.validationTimeout=10000
db.pool.config.maximumPoolSize=20
db.pool.config.minimumIdle=2
nacos.naming.empty-service.auto-clean=true
nacos.naming.empty-service.clean.initial-delay-ms=50000
nacos.naming.empty-service.clean.period-time-ms=30000
management.metrics.export.elastic.enabled=false
#management.metrics.export.elastic.host=http://localhost:9200
### Metrics for influx
management.metrics.export.influx.enabled=false
#management.metrics.export.influx.db=springboot
#*************** Access Log Related Configurations ***************#
### If turn on the access log:
server.tomcat.accesslog.enabled=true
### The access log pattern:
server.tomcat.accesslog.pattern=%h %l %u %t "%r" %s %b %D %{User-Agent}i %{Request-Source}i
 
### The directory of access log:
server.tomcat.basedir=
 
### The ignore urls of auth, is deprecated in 1.2.0:
nacos.security.ignore.urls=/,/error,/**/*.css,/**/*.js,/**/*.html,/**/*.map,/**/*.svg,/**/*.png,/**/*.ico,/console-ui/public/**,/v1/auth/**,/v1/console/health/**,/actuator/**,/v1/console/server/**
 
### The auth system to use, currently only 'nacos' and 'ldap' is supported:
nacos.core.auth.system.type=nacos
 
### If turn on auth system:
nacos.core.auth.enabled=false
 
### The token expiration in seconds:
nacos.core.auth.default.token.expire.seconds=18000
### The default token:
nacos.core.auth.default.token.secret.key=SecretKey012345678901234567890123456789012345678901234567890123456789
### 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=true
### Since 1.4.1, Turn on/off white auth for user-agent: nacos-server, only for upgrade from old version.
nacos.core.auth.enable.userAgentAuthWhite=false
### Since 1.4.1, worked when nacos.core.auth.enabled=true and nacos.core.auth.enable.userAgentAuthWhite=false.
### The two properties is the white list for auth and used by identity the request from other server.
nacos.core.auth.server.identity.key=serverIdentity
nacos.core.auth.server.identity.value=security
#*************** Istio Related Configurations ***************#
### If turn on the MCP server:
nacos.istio.mcp.server.enabled=false

⑤在配置的数据库中创建库和表 详情参考下载的nacos软件包中的 nacos-mysql.sql
⑥镜像制作容器

 docker run --name nacos-server  -p 8848:8848 -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 /home/soft/nacos/logs:/home/nacos/logs 
 -v /home/soft/nacos/conf/application.properties:/home/nacos/conf/application.properties 
 -d nacos/nacos-server:2.0.3

⑦打开服务器端口
查看已打开的端口 firewall-cmd --list-all
开放端口 firewall-cmd --add-port=8848/tcp --permanent
重载防火墙 firewall-cmd --reload
⑧访问http://192.168.183.129:8848/nacos

2.10 docker安装minio

搜索 : docker search minio

结果:

拉取镜像   docker pull minio/minio

运行容器

docker run -d -p 9002:9000 -p 9090:9090 --name minio \
-v /usr/local/minio/data:/data \
-v /usr/local/minio/config:/root/.minio \ 
-e "MINIO_ACCESS_KEY=minioadmin" \
-e "MINIO_SECRET_KEY=minioadmin" \
minio/minio server /data --console-address ":9090" -address ":9000"

如上图命令，因为宿主机的9000端口被占用，所以使用宿主机的9002，设置了账号密码，切挂载了数据目录和配置文件

2.11 docker安装neo4j

docker run --name my-neo4j -p 7474:7474 -p 7687:7687 \
-v /usr/local/neo4j/data:/data \
-e NEO4J_AUTH=neo4j/12345678 \
-d neo4j

① 宿主机建目录 /usr/local/neo4j/data
②账号密码 neo4j/12345678
浏览器访问：http://服务器ip:7474/

2.12 docker安装EMQX

创建目录：

/opt/emqx5/data
/opt/emqx5/log

docker run -d --name emqx \
  -p 1883:1883 -p 8083:8083 \
  -p 8084:8084 -p 8883:8883 \
  -p 18083:18083 \
  -v $PWD/data:/opt/emqx5/data \
  -v $PWD/log:/opt/emqx5/log \
  emqx/emqx:5.4.1

访问：http://ip地址:18083

2.13 docker 安装xxl-job

1.创建目录

/opt/apps/xxljob/xxljob/log
/opt/apps/xxljob/xxljob
并把application.properties(来自源码项目)放在 /opt/apps/xxljob/xxljob目录下

2.配置mysql连接

打开application.properties，修改
①server.port=30001 这里的端口号与容器映射处一致
②数据库连接信息
spring.datasource.url=jdbc:mysql://192.168.20.192:3307/xxl_job?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456

3.拉取镜像

docker pull xuxueli/xxl-job-admin:2.5.0

4.创建容器

docker run
-p 30001:30001
-d --name=xxl-job-admin --restart=always
-v /opt/apps/xxljob/xxljob/application.properties:/application.properties
-v /opt/apps/xxljob/xxljob/log:/data/applogs
-e PARAMS=‘–spring.config.location=/application.properties’ xuxueli/xxl-job-admin:2.5.0
注意：这里的3001:30001 ，前面一个端口30001是服务器开放给外界访问的，后面一个30001是容器内部端口，与第二步配置的微服务端口一致

5.访问

http://192.168.174.192:30001/xxl-job-admin/
默认账密：admin / 123456

2.14 docker安装mongoDb

1.创建目录

/data/mongodb

2.拉取镜像

docker pull mongo:latest

3.生成容器

docker run --name mongodb -d -p 27017:27017 \
-v /data/mongodb:/data/db \
-e MONGO_INITDB_ROOT_USERNAME=admin \
-e MONGO_INITDB_ROOT_PASSWORD=123456 \
mongo

2.15 docker安装skywalking oap和skywalking ui

2.151 采用mysql做存储

2.1511 拉取镜像与创建目录

docker pull apache/skywalking-oap-server:9.6.0
docker pull apache/skywalking-ui:9.6.0
创建目录：/mydata/skywalking

2.1512 创建临时容器，获取器配置文件与插件包

docker run \
--name skywalking-oap \
--restart always \
-p 11800:11800 \
-p 12800:12800 -d \
apache/skywalking-oap-server:10.0.1

2.1513 把容器生成的配置文件与插件jar包复制到本地

 docker cp skywalking-oap:/skywalking/config /mydata/skywalking
 docker cp skywalking-oap:/skywalking/oap-libs /mydata/skywalking

2.1514 准备mysql的驱动包

把mysql-connector-java-8.0.28.jar 拖进/mydata/skywalking/oap-libs/

2.1515 修改/mydata/skywalking/oap-libs/application.yml

storage:
  mysql:
    properties:
      jdbcUrl: ${SW_JDBC_URL:"jdbc:mysql://192.168.174.192:3307/skywalking?rewriteBatchedStatements=true&allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai"}
      dataSource.user: ${SW_DATA_SOURCE_USER:root}
      dataSource.password: ${SW_DATA_SOURCE_PASSWORD:123456}

2.1516 创建skywalking-oap容器，并还挂在配制文件到宿主机

 docker run \
--name skywalking-oap \
--restart always \
-p 11800:11800 \
-p 12800:12800 -d \
--privileged=true \
-e TZ=Asia/Shanghai \
-v /etc/localtime:/etc/localtime:ro \
-v /mydata/skywalking/oap-libs:/skywalking/oap-libs \
-v /mydata/skywalking/config/application.yml:/skywalking/config/application.yml \
apache/skywalking-oap-server:10.0.1

2.1517 创建skywalking的UI界面

docker run \
--name skywalking-ui \
--restart always \
-p 10086:8080 -d \
--privileged=true \
--link skywalking-oap:skywalking-oap \
-e TZ=Asia/Shanghai \
-e SW_OAP_ADDRESS=http://192.168.174.192:12800 \
-v /etc/localtime:/etc/localtime:ro \
apache/skywalking-ui:10.0.1

访问：192.168.174.192:10086

2.152 采用es做数据存储，省略es的安装

docker pull apache/skywalking-ui:10.0.1
docker pull apache/skywalking-oap-server:10.0.1

安装skywalking-oap

docker run \
--name skywalking-oap \
--restart always \
-p 11800:11800 \
-p 12800:12800 -d \
--link elasticsearch:elasticsearch \
--privileged=true \
-e TZ=Asia/Shanghai \
-e SW_STORAGE=elasticsearch \
-e SW_STORAGE_ES_CLUSTER_NODES=192.168.174.192:9200 \
-v /etc/localtime:/etc/localtime:ro \
apache/skywalking-oap-server:10.0.1

注： --link后面的第一个参数和elasticsearch容器名一致；
-e SW_STORAGE_ES_CLUSTER_NODES：ip:9200

docker run \
--name skywalking-ui \
--restart always \
-p 10086:8080 -d \
--privileged=true \
--link skywalking-oap:skywalking-oap \
-e TZ=Asia/Shanghai \
-e SW_OAP_ADDRESS=http://192.168.174.192:12800 \
-v /etc/localtime:/etc/localtime:ro \
apache/skywalking-ui:10.0.1

注：–link后面的第一个参数和skywalking OAP容器名一致,-e SW_OAP_ADDRESS后面的ip:端口 前有http://

如果向把oap-libs和配置文件挂在到宿主机：
创建一个目录 /mydata/skywalking

docker cp skywalking-oap:/skywalking/config /mydata/skywalking
docker cp skywalking-oap:/skywalking/oap-libs /mydata/skywalking

删除skywalking-oap 容器，重新生成

docker run \
--name skywalking-oap \
--restart always \
-p 11800:11800 \
-p 12800:12800 -d \
--link elasticsearch:elasticsearch \
--privileged=true \
-e TZ=Asia/Shanghai \
-e SW_STORAGE=elasticsearch \
-e SW_STORAGE_ES_CLUSTER_NODES=192.168.174.192:9200 \
-v /etc/localtime:/etc/localtime:ro \
-v /mydata/skywalking/oap-libs:/skywalking/oap-libs \
-v /mydata/skywalking/config/application.yml:/skywalking/config/application.yml \
apache/skywalking-oap-server:10.0.1

2.16 docker安装clickhouse

1.创建目录 /mydata/clickhouse

并在此目录下创建3个文件夹config data log

2.创建临时容器

docker pull clickhouse/clickhouse-server:24.12

3.启动临时容器

docker run --rm -d --name=temp-clickhouse-server clickhouse/clickhouse-server:24.12

4. 拷贝配置文件到文件夹

docker cp temp-clickhouse-server:/etc/clickhouse-server/users.xml /mydata/clickhouse/config/users.xml
docker cp temp-clickhouse-server:/etc/clickhouse-server/config.xml /mydata/clickhouse/config/config.xml

5.删除临时容器

docker rm -f temp-clickhouse-server

6.创建新容器

docker run --privileged=true --net=bridge \
-p 8123:8123 \
--name clickhouse-server \
--ulimit nofile=262144:262144 \
-v /mydata/clickhouse/data:/var/lib/clickhouse \
-v /mydata/clickhouse/config/config.xml:/etc/clickhouse-server/config.xml \
-v /mydata/clickhouse/config/users.xml:/etc/clickhouse-server/users.xml \
-v /mydata/clickhouse/log:/var/log/clickhouse-server \
-e CLICKHOUSE_USER=root \
-e CLICKHOUSE_PASSWORD=clickhouse \
-e CLICKHOUSE_DEFAULT_ACCESS_MANAGEMENT=1 \
-e TZ=Asia/Shanghai \
-d clickhouse/clickhouse-server:24.12

7.连接

使用dbever连接clickhouse，账号密码如第6步所示

2.17 docker 安装es8.17.0

1. 创建目录

mkdir -p /mydata/es/{logs,data,config,plugins}

2.创建临时容器

 docker run -d \
 --restart=always \
 --name elasticsearch \
 --network host \
 -p 9388:9200 \
 -p 9389:9300 \
 --privileged \
 -e "discovery.type=single-node" \
 -e "ES_JAVA_OPTS=-Xms2g -Xmx2g" \
 docker.elastic.co/elasticsearch/elasticsearch:8.17.0

3.复制配置文件到宿主机

docker cp elasticsearch:/usr/share/elasticsearch/data /mydata/es;
docker cp elasticsearch:/usr/share/elasticsearch/plugins /mydata/es;
docker cp elasticsearch:/usr/share/elasticsearch/config /mydata/es;
docker cp elasticsearch:/usr/share/elasticsearch/logs /mydata/es;

4.文件授权

chmod -R /mydata/es 755 ;
chown -R es:es /mydata/es;

es(如果没得es这用户就创建：useradd es)

5.创建es网络

docker network create es-net

6.创建新容器

docker run -d \
  --restart=always \
  --network es-net \
  --name "es8" \
  -p 9201:9200 \
  -p 9301:9300 \
  -v "/mydata/es/data:/usr/share/elasticsearch/data" \
  -v "/mydata/es/plugins:/usr/share/elasticsearch/plugins" \
  -v "/mydata/es/config:/usr/share/elasticsearch/config" \
  -v "/mydata/es/logs:/usr/share/elasticsearch/logs" \
  -e "discovery.type=single-node" \
  -e "ES_JAVA_OPTS=-Xms2g -Xmx2g" \
  -e "ELASTIC_PASSWORD=123456" \
  docker.elastic.co/elasticsearch/elasticsearch:8.17.0

7.访问(ES8只能使用HTTPS访问)

https:192.168.174.193:9201

2.18 docker安装kibana8.17.0

1.创建配置文件目录和文件

mkdir -p /mydata/kibana/config

2.创建文件

在目录/mydata/kibana/config执行
touch kibana.yml

3.获取token

进入 elasticsearch 容器 docker exec -it es8 /bin/bash
创建 kibana 服务账户的 token（名称为 kibana-token） bin/elasticsearch-service-tokens create elastic/kibana kibana-token
输出密文：SERVICE_TOKEN elastic/kibana/kibana-token = AAEAAWVsYXN0aWMva2liYW5hL2tpYmFuYS10b2tlbjpnNUpWc1dWSFMzcXZvdVdZUFh1WUh3

4.把密文拷进kibana.yml

# 允许外部访问
server.host: "0.0.0.0"
server.port: 5601
# # 指定 Elasticsearch 地址（必须！）
# # 注意：因为使用了 --network=es-net，这里应使用 Elasticsearch 容器的服务名或容器名
elasticsearch.hosts: ["https://192.168.174.193:9201"]
elasticsearch.serviceAccountToken: AAEAAWVsYXN0aWMva2liYW5hL2tpYmFuYS10b2tlbjpnNUpWc1dWSFMzcXZvdVdZUFh1WUh3
# # 如果你的 Elasticsearch 是 8.x 且启用了安全（默认开启），请取消下面注释并填写凭证
#elasticsearch.username: "elastic"
#elasticsearch.password: "123456"
# # 如果 ES 使用 HTTPS 但你想跳过证书验证（仅测试环境）
elasticsearch.ssl.verificationMode: none

5.创建kibana容器

(注意这里的网络是上面创建的es-net)

docker run -d \
--name kibana \
-v /mydata/kibana/config:/usr/share/kibana/config  \
--network=es-net \
-p 5601:5601 \
kibana:8.17.0

6.访问

http://192.168.174.193:5601/

三、手动把jar包做成docker镜像、容器

14.1、在/usr/local/docker/ 如果没有docker目录，就新建一个 mkdir docker传入打好的jar包
14.2、在这个目录创建一个Dockerfile：touch Dockerfile
14.3、编辑Dockerfile：

这是一个编辑好的dockerfile文件：

# 基础镜像使用java 
FROM java:8
# 作者 
MAINTAINER cc <513778675@qq.com>
# VOLUME 指定了临时文件目录为/tmp。 # 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp 
VOLUME /tmp
# 将jar包添加到容器中并更名为monitor.jar 
ADD gulimall-monitor-0.0.1-SNAPSHOT.jar monitor.jar
# 运行jar包 
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/monitor.jar"]

14.4、启动jar包 docker build -t yunpan .
这时查看镜像会看到刚生成的jar包对应镜像
14.5、从镜像制作到容器 docker run -d --name=monitor -p 8091:8091 monotor

四、开启docker的远程访问

15.1 、修改docker.service文件 vim /lib/systemd/system/docker.service#修改ExecStart这行 将文件内的 ExecStart注释, 新增如上行。
#ExecStart=/usr/bin/dockerd -H fd://–containerd=/run/containerd/containerd.sock
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock
15.2、重新加载配置文件与测试
重新加载配置文件:systemctl daemon-reload
重启服务:systemctl restart docker.service
查看端口是否开启:netstat -nlpt #如果找不到netstat命令，可进行安装。yum install net-tools
直接curl看是否生效 注意：必须要开启防火墙或者阿里云的安全组 2375端口 这个端口也可以自定义
curl http://121.89.202.183:2375/info

五、IDEA连接docker，制作镜像、容器

只有第15步完成才能连接docker

16.1、IDEA下载docker插件（就在plugins搜索docker安装即可）
16.2、连接与配置docker：在idea点击settings>Build、Execution、Deployment>Docker
就点Docker标题 配置TCP socket 配置docker的地址，默认端口是2375， 如果不确定端口是多少，那就在linux用：netstat -nlpt看一眼。

改完点击Apply
16.3、点击展开Docker，选择Docker Registry,在右侧的Address中设置自己的阿里云的docker镜像加速器：https://xxx.mirror.aliyuncs.com

16.4、docker-maven-plugin生成镜像
在springboot的pom.xml中配置如下：

 <build>
        <finalName>monitor</finalName>
        <plugins>
           <!-- docker-maven-plugin 插件就是为了帮助我们在Maven工程 中，通过简单的配 置，自动生成镜像并推送到仓库中-->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>
                <configuration>
                    <!-- 镜像名称  <docker.image.prefix>monitor</docker.image.prefix>配置在properties中-->
                    <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
                    <!--指定标签-->
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>
                    <!-- 基础镜像jdk 1.8-->
                    <baseImage>java</baseImage>
                    <!-- 制作者提供本人信息 -->
                    <maintainer>cc 123456@qq.com</maintainer>
                    <!--切换到/ROOT目录 -->
                    <workdir>/ROOT</workdir>
                    <cmd>["java", "-version"]</cmd>
                    <entryPoint>["java", "-jar", "${project.build.finalName}.jar"]</entryPoint>
                    <!-- 指定 Dockerfile 路径 <dockerDirectory>${project.basedir}/src/main/docker</dockerDirectory> -->
                    <!--指定远程 docker api地址-->
                    <dockerHost>http://192.168.200.137:2375</dockerHost>
                    <!-- 这里是复制 jar 包到 docker 容器指定目录配置 -->
                    <resources>
                        <resource>
                            <targetPath>/ROOT</targetPath>
                            <!--用于指定需要复制的根目录，${project.build.directory} 表示target目 录-->
                            <directory>${project.build.directory}</directory>
                            <!--用于指定需要复制的文件。 ${project.build.finalName}.jar指的是打包 后的jar包文件。-->
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

打开当前要制作镜像的springboot项目对应的idea的Terminal，输入：
mvn clean package docker:build
看到控制台信息，镜像制作成功。打开IDEA的Services,再点开Docker下的Images，就能看到刚刚制作>的镜像

16.5、由镜像制作容器
点击镜像，右键Create Container,在右侧弹出框只需改动两个地方：Container name和Run options

点击Apply后再点击run就可以创建容器了
这样就可以从Docker>Containers中看到刚创建的容器了，也可以启动停止

16.6 自动制作镜像
上面的镜像制作是手动输入命令，现在教一种自动制作镜像，
在pom.xml中加入一段：

<executions>
 <execution>
      <id>build-image</id>
      <phase>package</phase>
      <goals>
          <goal>build</goal>
      </goals>
  </execution>
</executions>

看清它所在位置
这时候点击它的package

仅仅是这样就制作完成了该springboot的镜像