因为alist被收购在开源社区引发的波动，该开源项目被“贵州不够科技”公司收购，文档和下载链接被修改：中文文档被大幅修改，加入了微信链接，更大范围的收集用户信息等非技术内容。有鉴于此，打算自行写一个备份文档，文中镜像已备份到我自己的仓库，备份来自未收购前的版本。

Docker安装

AList镜像

旧版WiKi文档：端口建议更改成另一个复杂端口，避免扫描攻击。

#未收购前版本(推荐)
docker run -d --restart=always -v /etc/alist:/opt/alist/data -p 5244:5244 -e PUID=0 -e PGID=0 -e UMASK=022 --name="alist" opslaobai/alist:v3.39.4

#3.45当前最新版本（2025-06-12）
docker run -d --restart=always -v /etc/alist:/opt/alist/data -p 5244:5244 -e PUID=0 -e PGID=0 -e UMASK=022 --name="alist" opslaobai/alist:latest

#初始密码指首次启动时的登录凭证。若后续忘记管理员用户名或密码，您可执行以下命令以随机生成新密码:
docker exec -it alist ./alist admin random

#或者您也可以手动设置新密码，​​NEW_PASSWORD​​ 表示您需要设置的密码:
docker exec -it alist ./alist admin set NEW_PASSWORD

我最新的镜像仓库地址：laobai，更换相应的docker镜像即可拉取2025-06-12最新上传版本。（有兴趣再更新版本）

Docker compose

version: '3.3'
services:
  alist:
    image: 'opslaobai/alist:v3.39.4'
    container_name: alist
    volumes:
      - '/etc/alist:/opt/alist/data'
    ports:
      - '5244:5244'
    environment:
      - PUID=0
      - PGID=0
      - UMASK=022
    restart: unless-stopped

环境变量参数

投毒风险引担忧

社区最关心的是潜在的供应链投毒风险。据报道，此前金华某公司收购Oneinstack和LNMP后曾尝试进行投毒，但被安全公司发现。

贵州不够科技此前还收购了Java工具库Hutool。有用户指出，该公司收购的开源软件都出现了异常情况。目前最大的风险在于，Alist使用了私有API服务，如果原开发者不再提供相关API支持，用户可能面临无法使用的困境。

R.I.P Alist部署文档备份最先出现在Liao's blog。

介绍Milvus向量数据库的安装过程，包括创建工作目录、下载docker-compose.yml文件、配置attu可视化面板和修改安全设置。

环境准备

• docker版本：28.0.4
• docker compose版本：v2.34.0

Milvus向量数据库简介

Milvus是一款开源的向量数据库，它专为AI应用设计，用于管理和检索海量的特征向量。Milvus的优势主要包括：

• 高效的向量检索性能：Milvus采用了多种先进的索引算法，如IVF, HNSW, ANNOY等，能够在大规模数据集上实现高效的近似最近邻搜索。
• 易于扩展和维护：Milvus支持水平和垂直扩展，能够适应不断增长的数据规模和查询需求。它的分布式架构使得数据存储和计算能力可以灵活扩展。
• 多种数据持久化选项：Milvus支持SSD, HDD等多种存储介质，并且可以与多种持久化存储解决方案集成，如MinIO, S3等。
• 丰富的数据接口：Milvus提供了Python, Java, RESTful等多种语言的SDK，方便开发者在不同的应用场景中使用。
• 强大的可扩展性和兼容性：支持各种大小和类型的向量数据，可以与现有的数据处理和机器学习工作流程无缝集成。
• 容器化和云原生支持：支持Docker和Kubernetes，方便在云环境中部署和管理。
• 开源社区支持：作为一个开源项目，Milvus拥有活跃的社区，不断有新的功能和改进被加入。

Milvus适用于各种需要高效向量检索的应用场景，如推荐系统、图像检索、自然语言处理等。由于其高效、易用和可扩展的特性，Milvus在AI应用开发中越来越受欢迎。

安装Milvus

1. 创建工作目录（自定义）

# 切换到root目录
cd /root
# 新建一个名为milvus的目录用于存放数据 目录名称可以自定义
mkdir milvus
# 进入到新建的目录
cd milvus

2. 下载并编辑docker-compose.yml

Github查看最新版本，选择带有GPU的yml配置文件下载（nvidia显卡）。也可以借鉴官网指南

3. 下载milvus.yml文件

该文件是milvus的配置文件，容器中内置，但如果要修改配置，需要单独下载，这里为了做访问控制，就需要修改配置。

# 注意改成自己对应的milvus版本号
wget https://raw.githubusercontent.com/milvus-io/milvus/v2.5.7/configs/milvus.yaml

下载好后，确保该文件位于milvus工作目录下，然后编辑该文件，找到其中的common > security > authorizationEnabled并将其设置为true。

3. 下载milvus-standalone-docker-compose-gpu.yml文件，在其中添加attu可视化面板的容器。并修改docker-compose.yml做资源映射

version: '3.5'
services:
  etcd:
    container_name: milvus-etcd
    image: quay.io/coreos/etcd:v3.5.18
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
      - ETCD_QUOTA_BACKEND_BYTES=4294967296
      - ETCD_SNAPSHOT_COUNT=50000
    volumes:
      - {DOCKER_VOLUME_DIRECTORY:-.}/volumes/etcd:/etcd
    command: etcd -advertise-client-urls=http://etcd:2379 -listen-client-urls http://0.0.0.0:2379 --data-dir /etcd
    healthcheck:
      test: ["CMD", "etcdctl", "endpoint", "health"]
      interval: 30s
      timeout: 20s
      retries: 3

  minio:
    container_name: milvus-minio
    image: minio/minio:RELEASE.2023-03-20T20-16-18Z
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    ports:
      - "9001:9001"
      - "9000:9000"
    volumes:
      -{DOCKER_VOLUME_DIRECTORY:-.}/volumes/minio:/minio_data
    command: minio server /minio_data --console-address ":9001"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

  standalone:
    container_name: milvus-standalone
    image: milvusdb/milvus:v2.5.7-gpu
    command: ["milvus", "run", "standalone"]
    security_opt:
    - seccomp:unconfined
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    volumes:
      - {DOCKER_VOLUME_DIRECTORY:-.}/volumes/milvus:/var/lib/milvus
      # 新增下面这一行来实现配置文件的映射
      -{DOCKER_VOLUME_DIRECTORY:-.}/milvus.yaml:/milvus/configs/milvus.yaml
    ports:
      - "19530:19530"
      - "9091:9091"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              capabilities: ["gpu"]
              device_ids: ["0"]
    depends_on:
      - "etcd"
      - "minio"

# 在原docker-compose文件的这个位置添加下面这个attu容器，注意版本号和行前空格。
  attu:
    container_name: attu
    image: zilliz/attu:v2.5.6
    environment:
      MILVUS_URL: milvus-standalone:19530
    ports:
      - "8000:3000"  # 外部端口8000可以自定义
    depends_on:
      - "standalone"

networks:
  default:
    name: milvus

启动Mlivus

# 安装目录下运行命令
# 拉取镜像
docker-compose pull
# 启动容器
docker-compose up -d
# 查看启动状态（健康状态）
docker-compose ps -a
# 停止容器
docker-compose down

放开端口：连接数据库需要放开19530端口，这是milvus的默认端口，可在docker-compose.yml中修改。访问可视化面板放开8000端口（刚才自己设置的）做反向代理的话可以不用放开此端口。

验证效果

访问可视化面板并修改密码：http://ip:8000

默认账号：root
默认密码：Milvus

Docker compose安装配置向量数据库Milvus，配置可视化Attu最先出现在Liao's blog。

postgresql + pgpool 构建容灾高可用集群(数据同步流复制/主备自动切换)，在postgresql官网看了pgpool-II的文档，发现部署比较麻烦，为了方便快捷还是使用docker部署。

一、简介

bitnami/postgresql-repmgr是PostgreSQL HA对应的docker镜像，PostgreSQL HA 是 PostgreSQL 集群解决方案，其中包括 PostgreSQL 复制管理器，这是一个用于管理 PostgreSQL 集群上的复制和故障转移的开源工具。

bitnami/pgpool是Pgpool-II 对应的docker镜像，是 PostgreSQL 代理。它位于 PostgreSQL 服务器和它们的客户端之间，提供连接池、负载平衡、自动故障转移和复制。

二、部署环境

• 系统：CentOS Linux release 7.9.2009 (Core)
• postgresql Version：postgresql-repmgr:14
• pgpool Version：latest
• Docker Version：20.10.21

1. 拉取docker镜像

稳妥起见，这里选用了postgresql 14版本，其次如果遭遇docker镜像拉取网络问题，可以参考我的这篇博文打造属于自己的Docker Hub镜像代理网站，或者在镜像前加入私有镜像站。

docker pull bitnami/postgresql-repmgr:14
docker pull bitnami/pgpool:latest

#私有镜像站eg
docker pull hub-mirror.c.163.com/bitnami/postgresql-repmgr:14
docker pull hub-mirror.c.163.com/bitnami/pgpool:latest

2. 启动pgsql数据库

1. 创建文件夹并授权

cd /
mkdir data
cd data
mkdir repmgr1
mkdir repmgr2
chmod 777 /data/repmgr1
chmod 777 /data/repmgr2

2. 创建docker网络

docker network create pg-network

3. 启动数据库
   为了数据持久化，我们把/bitnami/postgresql目录挂载到/data/repmgr1目录下。以下两条命令可以自行做成bash脚本启动。

#pg-0数据库启动
docker run -v /data/repmgr1:/bitnami/postgresql --detach --restart always --name pg-0 -p 30350:5432 --network pg-network --env REPMGR_PARTNER_NODES=pg-0,pg-1 --env REPMGR_NODE_NAME=pg-0 --env REPMGR_NODE_NETWORK_NAME=pg-0 --env REPMGR_PRIMARY_HOST=pg-0 --env REPMGR_PASSWORD=123456 --env POSTGRESQL_PASSWORD=123456 bitnami/postgresql-repmgr:14

#pg-1数据库启动
docker run -v /data/repmgr2:/bitnami/postgresql --detach --restart always --name pg-1 -p 30351:5432 --network pg-network --env REPMGR_PARTNER_NODES=pg-0,pg-1 --env REPMGR_NODE_NAME=pg-1 --env REPMGR_NODE_NETWORK_NAME=pg-1 --env REPMGR_PRIMARY_HOST=pg-0 --env REPMGR_PASSWORD=123456 --env POSTGRESQL_PASSWORD=123456 bitnami/postgresql-repmgr:14

4. 查看启动状态

docker ps

3. 启动Pgpool

注意，这里的--add-host参数对应的IP是你本地的宿主机IP，请自行修改。

docker run --detach --restart always --name pgpool -p 9999:5432 \
  --env PGPOOL_BACKEND_NODES=0:pg-0:30350,1:pg-1:30351 \
  --env PGPOOL_SR_CHECK_USER=postgres \
  --env PGPOOL_SR_CHECK_PASSWORD=123456 \
  --env PGPOOL_ENABLE_LDAP=no \
  --env PGPOOL_POSTGRES_USERNAME=postgres \
  --env PGPOOL_POSTGRES_PASSWORD=123456 \
  --env PGPOOL_ADMIN_USERNAME=postgres \
  --env PGPOOL_ADMIN_PASSWORD=123456 \
  --add-host=pg-0:192.168.1.204 \
  --add-host=pg-1:192.168.1.204 \
  bitnami/pgpool:latest

启动成功后，查看pgpool日志，通过pgpool可以实现数据库的负载均衡和读写分离。

4. 测试验证

1. navicat连接pgpool，创建user表并插入数据，看看pg-0及pg-1是否同步插入。

pgpool创建user表，插入数据

2. 验证：pg-0、pg-1同步插入

以上方法非常简单，最后程序直接访问9999端口即可实现读写分离。

缺点：
只能再一个宿主机上执行，不能跨主机。Pgpool和Pgsql有更多的高可用方法，后续还可以深入，多服务器部署及新增组件等。

参考地址：
官网WIKI
postgresql + pgpool 构建容灾高可用集群(数据同步流复制/主备自动切换)
pgpool-II 4.3 中文手册
Postgresql通过docker进行高可用部署

使用docker部署pg集群（postgresql+postgis+pgrouting+pgpool）

使用docker部署pgsql，构建容灾高可用集群最先出现在Liao's blog。

本博文基于原博CMLiussss Blog编写，旨在中转对 Docker 官方镜像仓库，帮助国内用户访问被墙的Docker hub，只建议私人或公司内部使用，不推荐使用该项目搭建公共服务。使用你自己的域名搭建公共服务有可能会遭受污染、反诈或被墙，推荐小规模自用即可。

环境准备

• GitHub账号
• Cloudflare账号
• 一个属于自己的域名

一、Docker代理工具介绍

本项目是一个基于 Cloudflare Workers 的 Docker 镜像代理工具，旨在中转对 Docker 官方镜像仓库的请求，解决访问限制并加速访问。

为什么需要这个工具？

由于神秘原因，国内用户逐渐无法访问Docker Hub仓库。这对于我们开发者来说是个不小的难题。

二、GitHub Fork本项目

点击 Github项目中的Fork到本地自己的仓库即可。

三、登录Cloudflare创建Pages自动化

登录 cloudflare ，点击Works和Pages并创建，选择Pages再连接到刚才我们Fork到Github本地仓库的项目

四、开始部署设置

部署完成后可以进入Pages里的自动化项目，给它设置一个自定义域名。假如我有一个顶级域名：laobaiblog.top，那我可以再自定义域名中配置一个：docker.laobaiblog.top作为我的Docker代理域名。

选择DNS解析，在域名解析中添加上Cloudflare生成给你的CNAME记录。

在你自己的域名解析管理中，添加CNAME记录，填入主机记录及记录值参数，等待5分钟后检查DNS记录。完成后访问代理域名会发现自动跳转为官网Docker Hub，且无需翻墙就说明已经实现了docker镜像代理。

地址栏输入你的自定义域名搜索镜像查询，毫无压力。

五、配置验证

在国内服务器上拉取镜像发现无法拉取，一直显示等待连接，各个大厂的镜像源都无法使用或仅内部使用。

docker pull nginx

拉取镜像时加上自己代理的域名。拉取镜像仓库的命令 docker pull docker.laobaiblog.top/nginx 即可拉取镜像。

docker pull docker.laobaiblog.top/nginx

你甚至可以将你的域名配置在daemon.json中，即可直接使用docker pull nginx无需再加上域名的前缀。在这里也提供了一些大佬无私分享的代理域名。

#编辑daemon.json
vim /etc/docker/daemon.json
:wq

#重启daemon配置
systemctl daemon-reload

#重启docker
systemctl restart docker.service

Centos7安装Docker并更改默认存储文件位置

CentOS7离线安装docker-ce

Docker仓库镜像代理打造属于自己的Docker Hub最先出现在Liao's blog。

ChatGpt接口目前只能在国外互联网环境中使用，国内想要使用相关服务的话可以寻求代理，在这里使用的是一台国外服务器安装Nginx服务进行相关代理。

二、环境要求

• 一台拥有公网IP的国外服务器
• 一个域名及免费ssl证书（可在腾讯云免费申请ssl证书）
• 一个ChatGpt账号及相关的APIkey

以上就是所有需要用到的环境，请注意，如要使用接口还需要充值API额度。除此之外还需要将你的域名解析到公网IP上。完成准备工作后进行以下操作。

三、Nginx转发

1. 在服务器中安装nginx，这里使用的是docker服务，根据以往博文中可自行安装Docker服务。

#服务器中新建一个nginx目录，下级目录新建conf.d、logs、ssl三个目录
mkdir -p nginx/conf.d
mkdir -p nginx/logs
mkdir -p nginx/ssl

#在nginx目录中新建start.sh脚本
vim start.sh

docker stop nginx
docker rm nginx
docker run  -p 80:80  -p 443:443 --name nginx --net=host  --restart=always  --privileged=true \
    -v `pwd`/conf.d/:/etc/nginx/conf.d \
    -v `pwd`/logs/:/var/log/nginx  \
    -v `pwd`/ssl/:/var/ssl \
    -e TZ="Asia/Shanghai" \
    nginx:latest

#输入 :wq 保存后授权并执行即可
chmod a+x start.sh
./start.sh

2. 将域名ssl证书放置在ssl目录下后，编辑nginx转发代理，执行start.sh脚本重启nginx服务。

vim conf.d/gpt.conf

#填入域名信息
server {
        listen       443 ssl;
        server_name  域名;
        ssl_certificate /var/ssl/域名.crt;     #配置证书位置
        ssl_certificate_key /var/ssl/域名.key; #配置秘钥位置】

        ssl_session_timeout 5m;
        ssl_protocols SSLv2 SSLv3 TLSv1.2;
        ssl_ciphers ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP;
        ssl_prefer_server_ciphers on;

        underscores_in_headers on;
        charset utf-8;

        location /v1/ {
             proxy_ssl_server_name on;
             proxy_ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
             proxy_pass https://api.openai.com;
        }
}

以上便完成了针对chatgpt接口地址 api.openai.com 的转发工作，转发后的地址既是你的域名。

四、Java实例调用实现多轮对话

1. 新建Maven项目ChatGPTClient，在pom.xml中添加后续用到的依赖，重构后拉取。

<dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.9.3</version>
</dependency>
<dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.9</version> <!-- 使用最新的可用版本 -->
</dependency>

2. java代码

import okhttp3.*;
import com.google.gson.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class ChatGPTClient {
    private final String apiKey;
    private final OkHttpClient client;
    private final List<Message> messages;
    private final Gson gson;
    private int tokenCount = 0;
    private int inputTokenCount = 0;
    private int outputTokenCount = 0;

    public ChatGPTClient(String apiKey) {
        this.apiKey = apiKey;
        this.client = new OkHttpClient();
        this.messages = new ArrayList<>();
        this.gson = new Gson();
    }

    public String sendMessage(String message) throws IOException {
        updateTokenCount(message, true);

        messages.add(new Message("system", "user", message));
//model模型选择可以有gpt-3.5-turbo、gpt-4、gpt-4-turbo价格以此类推
        RequestBody body = RequestBody.create(
                MediaType.get("application/json; charset=utf-8"),
                "{\"model\": \"gpt-3.5-turbo\", \"messages\": " + gson.toJson(messages) + "}"
        );

        Request request = new Request.Builder()
                .url("https://你的域名地址/v1/chat/completions")
                .addHeader("Authorization", "Bearer " + this.apiKey)
                .addHeader("Content-Type", "application/json")
                .post(body)
                .build();

        try (Response response = client.newCall(request).execute()) {
            JsonObject respJson = JsonParser.parseString(response.body().string()).getAsJsonObject();
            JsonArray choices = respJson.getAsJsonArray("choices");
            if (choices != null && choices.size() > 0) {
                JsonObject firstChoice = choices.get(0).getAsJsonObject();
                String aiResponse = firstChoice.getAsJsonObject("message").get("content").getAsString();

                updateTokenCount(aiResponse, false);

                messages.add(new Message("system", "assistant", aiResponse));

                System.out.println("输入的 Token 数: " + inputTokenCount);
                System.out.println("输出的 Token 数: " + outputTokenCount);
                System.out.println("总使用的 Token 数: " + tokenCount);

                return aiResponse;
            }
        }
        return "无法获取响应。";
    }

    private void updateTokenCount(String text, boolean isInput) {
        int count = 0;
        for (char c : text.toCharArray()) {
            count += (String.valueOf(c).matches("[\\u0000-\\u00ff]") ? 1 : 4);
        }
        int tokens = (int) Math.ceil(count / 4.0);
        tokenCount += tokens;
        if (isInput) {
            inputTokenCount += tokens;
        } else {
            outputTokenCount += tokens;
        }
    }

    private static class Message {
        String role;
        String content;

        public Message(String type, String role, String content) {
            this.role = role;
            this.content = content;
        }
    }

    public static void main(String[] args) throws IOException {
        ChatGPTClient client = new ChatGPTClient("YOUR-API-KEY");

        Scanner scanner = new Scanner(System.in, "UTF-8");
        String input;
        while (true) {
            System.out.print("输入消息（输入 'bye' 结束对话）: ");
            input = scanner.nextLine();
            if ("bye".equalsIgnoreCase(input)) {
                break;
            }
            String response = client.sendMessage(input);
            System.out.println("ChatGPT 回应: " + response);
        }
    }
}

在以上代码中，增加了每次对话后所使用的token值，以便查询核对接口使用费。可在官网查询相关定价。

五、运行结果

使用Nginx转发代理ChatGpt接口，Java调用实现多轮对话最先出现在Liao's blog。

背景

官网政策修改：甲骨文对闲置实例的定义为在 7 天内满足以下条件的实例：

• 95% 时间的 CPU 使用率不足 10%
• 网络利用率低于 10%
• 内存利用率低于 10% （仅适用于 A1 ARM 免费实例）

简介

为了防止服务器被删，网上各路大神也出了很多教程来让服务器高负载，不过大多数都是试用 shell 脚本循环计算，dd 复制空文件或者一些类似 lookbusy 等第三方软件来模拟高负载。

不过作为洁癖党，总是会避免安装一些不太了解的第三方软件，也但是一些脚本后台运行出问题，或者时间长了忘记了，所以还是觉得把脚本跑在 docker 里最合适，也最方便管理。可以做到想开就开，想关就关，还可以配合 crontab 定时开关。

教程

原理很简单，就是写了一段最简单的循环计算 shell 脚本，在 alpine 容器内部执行。只需要控制 docker 的启动和停止即可。

docker命令

#docker启动命令
docker run -d --name keeporaclealive --rm alpine sh -c "while true; do for i in {1..100000}; do j=((i*i)); done; done" 

#docker停止命令
docker stop keeporaclealive

#docker命令将容器常驻，即使服务器重启也会自动启动服务。
docker run -d --name keeporaclealive --restart always alpine sh -c "while true; do for i in {1..100000}; do j=((i*i)); done; done"

#docker停止命令
docker stop keeporaclealive
# 停止服务，容器不会被删除。
docker start keeporaclealive
# 再次启动容器。
docker rm keeporaclealive
# 停止后彻底删除容器。

效果

甲骨文云 Oracle Cloud 服务器防回收docker 命令最先出现在Liao's blog。

部署环境

• 操作系统版本：CentOS Linux release 7.9.2009 (Core)
• Docker版本：Docker Server Version: 20.10.17
• Nessus版本： 10.3.0 （#80） Linux

部署Nessus

#搜索nessus相关镜像
docker search nessus
#pull nessus最新镜像
docker pull tenableofficial/nessus
#启动docker镜像，同时配置用户名和口令、不启动自动更新
docker run -it -d -p8834:8834 --name nessus -e USERNAME=Nessus -e AUTO_UPDATE=no -e PASSWORD=HDuUNO1XzDEq2Ls tenableofficial/nessus

#进入nessus容器
docker exec -it nessus bash
#启动nessus服务
/opt/scripts/configure_scanner.py

访问nessus界面

https://localhost:8834

用户名和口令为创建nessus容器时配置的用户名和口令

username:Nessus
password:HDuUNO1XzDEq2Ls

二、官方注册插件库和激活码

官网插件库地址：
https://plugins.nessus.org/v2/offline.php

获取第一个值Challenge code

#进入Nessus容器
docker exec -it nessus bash
#生成匹配Challenge code
/opt/nessus/sbin/nessuscli fetch --challenge

Challenge code: be86f8bde86494e544d6bad87c2ea9122f8b012d

获取第二个值激活码Activation Code

进入官网，邮箱注册获取激活码，填写邮箱接收邮件
https://zh-cn.tenable.com/products/nessus/nessus-essentials?tns_redirect=true

获取激活码

提交获取插件下载地址和证书内容

插件下载地址及激活码License

更新docker中nessus插件库

将下载的插件库上传至nessus容器中

#从Docker宿主机复制文件到Docker容器 all-2.0.tar.gz插件位置看个人上传宿主机目录
docker cp /data/middleware/nessus/all-2.0.tar.gz nessus:/usr/local/
#Docker容器中更新插件库
docker exec -it nessus /bin/bash
cd /usr/local
#更新插件库
/opt/nessus/sbin/nessuscli update all-2.0.tar.gz

激活Nessus

#进入容器
docker exec -it nessus /bin/bash
cd /usr/local
#填写刚才所获得的激活码
vi nessus.license

-----BEGIN TENABLE LICENSE-----
aTJZK2tGL1NQY3Fad2UrR0pWeWRobFpxdjJiY1F3d0Q0cEk0OWJtR3FuYjhmOTduOUF1OUMrY0FF
SmRVTkNJUUp5dEN6WTFiY1UrTnlsMG02VEQ0eUZBNU0yVGNDNDA4MmRMZEYyZy9VelhacWYyY3JH
aXFkY29kdnRhUzJtNytBbnJpUnprU21URjQva21kT3VwRWNVYmlHb0QzaXFUekNtZnZITnJaVldx
Wmh1eEFxYU9Pb2cwQW5GZXVRTWFsS1ZOODRBaXBGbFNJWjRrUi9XUUtGYWZZTmY1RGplZjZWVE1F
aUgzUDJnRmxSazJ2WFI4ZVcyazBPVEQ4R3JuTlpIaUZnNVZKdkZqdHJLZ1lYNlBRcU4zTWhIdzZF
Z2ZlajZqaG5QeUpWSkhSVFlTaHcvdzB3OEZUVXRZNU1TZmttRWlpT1lEOHcxejM2STlha1BCSGFB
dERETmFxN3l6SXJ4QTQ3ekRlY3FiS0lLYUhwWUMyeFpPbGNoV3VXZloxNGRvSXRySnFGVXB6MXRP
TERDUkNGQ2lHSHIrYUtjMUM1SUpqWTZKcFRiSHIrZm5wU3k2VDMrY1NzeU1JV3VyUmw1cUNFVWVs
WkJudUxXNkg4R0pwd3gvZEdHYi9TUjNpVjV2dzFoQUpGWG91K2NqM04zTktKVE5VcUp2Zi9URUth
SHNKTy9uWW9ZeXpGck9IUGtzWmxpdVdnMzR6U3V1MGpEamZZYVFsK3Y2ZkRlUHp5dU4vZjhhREdw
MUpSQTN4NGYwUTl3dzg0aXdKd0Zyb0Z1L3ltZE9ValIrbGR2cWFpemp3b0k3cnVCckpiNXlJb0tw
bXR3NDF4OWx5aXFPczM5d056bEkrUlN1UlpRV1BJNDJjUStFN2dwOVA4dUhndzVuZmNXK2RySzA9
DQp7ImFjdGl2YXRpb25fY29kZSI6IkdSQTctMkxVRC1EUENOLTg1WEQtWE1CTSIsInVwZGF0ZV9w
YXNzd29yZCI6ImY4MjM0OTFlYzExYjIxMGI0ODczYTllM2YxMzVlMDE3IiwicGVuZG9fYXBpX2tl
eSI6ImE3YzhkNWM0LWI2YWUtNDg2Ny03ZGFiLTY5YTkyYTA4NDdlMSIsIm5hbWUiOiJOZXNzdXMg
SG9tZSIsInR5cGUiOiJob21lIiwiZXhwaXJhdGlvbl9kYXRlIjoxODE5NTkzMzkwLCJjdXN0b21l
cl9pZCI6MCwiaXBzIjoxNiwidXBkYXRlX2xvZ2luIjoiMDdhOGZhNGZkYmYzNGIxNzU5NGZhNGUw
YTc1NmM2ZTAiLCJkcm0iOiJjMDUyOGZkOWQyNGIyZGQ0MDExMmZjZTNlM2I2NzY1MiJ9
-----END TENABLE LICENSE-----

激活

/opt/nessus/sbin/nessuscli fetch --register-offline nessus.license
#重启nessus
/opt/scripts/configure_scanner.py

等待加载插件库后访问nessus界面

https://localhost:8834

username:Nessus
password:HDuUNO1XzDEq2Ls

插件正常加载

三、Nessus破解修改限制

#nessus初始化完成后Hosts显示为"0 of 16 used”，修改其限制
docker exec -it nessus /bin/bash
#复制插件到容器根目录
cp -r /opt/nessus/lib/nessus/plugins/ /
#查看plugins插件库复制是否成功，若不成功则重新复制
du -h /plugins/
#删除重新复制
rm -rf /plugins
cp -r /opt/nessus/lib/nessus/plugins/ /

• 查看plugin_feed_info.inc文件位置

[root@7b287c8f02b0 /]# find / -name "plugin_feed_info.inc"
/opt/nessus/var/nessus/plugin_feed_info.inc
/opt/nessus/lib/nessus/plugins/plugin_feed_info.inc

• 备份plugin_feed_info.inc

mkdir /pluginsinc
cp /opt/nessus/lib/nessus/plugins/plugin_feed_info.inc /pluginsinc/plugin_feed_info.inc.libinc
cp /opt/nessus/var/nessus/plugin_feed_info.inc /pluginsinc/plugin_feed_info.inc.varinc

• 将plugin_feed_info.inc内容修改为专业版，PLUGIN_SET序号号为Policy Template Version=202208301606或其后序号

vi /pluginsinc/plugin_feed_info.inc
PLUGIN_SET = "202208301606";
PLUGIN_FEED = "ProfessionalFeed (Direct)";
PLUGIN_FEED_TRANSPORT = "Tenable Network Security Lightning";

• 关闭Nessus服务

supervisorctl stop nessusd
rm -f /opt/nessus/lib/nessus/plugins/plugin_feed_info.inc
cp /pluginsinc/plugin_feed_info.inc /opt/nessus/var/nessus/plugin_feed_info.inc

• 重启Nessus服务

supervisorctl start nessusd
du -h /opt/nessus/lib/nessus/plugins/
more /opt/nessus/lib/nessus/plugins/plugin_feed_info.inc
more /opt/nessus/var/nessus/plugin_feed_info.inc

• 访问Nessus并更新规则库，此过程特慢需放置等待

• 查看状态

du -h /opt/nessus/lib/nessus/plugins/
more /opt/nessus/lib/nessus/plugins/plugin_feed_info.inc
more /opt/nessus/var/nessus/plugin_feed_info.inc
#若状态异常，重新执行插件删除程序
rm -rf /opt/nessus/lib/nessus/plugins/
cp -r /plugins /opt/nessus/lib/nessus/
supervisorctl stop nessusd
rm -f /opt/nessus/lib/nessus/plugins/plugin_feed_info.inc
cp /pluginsinc/plugin_feed_info.inc /opt/nessus/var/nessus/plugin_feed_info.inc
supervisorctl start nessusd

重置启动

因服务重启时unlimited失效，根据状态异常操作步骤重新操作，编写nessus_start.sh代替service nessusd start，因为命令执行过程较长且Nessus需要重新加载插件，启动过程慢是正常现象。

vi /root/nessus_start.sh

#!/bin/bash
rm -rf /opt/nessus/lib/nessus/plugins/
cp -r /plugins /opt/nessus/lib/nessus/
supervisorctl stop nessusd
rm -f /opt/nessus/lib/nessus/plugins/plugin_feed_info.inc
cp /pluginsinc/plugin_feed_info.inc /opt/nessus/var/nessus/plugin_feed_info.inc
supervisorctl start nessusd

chmod +x /root/nessus_start.sh

手动执行脚本

/root/nessus_start.sh

CentOS Docker环境部署Nessus漏洞扫描 系列一最先出现在Liao's blog。

一、概述

1.1 定义

对于大规模的日志，需要集中化的管理。而ELK提供了一整套解决方案，并且都是开源软件，之间互相配合使用，完美衔接，高效的满足了很多场合的应用。ELK是三种技术产品的简称，包括Elasticsearch、Logstash、Kibana，可在项目中作为日志框架使用。

1.2 功能说明

• Elasticsearch是个开源分布式搜索引擎，提供搜集、分析、存储数据三大功能。

• Logstash 主要是用来日志的搜集、分析、过滤日志的工具，支持大量的数据获取方式。

• Kibana 也是一个开源和免费的工具，Kibana可以为 Logstash 和 ElasticSearch 提供的日志分析友好的 Web 界面，可以帮助汇总、分析和搜索重要数据日志。

简单来说，应用服务生产日志，通过Logger产生日志并输出；Logstash通过http接收应用服务产生的日志；Elasticsearch为日志提供全文检索功能；kibana为Elasticsearch提供图形化界面。

二、部署ELK

部署环境

• CentOS Linux release 7.9.2009 (Core)
• Docker Version: 20.10.12
• Docker Compose version v2.3.4

2.1 创建目录及配置文件

1) 创建elasticsearch数据目录及插件目录

mkdir -p /home/middleware/elk/elasticsearch/data
mkdir -p /home/middleware/elk/elasticsearch/plugins
//elasticsearch数据文件夹授权，保障docker容器中读写权限
chmod 777 /home/middleware/elk/elasticsearch/data

2) 创建kibana目录，以便后续汉化操作

mkdir -p /home/middleware/elk/kibana/config
touch /home/middleware/elk/kibana/config/kibana.yml

配置kibana汉化

vim /home/middleware/elk/kibana/config/kibana.yml

#
# ** THIS IS AN AUTO-GENERATED FILE **
#

# Default Kibana configuration for docker target
server.host: "0.0.0.0"
server.shutdownTimeout: "5s"
# 注意你的本地IP
elasticsearch.hosts: [ "http://本地IP:9200" ]
monitoring.ui.container.elasticsearch.enabled: true
#汉化
i18n.locale: "zh-CN"

3) 创建logstash.conf配置文件

mkdir -p /home/middleware/elk/logstash.conf配置文件/conf.d/
touch /home/middleware/elk/logstash/conf.d/logstash.conf

编辑配置logstash.conf，其内容如下

vim /home/middleware/elk/logstash/conf.d/logstash.conf

input {
  tcp {
    mode => "server"
    host => "0.0.0.0"
    port => 4560
    codec => json
  }
}
output {
  elasticsearch {
    hosts => "es:9200"
    index => "logstash-%{+YYYY.MM.dd}"
  }
}

在这里指定了输入的日志的端口是4560，那么下面对外暴露的端口也必须是4560。

4) 创建docker-compose.yml文件

touch /home/middleware/elk/docker-compose.yml

2.2 配置docker-compose并启动

cd /home/middleware/elk
vim docker-compose.yml

配置内容如下：

version: '3.7'
services:
  elasticsearch:
    image: elasticsearch:7.17.1
    container_name: elasticsearch
    privileged: true
    user: root
    environment:
      #设置集群名称为elasticsearch
      - cluster.name=elasticsearch 
      #以单一节点模式启动
      - discovery.type=single-node 
      #设置使用jvm内存大小
      - ES_JAVA_OPTS=-Xms512m -Xmx512m 
    volumes:
      - /home/middleware/elk/elasticsearch/plugins:/usr/share/elasticsearch/plugins
      - /home/middleware/elk/elasticsearch/data:/usr/share/elasticsearch/data
    ports:
      - 9200:9200
      - 9300:9300

  logstash:
    image: logstash:7.17.1
    container_name: logstash
    ports:
       - 4560:4560
    privileged: true
    environment:
      - TZ=Asia/Shanghai
    volumes:
      #挂载logstash的配置文件
      - /home/middleware/elk/logstash/conf.d/logstash.conf:/usr/share/logstash/pipeline/logstash.conf
    depends_on:
      - elasticsearch 
    links:
      #可以用es这个域名访问elasticsearch服务
      - elasticsearch:es 

  kibana:
    image: kibana:7.17.1
    container_name: kibana
    ports:
        - 5601:5601
    privileged: true
    links:
      #可以用es这个域名访问elasticsearch服务
      - elasticsearch:es 
    depends_on:
      - elasticsearch 
    environment:
      #设置访问elasticsearch的地址
      - elasticsearch.hosts=http://elasticsearch:9200
    volumes:
      - /home/middleware/elk/kibana/config/kibana.yml:/usr/share/kibana/config/kibana.yml

这里使用privileged设置为true是赋予这个容器root权限。然后启动

5) docker-compose启动elk

完整目录结构如下图

cd /home/middleware/elk
docker-compose up -d

若启动报错，需要先关闭并删除容器后再重新启动。关闭删除命令：

docker-compose down

2.3 打开kibana

输入http://192.168.1.104:5601/app/home，访问Kibana web界面。点击左侧设置，进入Management界面

三、日志收集

本文通过SpringBoot架构把日志信息记录到logstash。

3.1 环境准备

• IntelliJ IDEA 2019.3.5
• Spring-boot

3.1.1 创建springboot项目

1) 打开IDEA，新建File -> New -> Project -> Spring Initializr

2) 创建springelk测试项目

3) 新建一个springboot的项目，在 pom.xml 下导入以下web的依赖

<!--集成logstash开始-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>net.logstash.logback</groupId>
            <artifactId>logstash-logback-encoder</artifactId>
            <version>6.6</version>
        </dependency>
<!--集成logstash结束-->

3.1.2 使用logback记录日志

logback是SpringBoot自带的日志，只要导入了web的依赖即可使用。
1) 在测试包下新建一个测试类和测试方法

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 *
 * @author lkh
 * date:2022-03-30
 */

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringElkTest.class)
public class SpringElkTest {
//创建log对象

    Logger logger = LogManager.getLogger(this.getClass());

    @Test
    public void logback() {
        logger.info("这是一个logback日志Info信息");
        logger.error("这是一个logback日志Error信息");
    }

}

2）在resources目录新建logback-spring.xml

写入以下内容

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration>
<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
    <include resource="org/springframework/boot/logging/logback/console-appender.xml"/>
    <!--应用名称-->
    <property name="APP_NAME" value="springboot-logback-elk-demo"/>
    <!--日志文件保存路径-->
    <property name="LOG_FILE_PATH" value="{LOG_FILE:-{LOG_PATH:-{LOG_TEMP:-{java.io.tmpdir:-/tmp}}}/logs}"/>
    <contextName>{APP_NAME}</contextName>
    <!--每天记录日志到文件appender-->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>{LOG_FILE_PATH}/{APP_NAME}-%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>{FILE_LOG_PATTERN}</pattern>
        </encoder>
    </appender>
    <!--输出到logstash的appender-->
    <appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <!--可以访问的logstash日志收集端口-->
        <destination>192.168.1.104:4560</destination>
        <encoder charset="UTF-8" class="net.logstash.logback.encoder.LogstashEncoder"/>
    </appender>
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
        <appender-ref ref="LOGSTASH"/>
    </root>
</configuration>

3) 然后启动测试方法，查看控制台日志。

4) 返回kibana页面，创建索引，已自动搜索展示出来

5) 选择Discover,可以看到刚才打印的日志已经反馈到kibana中

查看信息时，建议在左侧Available fields中筛选出"message"信息，"host"字段可选。筛选的字段在左侧也可以看到，右侧看到的信息就比较清晰。

需要注意的是，在这些日志中，时间是logstash收集日志时的创建时间，并不是原始日志的记录时间。

3.1.3 使用log4j2记录日志

要使用log4j2，则必须排除SpringBoot自带的日志。
1) pom.xml中排除logback并导入log4j2依赖

<!--集成log4j2开始-->
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter</artifactId>
                    <exclusions>
                        <!-- 引入log4j日志时需去掉默认的logback -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- 日志管理log4j2 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
            <version>2.1.0.RELEASE</version>
        </dependency>
        <!--集成log4j2结束 -->

在资源目录下新建log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>

<configuration status="info">
    <Properties>
        <!-- 声明日志文件存储的目录 -->
        <Property name="LOG_HOME">E:\logs</Property>
        <Property name="LOG_PATTERN"
                  value="%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread][%class{36}:%line] - %msg%n"></Property>
    </Properties>

    <Appenders>
        <!--输出控制台的配置-->
        <Console name="Console" target="SYSTEM_OUT">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <!-- 输出日志的格式-->
            <PatternLayout pattern="{LOG_PATTERN}"/>
        </Console>

        <!--这输出日志到文件的配置，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFile" fileName="{LOG_HOME}\app_{date:yyyy-MM-dd}.log"
                     filePattern="{LOG_HOME}\{date:yyyy-MM}\app_%d{yyyy-MM-dd}_%i.log">
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <!-- 输出日志的格式-->
            <PatternLayout pattern="{LOG_PATTERN}"/>
            <!-- 日志文件大小 -->
            <SizeBasedTriggeringPolicy size="20MB"/>
            <!-- 最多保留文件数 -->
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>

        <!--输出到logstash的appender-->
        <Socket name="Socket" host="192.168.1.104" port="4560" protocol="TCP">
            <!--输出到logstash的日志格式-->
            <PatternLayout pattern="${LOG_PATTERN}"/>
        </Socket>
    </Appenders>

    <!--然后定义Logger，只有定义了Logger并引入的Appender，Appender才会生效。Root中level配置了日志级别，可配置其他级别-->
    <Loggers>
        <Root level="info">
            <AppenderRef ref="Console"/>
            <AppenderRef ref="RollingFile"/>
            <AppenderRef ref="Socket"/>
        </Root>
    </Loggers>

</configuration>

注意需要指定logstash服务的ip和记录日志的端口。

3) 新建测试类及方法

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 *
 * @author lkh
 * date:2022-03-30
 */

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringElkTest.class)
public class SpringElkTest {
//创建log对象

    Logger logger = LogManager.getLogger(this.getClass());

    /*@Test
    public void logback() {
        logger.info("这是一个logback日志Info信息test1111");
        logger.error("这是一个logback日志Error信息test1111");
    }*/

    @Test
    public void log4j2() {
        logger.info("这是一个log4j2日志Info信息");
        logger.error("这是一个log4j2日志Error信息");
    }

}

4) 启动测试方法

查看kibana的日志信息

查看信息时，建议在左侧Available fields中筛选出"message"信息，"thread_name"，"host"字段可选。筛选的字段在左侧也可以看到，右侧看到的信息就比较清晰，包含了日志本身的时间，这是是配置日志配置的。

Docker-compose安装部署ELK并集成SpringBoot最先出现在Liao's blog。

• Elasticsearch 是个开源分布式搜索引擎，它的特点有：分布式，零配置，自动发现，索引自动分片，索引副本机制，restful风格接口，多数据源，自动搜索负载等。
• Logstash 是一个完全开源的工具，它可以对你的日志进行收集、分析，并将其存储供以后使用。
• kibana 是一个开源和免费的工具，它可以为 Logstash 和 ElasticSearch 提供的日志分析友好的 Web 界面，可以帮助您汇总、分析和搜索重要数据日志。
• Filebeat 是用于单用途数据托运人的平台。它们以轻量级代理的形式安装，并将来自成百上千台机器的数据发送到 Logstash 或 Elasticsearch。

Docker 镜像统一从 https://hub.docker.com/ 下载 （安装时请使用统一版本）。保险起见我安装的是7.17.1版本

一、Docker 安装镜像

官网镜像地址：
https://hub.docker.com//elasticsearch
https://hub.docker.com//kibana
https://hub.docker.com//logstash
https://hub.docker.com//filebeat

# 下载镜像 查看镜像
docker pull elasticsearch:7.17.1
docker pull kibana:7.17.1
docker pull logstash:7.17.1
docker pull store/elastic/filebeat:7.17.1
docker images

1. Docker 安装启动 Elasticsearch

# 创建自定义的网络(用于连接到连接到同一网络的其他服务(例如Kibana))
docker network create elknetwork

# 运行 elasticsearch
docker run -d --name elasticsearch \
--net elknetwork  -p 9200:9200 -p 9300:9300 \
-e "ES_JAVA_OPTS=-Xms2048m -Xmx2048m" \
-e "discovery.type=single-node" \
elasticsearch:7.17.1

# 查看容器状态
docker ps

访问：http://IP:9200 Elasticsearch 安装启动完成

2. Docker 安装启动 Kibana

# 汉化kibana
mkdir -p /data/dockerfile/kibana/config
cd /data/dockerfile/kibana/config
vim kibana.yml

    #
    # ** THIS IS AN AUTO-GENERATED FILE **
    #
    # Default Kibana configuration for docker target
    server.host: "0.0.0.0"
    server.shutdownTimeout: "5s"
    # 注意你的本地IP
    elasticsearch.hosts: [ "http://yourip:9200" ] 
    monitoring.ui.container.elasticsearch.enabled: true
    i18n.locale: "zh-CN"

# 启动kibana

docker run -d --name kibana --net elknetwork -p 5601:5601 \
-v /data/dockerfile/kibana/config/kibana.yml:/usr/share/kibana/config/kibana.yml \
kibana:7.17.1

3. Docker 安装启动 logstash

mkdir -p /data/dockerfile/logstash/conf.d
cd /data/dockerfile/logstash
vim logstash.yml
    http.host: "0.0.0.0"
    #配置elasticsearch集群地址
    xpack.monitoring.elasticsearch.hosts: [ "http://yourip:9200" ]
    ##允许监控
    xpack.monitoring.enabled: true
    ##目录为挂载目录，启动命令指定的
    path.config: /usr/share/logstash/conf.d/my.conf

vim conf.d/my.conf
    input {
       beats {
         port => 5044
         client_inactivity_timeout => 36000
      }
    }
    output {
      elasticsearch {
        hosts => ["http://yourip:9200"]
        index  => "index-%{+YYYY.MM}"
      }
    }

# 启动logstash
docker run -it -d -p 5044:5044 --name logstash  \
-v /data/dockerfile/logstash/logstash.yml:/usr/share/logstash/config/logstash.yml \
-v /data/dockerfile/logstash/conf.d/:/usr/share/logstash/conf.d/ \
logstash:7.17.1

4. Docker 安装启动 filebeat

mkdir -p /data/dockerfile/filebeat
vim /data/dockerfile/filebeat/filebeat.yml

    # 定义应用的input类型、以及存放的具体路径
    filebeat.inputs:
      #nginx
    - type: log
      enabled: true
      paths:
        - /var/log/nginx/*.log
      tags: ["nginx"]
      fields:
        index: nginx
      #systemlogs
    - type: log
      enabled: true
      paths:
        - /var/log/messages
      tags: ["messages"]
      fields:
        index: messages

    #============================= Filebeat modules ===============================
    filebeat.config.modules:
      # Glob pattern for configuration loading
      path: ${path.config}/modules.d/*.yml
      # Set to true to enable config reloading
      reload.enabled: true

    # ============================== logstash =====================================  
    output.logstash:
      hosts: ["yourip:5044"] #localhost为logstash安装的服务器ip
      enabled: true
    #============================== Kibana =====================================
    setup.kibana:
      host: "yourip:5601"

    #============================== elasticsearch =====================================
    #output.elasticsearch:
    #  hosts: ["yourip:9200"]
    #  enabled: true

# 启动 filebeat

docker run -d  -u root --name filebeat --net elknetwork \
-v /usr/local/nginx/logs:/var/log/nginx:rw \
-v /var/log/messages:/var/log/messages:rw \
-v /data/dockerfile/filebeat/filebeat.yml:/usr/share/filebeat/filebeat.yml:ro \
store/elastic/filebeat:7.17.1

二、创建索引，查看ELK抓取日志

1. 进入Stack management

2. 选择 Kibana->索引模式->创建索引
   可以看到右侧已经自动获取到我在logstash配置文件下简建立的index索引：/usr/share/logstash/conf.d/my.conf

3. 选择Discovre

可以看到监控的/var/log/messages以及/usr/local/nginx/logs/日志文件都显示出来了。

效果1

效果2

DOCKER安装部署ELK (ELASTICSEARCH+KIBANA+LOGSTASH+FILEBEAT)最先出现在Liao's blog。

蓝奏云下载地址：蓝奏云地址

官网下载地址：docker.com

二、安装

1、安装环境

• 操作系统：CentOS Linux release 7.9.2009 (Core)
• Docker版本：Server Version: 18.09.8

2、安装

rpm -ivh docker-ce-cli-18.09.8-3.el7.x86_64.rpm  --nodeps --force
rpm -ivh container-selinux-2.107-3.el7.noarch.rpm  --nodeps --force
rpm -ivh containerd.io-1.2.2-3.el7.x86_64.rpm  --nodeps --force
rpm -ivh docker-ce-18.09.8-3.el7.x86_64.rpm  --nodeps --force

3、启动

# 启动
systemctl start docker 

# 查看状态
systemctl status docker 

4、更改docker存储目录

戳以往教程

CentOS7离线安装docker-ce最先出现在Liao's blog。

更新

全自动获取CK值，在之前用的是浏览器开发工具或插件获取。

网页版

全自动ck获取服务说明
1. 安装 docker run --name service1 -p 5100:5100 -d asupc/service -restart:always
2. 云服务器放行端口 5100 ， 如需要修改端口请修改冒号前的5100。
3. 浏览器访问 http://ip:5100/api/service 正常情况浏览器返回"量子公共服务。"
4. 获取短信验证码接口 http://ip:5100/api/sms/{phone}  get 请求。如： http://192.168.2.2:5100/api/sms/1888888888
5. 验证短信验证码接口 http://ip:5100/api/sms/{phone}/{code}  get 请求，成功后返回ck信息。如： http://192.168.2.2:5100/api/sms/1888888888/123456

效果

1、可以看到发送了验证码

2、获取的CK值

Shell版

rm -rf ck sc pt
cl(){
read -p "请输入手机号: " mobile
appid=959
qversion=1.0.0
country_code=86
}
ck(){
ts=(expr(date +%s%N) / 1000000)
sub_cmd=1
gsign=(echo -nappidqversionts"36"sub_cmd"sb2cwlYyaCSN1KUv5RHG3tmqxfEb8NKN" | md5sum | cut -d ' ' -f1)
d="client_ver=1.0.0&gsign=gsign&appid=appid&return_page=https%3A%2F%2Fcrpl.jd.com%2Fn%2Fmine%3FpartnerId%3DWBTF0KYY%26ADTAG%3Dkyy_mrqd%26token%3D&cmd=36&sdk_ver=1.0.0&sub_cmd=sub_cmd&qversion=qversion&ts=ts"
l={#d}
curl -s -k -i --raw -o ck --http2 -X POST -H "Host:qapplogin.m.jd.com" -H "cookie:" -H "user-agent:Mozilla/5.0 (Linux; Android 10; V1838T Build/QP1A.190711.020; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/98.0.4758.87 Mobile Safari/537.36 hap/1.9/vivo com.vivo.hybrid/1.9.6.302 com.jd.crplandroidhap/1.0.3 ({"packageName":"com.vivo.hybrid","type":"deeplink","extra":{}})" -H "accept-language:zh-CN,zh;q=0.9,en;q=0.8" -H "content-type:application/x-www-form-urlencoded; charset=utf-8" -H "content-length:l" -H "accept-encoding:" -d "d" "https://qapplogin.m.jd.com/cgi-bin/qapp/quick"
gsalt=(cat ck | grep -o "gsalt.*" | cut -d '"' -f3)
guid=(cat ck | grep -o "guid.*" | cut -d '"' -f3)
lsid=(cat ck | grep -o "lsid.*" | cut -d '"' -f3)
rsa_modulus=(cat ck | grep -o "rsa_modulus.*" | cut -d '"' -f3)
ck=(echo "guid=guid;  lsid=lsid;  gsalt=gsalt;  rsa_modulus=rsa_modulus;")
}
sc(){
ts=(expr(date +%s%N) / 1000000)
sub_cmd=2
gsign=(echo -nappidqversionts"36"sub_cmdgsalt | md5sum | cut -d ' ' -f1)
sign=(echo -nappidqversioncountry_codemobile'4dtyyzKF3w6o54fJZnmeW3bVHl0PbXj' | md5sum | cut -d ' ' -f1)
d="country_code=country_code&client_ver=1.0.0&gsign=gsign&appid=appid&mobile=mobile&sign=sign&cmd=36&sub_cmd=sub_cmd&qversion=qversion&ts=ts"
l={#d}
curl -s -k -i --raw -o sc --http2 -X POST -H "Host:qapplogin.m.jd.com" -H "cookie:ck" -H "user-agent:Mozilla/5.0 (Linux; Android 10; V1838T Build/QP1A.190711.020; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/98.0.4758.87 Mobile Safari/537.36 hap/1.9/vivo com.vivo.hybrid/1.9.6.302 com.jd.crplandroidhap/1.0.3 ({"packageName":"com.vivo.hybrid","type":"deeplink","extra":{}})" -H "accept-language:zh-CN,zh;q=0.9,en;q=0.8" -H "content-type:application/x-www-form-urlencoded; charset=utf-8" -H "content-length:l" -H "accept-encoding:" -d "d" "https://qapplogin.m.jd.com/cgi-bin/qapp/quick"
err_msg=(cat sc | grep -o "err_msg.*" | cut -d '"' -f3)
[ -zerr_msg ] && echo 手机号为mobile的验证码发送成功 || echoerr_msg
}
pt(){
read -p "请输入验证码: " smscode
ts=(expr(date +%s%N) / 1000000)
sub_cmd=3
gsign=(echo -nappidqversionts"36"sub_cmdgsalt | md5sum | cut -d ' ' -f1)
d="country_code=country_code&client_ver=1.0.0&gsign=gsign&smscode=smscode&appid=appid&mobile=mobile&cmd=36&sub_cmd=sub_cmd&qversion=qversion&ts=ts"
l={#d}
curl -s -k -i --raw -o pt --http2 -X POST -H "Host:qapplogin.m.jd.com" -H "cookie:ck" -H "user-agent:Mozilla/5.0 (Linux; Android 10; V1838T Build/QP1A.190711.020; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/98.0.4758.87 Mobile Safari/537.36 hap/1.9/vivo com.vivo.hybrid/1.9.6.302 com.jd.crplandroidhap/1.0.3 ({"packageName":"com.vivo.hybrid","type":"deeplink","extra":{}})" -H "accept-language:zh-CN,zh;q=0.9,en;q=0.8" -H "content-type:application/x-www-form-urlencoded; charset=utf-8" -H "content-length:l" -H "accept-encoding:" -d "country_code=country_code&client_ver=1.0.0&gsign=gsign&smscode=smscode&appid=appid&mobile=mobile&cmd=36&sub_cmd=sub_cmd&qversion=qversion&ts=ts" "https://qapplogin.m.jd.com/cgi-bin/qapp/quick"
err_msg=(cat pt | grep -o "err_msg.*" | cut -d '"' -f3)
if [ -z err_msg ]
then pt_key=(cat pt | grep -o "pt_key.*" | cut -d '"' -f3)
pt_pin=(cat pt | grep -o "pt_pin.*" | cut -d '"' -f3)
qlck="pt_key=pt_key;pt_pin=pt_pin;"
echo 你的JD_COOKIE为qlck 
rm -rf ck sc pt
else echo err_msg
fi
}
cl && ck && sc
[ -zerr_msg ] && pt

下载地址：蓝奏云ptkey.zip

效果

如遇到报错信息curl: option --http2: is unknown，安装nghttp2模块
教程地址：安装教程

前言

支持多种脚本语言（python3、javaScript、shell、typescript）
支持在线管理脚本、环境变量、配置文件
支持在线查看任务日志
支持秒级任务设置
支持系统级通知
支持暗黑模式
支持手机端操作

其实很多人都只是拿它作为一个薅京东羊毛的管理工具，我也是。

搭建面板

先安装docker，可参考官方文档：https://github.com/whyour/qinglong

启动青龙面板，很多人都用的初始端口5700，但用多了很多人就会频繁攻击，这里换成了5888（随意）。

访问青龙面板

http://IP:5888/
设置账号密码即可。

拉取第三方库

1.容器内拉取

• KingRan库

#进入容器
docker exec -it qinglong bash
#推荐使用下方库(更新拉库命令)
#拉库命令：
#国内鸡：
ql repo https://github.com.cnpmjs.org/KingRan/JDJB.git "jd_|jx_|jdCookie" "activity|backUp" "^jd[^_]|USER|utils|function|sign|sendNotify|ql|JDJR"
#国外鸡：
ql repo ql repo https://github.com/KingRan/JDJB.git "jd_|jx_|jdCookie" "activity|backUp" "^jd[^_]|USER|utils|function|sign|sendNotify|ql|JDJR"

• ccwav库

#ccwav的资产通知增强版和CK检测
#2.10.3之前版本青龙拉库命令:
#不包含sendNotify:
ql repo https://github.com/ccwav/QLScript2.git "jd_" "NoUsed" "ql|utils"
#包含sendNotify:
ql repo https://github.com/ccwav/QLScript2.git "jd_" "NoUsed" "ql|sendNotify|utils"
2.10.3之后版本青龙拉库命令:
#不包含sendNotify:
ql repo https://github.com/ccwav/QLScript2.git "jd_" "NoUsed" "ql|utils|USER_AGENTS|jdCookie|JS_USER_AGENTS"
#包含sendNotify:
ql repo https://github.com/ccwav/QLScript2.git "jd_" "NoUsed" "ql|sendNotify|utils|USER_AGENTS|jdCookie|JS_USER_AGENTS"

2.面板页面拉取

• 定时任务中新建即可，加上定时器

3.成功入库
可以看到很多定时脚本已经在面板中

配置京东账号

在环境变量中新增京东Cookie值，如何获取这两个值可以在网页端操作。

• pt_key
• pt_pin

获取Cookie

• 电脑浏览器无痕模式打开京东网址 https://m.jd.com/
• 登录手机用户

• 登录之后，按F12进入开发者模式，选择网络，点击Fetch/XHR

• 刷新页面，可以在下接口返回值中，看到cookie，从中找到 pt_key、pt_pin

配置通知方式

创建群组，创建webhook消息机器人，获取token值

更多的玩法，可以自行摸索，低调行事。

Docker搭建青龙面板最先出现在Liao's blog。

2022新春佳节，虎年~最先出现在Liao's blog。

环境准备

拉取mysql、nextcloud、redis镜像

docker pull mysql
docker pull nextcloud
docker pull redis

安装mysql

docker run -p 3306:3306 --restart=always --name mysql -v /usr/local/mysql/conf:/etc/mysql/conf.d -v /usr/local/mysql/logs:/logs -v /usr/local/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql

配置mysql

docker exec -it mysql容器ID /bin/bash
root@ID:/# mysql -u root -p
mysql> GRANT ALL PRIVILEGES on *.* to root@'%' WITH GRANT OPTION;
mysql> ALTER USER 'root'@'%' IDENTIFIED BY '123456' PASSWORD EXPIRE NEVER;
Query OK, 0 rows affected (0.02 sec)
mysql> ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
 Query OK, 0 rows affected (0.01 sec)
mysql> FLUSH PRIVILEGES;
mysql> exit

安装Nextcloud

mkdir -p /home/nextcloud
docker run -d --name=nextcloud  -v /home/nextcloud:/var/www/html -p 8000:80 --restart=always nextcloud

配置nextcloud

• 设置用户名、密码
• 配置连接mysql 数据库配置信息（数据库【没有时可自动创建】、用户名、密码、IP地址）

访问nextcloud

因为我已经安装配置过了，当时没有截图，就大致写一下

http://IP:8000

安装完成，输入安装时创建的管理员账号密码登录即可。

安装Redis，优化nextcloud访问

mkdir -p /home/redis/conf
mkdir -p /home/redis/data

#新增redis配置文件
cd /home/redis/conf
touch redis.conf

修改redis配置文件：vim redis.conf

#bind 127.0.0.1
protected-mode no
appendonly yes
requirepass 123456

启动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 redis-server /etc/redis/redis.conf

• docker run表示运行的意思
• –name redis表示运行容器的名字叫myredis
• -p 6379:6379表示将服务器的6379（冒号前的6379）端口映射到docker的6379（冒号后的6379）端口，这样就可以通过服务器的端口访问到docker容器的端口了
• -d 表示以后台服务的形式运行redis
• -v /home/redis/data:/data表示将服务器上的/home/redis/data映射为docker容器上的/data ，这样/data中产生的数据就可以持久化到本地的目录下了
• -v /home/redis/conf/redis.conf:/etc/redis/redis.conf表示将本地/home/redis/conf/redis.conf映射为docker容器上的/etc/redis/redis.conf，这样再配合指令末尾的redis redis-server /etc/redis/redis.conf实现让docker容器运行时使用本地配置的Redis配置文件的功能了。
• redis redis-server /etc/redis/redis.conf表示运行redis服务器程序，并且指定运行时的配置文件

docker ps 查看服务是否启动

配置nextcloud+redis

cd /home/nextcloud/config

修改 vim config.php
在末尾添加如下代码

'redis' => 
  array (
    'host' => '192.168.1.104',
    'port' => 6379,
    'password' => '123456',
  ),

重启nextcloud

docker restart nextcloud

进入redis容器查看是否已进入缓存

docker exec -it redis bash

#进入redis-cli
> redis-cli
> auth "123456"
> keys *

可以看到已经有值进来了，就证明已经成功。

效果

颜值确实在线。

Nextcloud在应用市场内还有很多支持的apps，有兴趣可以多研究看看

Docker安装Nextcloud个人/团队网盘并配置redis优化最先出现在Liao's blog。

Portainer是一个可视化的容器镜像的图形管理工具，利用Portainer可以轻松构建，管理和维护Docker环境。 而且完全免费，基于容器化的安装方式，方便高效部署。

官方网站:

https://www.portainer.io/

Protainer安装说明

官方安装说明：

https://www.portainer.io/installation/

使用docker安装：

（1）搜索镜像：

docker search Portainer
docker pull portainer/portainer

（2）启动Portainer

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

（3）登录Portainer

输入服务器地址：服务器IP:9000（如果是云服务器地址，应该登录云服务台，开放9000端口）
– 首次登录需要设置admin的密码

• 选择docker连接
  • 选择Local，代表本地模式，portainer仅管理本机的docker容器
  • 选择Remote，代表远程模式，名称随意，在Endpoint URL中填写docker节点的地址:docker远程端口（docker安装教程中的设置的-H 0.0.0.0:2375中的2375）

管理docker

进入管理台以后，可以查看本地镜像，正在运行的容器…….

安装Protainer以后，包括拉取镜像，删除镜像，启动、删除容器等等命令都可以在该界面一键操作。
后续自行摸索~

安装Protainer可视化软件管理Docker最先出现在Liao's blog。

Docker从1.13版本之后采用时间线的方式作为版本号，分为社区版CE和企业版EE。

社区版是免费提供给个人开发者和小型团体使用的，企业版会提供额外的收费服务，比如经过官方测试认证过的基础设施、容器、插件等。

社区版按照stable和edge两种方式发布，每个季度更新stable版本，如17.06，17.09；每个月份更新edge版本，如17.09，17.10。

一、安装docker

1、Docker 要求 CentOS 系统的内核版本高于 3.10 ，查看本页面的前提条件来验证你的CentOS 版本是否支持 Docker 。

通过 uname -r 命令查看你当前的内核版本

uname -r

2、使用 root 权限登录 Centos。确保 yum 包更新到最新。

yum update

3、卸载旧版本(如果安装过旧版本的话)

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

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

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

5、设置yum源

yum-config-manager --add-repo https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo
或
wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
或
curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo

#刷新缓存
yum makecache fast

6、可以查看所有仓库中所有docker版本，并选择特定版本安装

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

7、安装docker

yum install docker-ce 或 yum install docker-ce-18.06.3.ce
#由于repo中默认只开启stable仓库，故这里安装的是最新稳定版18.06.3.ce
yum install <FQPN>  # 例如：sudo yum install docker-ce-18.06.3.ce

8、启动并加入开机启动

systemctl start docker 
systemctl enable docker 

9、验证安装是否成功(有client和service两部分表示docker安装启动都成功了)

docker version 

（我已经自行升级到最新20版本）

二、更改docker默认存储位置

方法一：软连接

默认情况下Docker的存放位置为：/var/lib/docker
可以通过下面命令查看具体位置：

docker info | grep "Docker Root Dir"

解决这个问题，最直接的方法当然是挂载分区到这个目录，但是我的数据盘还有其他东西，这肯定不好管理，所以采用修改镜像和容器的存放路径的方式达到目的。
这个方法里将通过软连接来实现。
首先停掉Docker服务：

systemctl stop docker

然后移动整个/var/lib/docker目录到目的路径：

mv /var/lib/docker  /home/docker
ln -s /home/docker  /var/lib/docker

这时候启动Docker时发现存储目录依旧是/var/lib/docker，但是实际上是存储在数据盘的，你可以在数据盘上看到容量变化。

方法二：修改docker.service

关闭docker服务

systemctl stop docker.service

移动数据到新的目录

mv /var/lib/docker /home/docker

修改docker.service文件，使用-g参数指定存储位置

vi /usr/lib/systemd/system/docker.service  
ExecStart=/usr/bin/dockerd --graph /home/docker 

reload配置文件

systemctl daemon-reload 

重启docker

systemctl restart docker.service

查看数据目录

docker info | grep Dir

卸载docker

yum remove docker-ce
sudo rm -rf /var/lib/docker

Centos7安装Docker并更改默认存储文件位置最先出现在Liao's blog。

2022年5月17日更新

1、简介

Prometheus是由SoundCloud开发的开源监控报警系统和时序列数据库(TSDB)。
Prometheus使用Go语言开发，是Google BorgMon监控系统的开源版本。 2016年由Google发起Linux基金会旗下的原生云基金会(Cloud Native Computing Foundation), 将Prometheus纳入其下第二大开源项目。 Prometheus目前在开源社区相当活跃。
Prometheus和Heapster(Heapster是K8S的一个子项目，用于获取集群的性能数据。)相比功能更完善、更全面。Prometheus性能也足够支撑上万台规模的集群。

2、基本原理

Prometheus的基本原理是通过HTTP协议周期性抓取被监控组件的状态，任意组件只要提供对应的HTTP接口就可以接入监控。不需要任何SDK或者其他的集成过程。
这样做非常适合做虚拟化环境监控系统，比如VM、Docker、Kubernetes等。输出被监控组件信息的HTTP接口被叫做exporter。目前互联网公司常用的组件大部分
都有exporter可以直接使用，比如Varnish、Haproxy、Nginx、MySQL、Linux系统信息(包括磁盘、内存、CPU、网络等等)。

3、架构涉及

组件

• Prometheus Sever：是Prometheus组件中的核心部分，负责实现对监控数据的获取，存储及查询。
• Prometheus Server可以通过静态配置管理监控目标，也可以配合使用Service -Discovery的方式动态管理监控目标，并从这些监控目标中获取数据。其次Prometheus Sever需要对采集到的数据进行存储，Prometheus Server本身就是一个实时数据库，将采集到的监控数据按照时间序列的方式存储在本地磁盘当中。Prometheus Server对外提供了自定义的PromQL，实现对数据的查询以及分析。另外Prometheus Server的联邦集群能力可以使其从其他的Prometheus Server实例中获取数据。

• Exporter：将监控数据采集的端点通过HTTP服务的形式暴露给Prometheus Server，Prometheus Server通过访问该Exporter提供的Endpoint端点，即可以获取到需要采集的监控数据。可以将Exporter分为2类：
  直接采集：这一类Exporter直接内置了对Prometheus监控的支持，比如cAdvisor，Kubernetes，Etcd，Gokit等，都直接内置了用于向Prometheus暴露监控数据的端点。
  间接采集：原有监控目标并不直接支持Prometheus，因此需要通过Prometheus提供的Client Library编写该监控目标的监控采集程序。例如：Mysql Exporter，JMX Exporter，Consul Exporter等。

• Service Discovery：服务发现，Prometheus支持多种服务发现机制：文件，DNS，Consul,Kubernetes,OpenStack,EC2等等。基于服务发现的过程并不复杂，通过第三方提供的接口，Prometheus查询到需要监控的Target列表，然后轮询这些Target获取监控数据。
• AlertManager：在Prometheus Server中支持基于Prom QL创建告警规则，如果满足Prom QL定义的规则，则会产生一条告警。在AlertManager从 Prometheus server 端接收到 alerts后，会进行去除重复数据，分组，并路由到对收的接受方式，发出报警。常见的接收方式有：电子邮件，pagerduty，webhook 等。

• PushGateway：Prometheus数据采集基于Prometheus Server从Exporter pull数据，因此当网络环境不允许Prometheus Server和Exporter进行通信时，可以使用PushGateway来进行中转。通过PushGateway将内部网络的监控数据主动Push到Gateway中，Prometheus Server采用针对Exporter同样的方式，将监控数据从PushGateway pull到Prometheus Server。

工作流

1. Prometheus server定期从配置好的jobs或者exporters中拉取metrics，或者接收来自 Pushgateway发送过来的metrics，或者从其它的Prometheus server中拉metrics。
2. Prometheus server在本地存储收集到的metrics，并运行定义好的alerts.rules，记录新的时间序列或者向Alert manager推送警报。
3. Alertmanager根据配置文件，对接收到的警报进行处理，发出告警。
4. 在图形界面中，可视化采集数据。

常用的exporter整理

• node-exporter: 用来监控运算节点上的宿主机的资源信息，需要部署到所有运算节点
• kube-state-metric：prometheus采集k8s资源数据的exporter，能够采集绝大多数k8s内置资源的相关数据，例如pod、deploy、service等等。同时它也提供自己的数据，主要是资源采集个数和采集发生的异常次数统计
• cAdvisor （Container Advisor） ：用于监控正在运行的容器资源使用和性能信息。
  https://github.com/google/cadvisor
• Blackbox_exporter：监控业务容器存活性。可以提供 http、dns、tcp、icmp 的监控数据采集

二、环境准备

1. docker环境3台 server: 192.168.0.219 client: 192.168.0.89/192.168.0.199
2. 监控服务器 需要安装4个服务
   Prometheus Server(普罗米修斯监控主服务器 )
   Node Exporter (收集Host硬件和操作系统信息)
   cAdvisor (负责收集Host上运行的容器信息)
   Grafana (展示普罗米修斯监控界面）
3. 被监控的只需安装2个
   Node Exporter (收集Host硬件和操作系统信息)
   cAdvisor (负责收集Host上运行的容器信息)

三、部署node_exporter（server、client都安装）

docker pull prom/node-exporter #拉取最新镜像
docker run --name=node-exporter -p 9100:9100 -itd prom/node-exporter #启动exporter

访问节点信息
– server http://192.168.0.219:9100

• client http://192.168.0.89:9100
• client http://192.168.0.199:9100
  

四、安装prometheus server（server安装）

mkdir -p /data/docker/prometheus/{server,client}  #根据自身服务器情况编写路径
touch /data/docker/prometheus/server/rules.yml
编辑prometheus.yml文件，添加客户端信息

vim /data/docker/prometheus/server/prometheus.yml

global:
  scrape_interval:     60s
  evaluation_interval: 60s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets: ['localhost:9090']
        labels:
          instance: prometheus

  - job_name: 主节点
    static_configs:
      - targets: ['192.168.0.219:9100']
        labels:
          instance: 192.168.0.219

  - job_name: 副节点
    static_configs:
      - targets: ['192.168.0.89:9100']
        labels:
          instance: 192.168.0.89

  - job_name: 副节点
    static_configs:
      - targets: ['192.168.0.199:9100']
        labels:
          instance: 192.168.0.199

docker启动prometheus：

docker pull prom/prometheus

docker run --name prometheus -p 9090:9090 --restart=always \
-v /data/docker/prometheus/server/prometheus.yml:/etc/prometheus/prometheus.yml \
-v /data/docker/prometheus/server/rules.yml:/etc/prometheus/rules.yml \
-itd prom/prometheus \
--config.file=/etc/prometheus/prometheus.yml \
--web.enable-lifecycle

注：启动时加上
--web.enable-lifecycle： 启用远程热加载配置文件
--config.file：启动时加载配置文件

浏览器访问prometheus：http://192.168.0.219:9090

五、安装Grafana展示（server安装）

Grafana是用于可视化大型测量数据的开源程序，它提供了强大和优雅的方式去创建、共享、浏览数据。

1、先启动测试grafana

docker pull grafana/grafana
docker run --name=grafana -p 3000:3000 -itd grafana/grafana
#将配置文件复制到宿主机：
修改配置文件grafana.ini，配置smtp邮件报警信息（报警会用到）
docker cp grafana:/etc/grafana/grafana.ini /data/docker/prometheus/grafana/
docker rm -f grafana
#防止grafana生成文件权限受阻，全开放
chmod 777 /data/docker/prometheus/* 

2、正式启动grafana

docker run -p 3000:3000 --name grafana  --restart=always \
-v /data/docker/prometheus/grafana/grafana.ini:/etc/grafana/grafana.ini \
-v /data/docker/prometheus/grafana/data:/var/lib/grafana \
-e "GF_SECURITY_ADMIN_PASSWORD=XXXXX" \
-itd grafana/grafana

注：-e "GF_SECURITY_ADMIN_PASSWORD=XXXXX" 
是设置grafana登陆页面的密码,如不添加这条，默认账号密码为admin/admin

访问：http://192.168.0.219:3000 账号密码为：admin/XXXXX

3、添加prometheus数据源

4、添加模板文件：（监控主机信息）

官网模板地址：Dashboards | Grafana Labs
根据自己需求下载网址中模板，下载到本地后，导入grafana

也可以导入id号

选择Prometheus

5、展示

在面板上可选择节点查看

未完待续

Docker搭建Prometheus+grafana监控系统最先出现在Liao's blog。

一、安装WordPress

安装docker-compose

以二进制方式进行安装，首先在github中查看当前最新版本为1.29.2，如需更改版本，在下列代码中更改对应版号。

[root@instance]# curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-(uname -s)-(uname -m)" -o /usr/local/bin/docker-compose
[root@instance]# chmod +x /usr/local/bin/docker-compose
[root@instance]# ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
[root@instance]# docker-compose --version

安装好之后 docker-compose –version 查看信息

安装docker

1、官网下载，创建对应目录，下载docker最新包解压。

[root@insta]# mkdir -p /root/download
[root@insta]# cd /root/download
[root@insta]# wget https://download.docker.com/linux/static/stable/x86_64/docker-20.10.6.tgz
[root@insta]# tar -xvf docker-20.10.6.tgz

2、分发二进制文件到所有 worker 节点：

[root@insta]# mkdir -p /opt/docker/bin
[root@insta]# cp docker/*  /opt/docker/bin/
[root@insta]# chmod +x /opt/docker/bin/*

编辑环境变量：

[root@insta]# vim /etc/profile
 #添加变量   export PATH=/opt/docker/bin:$PATH
[root@insta]# source /etc/profile

3、创建和分发 systemd unit 文件

注意更改WorkingDirectory目录，自行定义

[root@insta]# cd /root/download
[root@insta]# cat > docker.service <<"EOF"
[Unit]
Description=Docker Application Container Engine
Documentation=http://docs.docker.io

[Service]
WorkingDirectory=/data/docker
Environment="PATH=/opt/docker/bin:/bin:/sbin:/usr/bin:/usr/sbin"
ExecStart=/opt/docker/bin/dockerd 
ExecReload=/bin/kill -s HUP $MAINPID
Restart=on-failure
RestartSec=5
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
Delegate=yes
KillMode=process

[Install]
WantedBy=multi-user.target
EOF

• EOF 前后有双引号，这样 bash 不会替换文档中的变量，如$DOCKER_NETWORK_OPTIONS；
• dockerd 运行时会调用其它 docker 命令，如 docker-proxy，所以需要将 docker 命令所在的目录加到 PATH 环境变量中；
• docker 需要以 root 用于运行；
• docker 从 1.13 版本开始，可能将 iptables FORWARD chain的默认策略设置为DROP，从而导致 ping 其它 Node 上的 Pod IP 失败，遇到这种情况时，需要手动设置策略为 ACCEPT：

[root@insta]# sudo iptables -P FORWARD ACCEPT

并且把以下命令写入 /etc/rc.local 文件中，防止节点重启iptables FORWARD chain的默认策略又还原为DROP

[root@insta]# vim /etc/rc.local
/sbin/iptables -P FORWARD ACCEPT
:wq

分发 systemd unit 文件到宿主机器:

[root@insta]# cp docker.service  /etc/systemd/system/

4、使用国内的仓库镜像服务器以加快 pull image 的速度，同时增加下载的并发数 (需要重启 dockerd 生效，目录自行定义)：

[root@insta]# cd /root/download
[root@insta]# mkdir -p /data/docker/data
[root@insta]# mkdir -p /data/docker/exec
[root@insta]# cat > daemon.json <<EOF
{
    "registry-mirrors": [ "https://477njxek.mirror.aliyuncs.com", "https://registry.docker-cn.com/", "https://hub-mirror.c.163.com", "https://docker.mirrors.ustc.edu.cn"],
    "insecure-registries": [],
    "max-concurrent-downloads": 20,
    "live-restore": true,
    "max-concurrent-uploads": 10,
    "debug": true,
    "data-root": "/data/docker/data",
    "exec-root": "/data/docker/exec",
    "log-opts": {
      "max-size": "100m",
      "max-file": "5"
    }
}
EOF

分发 docker 配置文件到所有宿主机节点：

[root@insta]# cd /root/download
[root@insta]# mkdir -p  /etc/docker/
[root@insta]# cp daemon.json /etc/docker/

5、启动docker服务

[root@insta]# systemctl stop firewalld && systemctl disable firewalld
[root@insta]# /usr/sbin/iptables -F && /usr/sbin/iptables -X && /usr/sbin/iptables -F -t nat && /usr/sbin/iptables -X -t nat
[root@insta]# /usr/sbin/iptables -P FORWARD ACCEPT
[root@insta]# systemctl daemon-reload && systemctl enable docker && systemctl restart docker

• 关闭 firewalld(centos7)/ufw(ubuntu16.04)，否则可能会重复创建 iptables 规则；
• 清理旧的 iptables rules 和 chains 规则；
• 开启 docker0 网桥下虚拟网卡的 hairpin 模式;

6、添加软连接

[root@insta]# ln -s /opt/docker/bin/docker /usr/bin/docker

7、检查docker服务状态：docker info

安装mysql、WordPress

[root@instance]# docker pull mysql:5.7
[root@instance]# docker pull wordpress:latest

使用yml启动

1、编写docker-wordpress.yml，部分参数解释，注意创建的数据库用户密码，数据库账户密码前都有空格符。

[root@instance]# vim docker-wordpress.yml
version: '3.3'
services:
  db:
     image: mysql:5.7
     container_name: "wordpress_mysql"
     ports:
       - "3307:3306"
     volumes:
       - PWD/data:/var/lib/mysql
     restart: always
     environment:
       MYSQL_ROOT_PASSWORD: 自定义数据库root密码
       MYSQL_DATABASE: wordpress
       MYSQL_USER: laobai
       MYSQL_PASSWORD: 自定义laobai用户密码
  wordpress:
     depends_on:
       - db
     image: wordpress:latest
     container_name: "wordpress"
     ports:
       - "80:80"       - "443:443"
     restart: always
     environment:
       WORDPRESS_DB_HOST: db:3306
       WORDPRESS_DB_USER: laobai
       WORDPRESS_DB_PASSWORD: 与上面相通的laobai用户密码
       WORDPRESS_DB_NAME: wordpress
       WORDPRESS_WPLANG: zh-CN
     volumes:
       -PWD/wp-content:/var/www/html/wp-content
       - $PWD/ssl:/ssl

• ports：映射端口
• volumes：映射容器目录
• restart: always 自动重启
• – $PWD/ssl:/ssl 方便再容器外添加ssl证书

2、启动yml

[root@instance]# docker-compose -f docker-wordpress.yml up -d   #后台启动

访问IP+80即可访问到博客，请注意服务器是否开放80/443端口。

二、添加https协议

1、进入wordpress容器，加载apache的ssl模块，修改证书和私钥路径。因为我已经按照过ssl模块，这里显示已存在。

[root@instance]# docker exec -it wordpress bash
root@cd5205193f22:/var/www/html# a2enmod ssl

编辑容器中的ssl文件

root@cd5205193f22:/var/www/html# vim /etc/apache2/sites-available/default-ssl.conf

找到SSLCertificateFile和SSLCertificateKeyFile这两个配置项，改成把私钥和证书（ssl证书我是在腾讯云申请的一年免费域名证书）挂载进容器里面后的路径，这里都在/ssl/目录下。修改后为：
(这是以前的域名)

在容器中或许不能使用vi/vim，可以将文件从容器中拷贝出来改，再拷贝进去（docker cp…….）
让ssl配置被apache加载

root@cd5205193f22:/var/www/html# ln -s /etc/apache2/sites-available/default-ssl.conf /etc/apache2/sites-enabled/default-ssl.conf

退出容器，并重启。

[root@instance]# docker restart wordpress

强制http请求转到https
编辑 /etc/apache2/sites-available/000-default.conf，找到 标签中增加下面的配置：

<Directory "/var/www/html"> 
    RewriteEngine   on
    RewriteBase /
    # FORCE HTTPS
    RewriteCond %{HTTPS} !=on
    RewriteRule ^/?(.*) https://%{SERVER_NAME}/$1 [R,L]
</Directory>

退出容器，并重启。

[root@instance]# docker restart wordpress

最后，查看是否已更换成https协议访问。

本篇文章篇幅较长，主要是设计到docker、docker-compose、ssl等安装配置。
更多内容可进入我的博客，文章可转载，需标明原博地址。

Docker小知识持续更新

docker inspect container_name/id | grep Mounts -A 20 #查看docker容器挂载目录
docker inspect NAMES # 查看容器所有状态信息；
docker inspect --format='{{.NetworkSettings.IPAddress}}' ID/NAMES # 查看 容器ip 地址
docker inspect --format '{{.Name}} {{.State.Running}}' NAMES # 容器运行状态
docker top NAMES #查看进程

Docker安装WordPress并添加https访问最先出现在Liao's blog。