docker run -d \
--name=prometheus \
-p 9090:9090 \
-v /home/prometheus/config/prometheus.yml:/etc/prometheus/prometheus.yml \
-v /home/prometheus/prometheus:/prometheus \
{harborPath}/prom/prometheus:v3.3.0

prometheus.yml 配置文件

# my global config
global:
  scrape_interval: 15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).

# Alertmanager configuration
alerting:
  alertmanagers:
    - static_configs:
        - targets:
          # - alertmanager:9093

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: "prometheus"

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.

    static_configs:
      - targets: ["{prometheus.path}"]
       # The label name is added as a label `label_name=<label_value>` to any timeseries scraped from this config.
        labels:
          app: "prometheus"

  - job_name: 'Aserver'
    static_configs:
      - targets: [ '{Aserver.path}' ]
        labels:
          app: "Aserver"
  - job_name: 'Bserver'
    static_configs:
      - targets: [ '{Bserver.path}' ]
        labels:
          app: "Bserver"

  - job_name: '200mysql'
    static_configs:
      - targets: ['{mysql.path}']
        labels:
          instance: "200mysql"
          app: "200mysql"

grafana docker部署

docker run -d \
--name=grafana \
-p 3000:3000 \
-v /home/grafana/grafana:/var/lib/grafana \
-e "GF_SECURITY_ADMIN_PASSWORD={password}" \
{harborPath}/grafana/grafana:11.6.0

服务器监控收集器 docker部署

docker run -d \
--name 200-exporter \
--restart=always \
-p 9100:9100 \
-v /proc:/host/proc:ro \
-v /sys:/host/sys:ro \
-v /:/rootfs:ro \
{harborPath}/prom/node-exporter:241003

mysql监控收集器 docker部署

docker run -d \
-p 9104:9104 \
--name=mysqld-exporter \
-v /home/prometheus/mysql/.my.cnf:/.my.cnf \
{harborPath}/prom/mysqld-exporter:v0.17.2

.my.cnf 配置文件

[client]
user={mysql.user}
password={mysql.password}
host={mysql.host}
port={mysql.port}

dockerFile

FROM {harbor}/test/openjdk:8-jre
LABEL authors="lhyshome_pc"
ENV TZ=Asia/Shanghai
ADD ./proxy-client /proxy-client
ADD ./ep.sh /ep.sh
RUN apt-get update && apt-get install -y procps
RUN apt-get update && apt-get install -y dos2unix
RUN dos2unix /ep.sh && chmod +x /ep.sh
ENTRYPOINT ["/ep.sh"]

ep.sh

#!/bin/bash

echo "entrypoint.sh start"
# 定义目标配置文件路径
CONFIG_FILE=proxy-client/conf/config.properties

# 替换占位符为环境变量的值
sed -e "s|{{CLIENT_KEY}}|${CLIENT_KEY:-CLIENT_KEY}|g" \
    -e "s|{{SERVER_HOST}}|${SERVER_HOST:-127.0.0.1}|g" \
    -e "s|{{SERVER_PORT}}|${SERVER_PORT:-80}|g" \
    proxy-client/conf/config.template > $CONFIG_FILE

echo "Generated config file:"
cat $CONFIG_FILE

# 启动主程序（根据需要替换为实际启动命令）
exec "proxy-client/bin/startup.sh"

config.template

client.key={{CLIENT_KEY}}
server.host={{SERVER_HOST}}
server.port={{SERVER_PORT}}

docker构建及上传

进入proxy-client的上级目录

docker build -t {harbor}/test/proxy-client:v1.0.0 ./
docker push {harbor}/test/proxy-client:v1.0.0
docker image rm {harbor}/test/proxy-client:v1.0.0

docker部署命令

docker run -e CLIENT_KEY=xxxxx -e SERVER_HOST=xxx.xxx.xxx.xxx -e SERVER_PORT=xxxx –name proxy-client –privileged=true –restart=always -d {harbor}/test/proxy-client:v1.0.0

配置环境变量

在命令行工具中使用代理，需要在环境变量中明确指定。

配置步骤：

编辑环境变量文件

打开当前用户的 ~/.bashrc 文件：

nano ~/.bashrc

添加代理环境变量

根据代理类型（HTTP/HTTPS/FTP），添加以下内容：

export http_proxy=http://proxy.example.com:8080 
export https_proxy=http://proxy.example.com:8080 
export ftp_proxy=http://proxy.example.com:8080 
export no_proxy=localhost,127.0.0.1,::1 

如果代理需要认证，则添加用户名和密码：

export http_proxy=http://username:password@proxy.example.com:8080 export https_proxy=http://username:password@proxy.example.com:8080

刷新环境变量

保存文件后，运行以下命令使配置生效：

source ~/.bashrc

验证配置

查看环境变量是否已生效：

echo $http_proxy

Docker 客户端配置代理

前提

Error response from daemon: Get “https://registry-1.docker.io/v2/”: context deadline exceeded (Client.Timeout exceeded while awaiting headers)

因为没有代理，所以docker客户端无法访问dockerhub的默认仓库 https://registry-1.docker.io/v2/ 地址

配置代理

如果您的网络需要通过代理访问外网，您需要在 Docker 中配置代理。

配置步骤：

创建 Docker 配置目录（如果不存在）：

mkdir -p /etc/systemd/system/docker.service.d

创建或编辑 http-proxy.conf 文件：

nano /etc/systemd/system/docker.service.d/http-proxy.conf

添加以下内容：

# 根据实际代理信息替换 http://proxy.example.com:8080 
Environment="HTTP_PROXY=http://proxy.example.com:8080" Environment="HTTPS_PROXY=http://proxy.example.com:8080" Environment="NO_PROXY=localhost,127.0.0.1"

重载并重启 Docker 服务：

systemctl daemon-reload
systemctl restart docker

验证代理配置是否生效：

docker info | grep -i proxy

github下载地址：
https://github.com/kekingcn/kkFileView

下载源码的zip包

安装

将下载的源码打开后，将源码docker路径下的文件夹上传至服务器

在服务器执行docker build ../../Dockerfile 构建kkFileView的运行的基板

对源码 maven package后将server/target下的 kkFileView-4.4.0-beta.tar.gz 文件和根目录的Dockerfile（注意这里的Dockerfile和之前步骤的Dockerfile不是同一个，作用也不一样）上传至服务器

修改Dockerfile中的 ADD ./kkFileView-4.4.0-beta.tar.gz /opt/ 这一行 将kkFileView-4.4.0-beta.tar.gz的路径改为服务器上对应的 绝对路径或者相对路径，对当前DockerFile执行docker build ，构建完成后将会出现kkFileView的执行docker镜像

用docker run启动当前镜像 暴露8012端口到宿主机

在服务器防火墙上对8012端口放行

验证

http://服务器ip:8012

出现这个页面则为部署成功

http://服务器ip:8012/onlinePreview?url=aHR0cDovLzE5Mi4xNjguMC4yMDA6NTI0NC9wL0Rvd25sb2Fkcy8lRTYlOTYlQjAlRTUlQkIlQkElRTYlOTYlODclRTYlQTElQTMuZG9jeD9zaWduPW53RHB2MVhoS2NXQ3pPODVfa2tPbE85MFo1NGp2YnNXdXA0VlRacnlmaUU9OjA%3D

注意http://服务器ip:8012/onlinePreview?url= 后拼接的地址为文件下载地址，且必须经过base64编码后的请求地址

官方操作文档

https://kkfileview.keking.cn

docker run -d --restart=unless-stopped -v /home/alist:/opt/alist/data -p 5244:5244 -e PUID=0 -e PGID=0 -e UMASK=022 --name="alist" xhofe/alist:v3.36.0

执行后docker容器的log中会展示出admin账号的密码

页面登陆127.0.0.1:5244

看到该页面即部署成功

nginx配置（可选）

如果需要使用域名访问，nginx反向代理如下

upstream alist {
    server 127.0.0.1:5244 ;
}

server {
    listen 80;
    server_name alist.example.com;
    location / {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header Range $http_range;
        proxy_set_header If-Range $http_if_range;
        proxy_redirect off;
        # the max size of file to upload
        client_max_body_size 20000m;
        proxy_pass http://alist;
    }
}

AList官方文档

https://alist.nn.ci/zh

AList github地址

https://github.com/alist-org/alist/tree/main

安装／升级Docker客户端

推荐安装1.10.0以上版本的Docker客户端，参考文档docker-ce

配置镜像加速器

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

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

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

sudo systemctl daemon-reload
sudo systemctl restart docker

docker network create es-net

部署es

docker run -d \
--restart=always \
--name es \
--network es-net \
-p 9200:9200 \
-p 9300:9300 \
--privileged=true \
-e "discovery.type=single-node" \
-e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
elasticsearch:7.17.18

进入es容器，安装分词器

./bin/elasticsearch-plugin install https://github.com/infinilabs/analysis-ik/releases/download/v7.17.18/elasticsearch-analysis-ik-7.17.18.zip

部署kibana

docker run -d \
--restart=always \
--name kibana \
--network es-net \
-p 5601:5601 \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
kibana:7.17.18

存在的docker容器

执行脚本

# 将容器打包为镜像
docker commit clash clash:1 
# 将当前docker本地镜像（或已下载的镜像）打上tag（已下载的公共镜像从此步骤开始，打tag和上传）
docker tag clash:1 harbor_ip:harbor_port/test/clash:1
# 上传至私有镜像仓库中
docker push harbor_ip:harbor_port/test/clash:1
# 删除本地镜像
docker image rm harbor_ip:harbor_port/test/clash:1

从harbor拉取制作镜像，并运行

docker pull harbor_ip:harbor_port/test/clash:1

docker run -d --name=clash -v "/home/clash:/root/.config/clash/" -p "7890:7890" -p "7891:7891" -p "9090:9090" --restart=unless-stopped harbor_ip:harbor_port/test/clash:1

2.从dockerhub上拉取镜像推送到harbor

docker pull nacos/nacos-server:v2.4.3
docker tag nacos/nacos-server:v2.4.3 harbor_ip:harbor_port/test/nacos/nacos-server:v2.4.3
docker push harbor_ip:harbor_port/test/nacos/nacos-server:v2.4.3
docker image rm harbor_ip:harbor_port/test/nacos/nacos-server:v2.4.3

Jenkins+harbor+nexus+docker+k8s

Jenkins执行流水线脚本命令

harbor维护管理docker镜像

nexus维护私有maven依赖

docker创建服务各个版本的docker镜像

k8s部署服务镜像

后端：

Jenkins流水线脚本

pipeline {
    agent none
    environment {
        FLAG = 'ruoyigatewaydev'
    }
    options {
        timeout(time:25, unit: 'MINUTES')
    }
    stages {
        stage('Build Package') {
            agent {
                docker {
                    image 'maven:3.6.1-jdk-8'
                    args '-v /var/lib/jenkins/repository:/repository '
                }
            }
            steps {
                git branch: 'dev',
                        credentialsId: 'gitlab_local_pwd',
                        url: 'http://git_ip:git_port/lhy/ruoyi-gateway.git'
                sh '''
                mvn -s settings.xml -Dmaven.repo.local=/repository -B clean package -DskipTests=true
                '''
            }
        }
        stage('Build image and Push') {
            agent any
            environment {
                IMAGE_TAG = sh(returnStdout: true,script: 'echo $image_tag').trim()
            }
            steps {
                sh """	
					docker build -t harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG} ./
					docker push harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG}
					docker image rm harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG}
                   """
            }
        }

        stage('Deploy') {
            agent any
            steps {
                script{
                    def remote = [:]
                    remote.name = 'kube'
                    remote.host = 'k8s_ip'
                    remote.port = 22
                    remote.allowAnyHosts = true
                    //通过withCredentials调用Jenkins凭据中已保存的凭据，credentialsId需要填写，其他保持默认即可
                    withCredentials([usernamePassword(credentialsId: 'Vm_local_pwd', passwordVariable: 'password', usernameVariable: 'userName')]) {
                        remote.user = "${userName}"
                        remote.password = "${password}"
                    }
                    sshCommand remote: remote, command: """ 
                        if [ ! -d '/home/ruoyi/${FLAG}' ];then 
                        mkdir /home/ruoyi/${FLAG}
                        else
                        echo "文件夹已经存在"
                        fi
    				   """
                    sshPut remote: remote, from: 'k8s.yaml', into: "/home/ruoyi/${FLAG}"
                    sshCommand remote: remote, command: """ 
    					sed -i 's#${FLAG}:.*#${FLAG}:${IMAGE_TAG}#g' /home/ruoyi/${FLAG}/k8s.yaml
    					kubectl apply -f /home/ruoyi/${FLAG}/k8s.yaml
    					rm -rf /home/ruoyi/${FLAG}/k8s.yaml
    				   """
                }
            }
        }
    }
}

k8s.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ruoyigateway
  namespace: ruoyi-dev
  labels:
    app: ruoyigateway
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ruoyigateway
  template:
    metadata:
      name: ruoyigateway
      labels:
        app: ruoyigateway
    spec:
      containers:
        - name: ruoyigateway
          image: harbor_ip:harbor_port/public/ruoyigatewaydev:7.0
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: containerPort
              protocol: TCP
      restartPolicy: Always
      imagePullSecrets:
        - name: harbor-lhy

---
apiVersion: v1
kind: Service
metadata:
  name: ruoyigateway
  namespace: ruoyi-dev
spec:
  selector:
    app: ruoyigateway
  ports:
    - protocol: TCP
      port: port
      targetPort: targetPort
      nodePort: nodePort
  type: NodePort

DockerFile

FROM openjdk:8-jre
LABEL authors="lhyshome_pc"
ADD target/ruoyi-gateway.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

前端

Jenkins流水线脚本

pipeline {
    agent none
    environment {
        FLAG = 'ruoyiuidev'
    }
    options {
        timeout(time:25, unit: 'MINUTES')
    }
    stages {
        stage('npm') {
            agent {
                docker {
                    image 'node:14'
                    args '-u root:root --network=host'
                }
            }
            steps {
                git branch: 'dev',
                credentialsId: 'gitlab_local_pwd',
                url: 'http://git_ip:git_port/lhy/ruoyi-ui.git'
                sh """
                    npm install && npm run build:stage
                """
            }
        }
        stage('Build image and Push') {
            agent any
            environment {
                IMAGE_TAG = sh(returnStdout: true,script: 'echo $image_tag').trim()
            }
            steps {
                sh """	
					docker build -t harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG} ./
					docker push harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG}
					docker image rm harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG}
                   """
            }
        }
        stage('Deploy') {
            agent any
            steps {
                script{
                    def remote = [:]
                    remote.name = 'kube'
                    remote.host = 'k8s_ip'
                    remote.port = 22
                    remote.allowAnyHosts = true
                    //通过withCredentials调用Jenkins凭据中已保存的凭据，credentialsId需要填写，其他保持默认即可
                    withCredentials([usernamePassword(credentialsId: 'Vm_local_pwd', passwordVariable: 'password', usernameVariable: 'userName')]) {
                        remote.user = "${userName}"
                        remote.password = "${password}"
                    }
                    sshCommand remote: remote, command: """ 
                        if [ ! -d '/home/ruoyi/${FLAG}' ];then 
                        mkdir /home/ruoyi/${FLAG}
                        else
                        echo "文件夹已经存在"
                        fi
    				   """
                    sshPut remote: remote, from: 'k8s.yaml', into: "/home/ruoyi/${FLAG}"
                    sshCommand remote: remote, command: """ 
    					sed -i 's#${FLAG}:.*#${FLAG}:${IMAGE_TAG}#g' /home/ruoyi/${FLAG}/k8s.yaml
    					kubectl apply -f /home/ruoyi/${FLAG}/k8s.yaml
    					rm -rf /home/ruoyi/${FLAG}/k8s.yaml
    				   """
                }
            }
        }
    }
}

k8s.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ruoyiui
  namespace: ruoyi-dev
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ruoyiui
  template:
    metadata:
      labels:
        app: ruoyiui
    spec:
      containers:
        - name: ruoyiui
          image: harbor_ip:harbor_port/public/ruoyiuiprod:9.0
          ports:
            - containerPort: containerPort
---
apiVersion: v1
kind: Service
metadata:
  name: ruoyiui
  namespace: ruoyi-dev
spec:
  type: LoadBalancer
  selector:
    app: ruoyiui
  ports:
    - protocol: TCP
      port: port
      targetPort: targetPort
      nodePort: nodePort

DockerFile

FROM nginx:1.14.1
ADD ./dist /home
ADD ./nginx.conf /etc/nginx
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

nginx.conf

worker_processes  1;

events {
    worker_connections  1024;
}

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

    server {
        listen       80;
        server_name  localhost;

        location / {
            root   /home;
            try_files $uri $uri/ /index.html;
            index  index.html index.htm;
        }

        # 避免actuator暴露
        if ($request_uri ~ "/actuator") {
            return 403;
        }

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

创建/home/nexus目录，并给其赋予777权限，完成后执行如下命令，等待启动成功

docker run -d --restart always --name nexus3 -p 8081:8081 -v /home/nexus:/nexus-data sonatype/nexus3

第一次登录用admin账号，密码在/home/nexus/admin.password

安装完成后

创建repository

创建如下图三个

snapshots和releases创建时应设置Version policy为对应类型，Deployment policy为Allow redeploy（设置后可以上传），public设置为mixed

设置public时应将之前创建的snapshots和releases加入到members中去

创建用户及角色

创建角色，并将将创建的repository权限赋予当前角色

创建用户，在roles中勾选刚刚创建的角色

使用

maven的settings.xml配置，控制从私有仓库中的同步拉取jar

<server>
    <!-- id为当前用户id，后续在需要使用此用户时，对应所有id都应该用此id -->
    <id>lhy-maven</id>
    <username>lhy</username>
    <password>password</password>
</server>
...........
                <repository>
                    <id>lhy-maven</id>
                    <url>http://192.168.0.200:8081/repository/lhy-public/</url>
                    <releases>
                        <enabled>true</enabled>
                    </releases>
                    <snapshots>
                        <enabled>true</enabled>
                    </snapshots>
                </repository>

项目中的pom.xml，控制往私有仓库中deploy，不需要deploy的不需要配置

<distributionManagement>
    <repository>
        <!--注意这个id一定要填写我们maven的setting.xml当中配置的id-->
        <id>lhy-maven</id>
        <url>http://ip:port/repository/lhy-releases/</url>
    </repository>
    <snapshotRepository>
        <!--注意这个id一定要填写我们maven的setting.xml当中配置的id-->
        <id>lhy-maven</id>
        <url>http://ip:port/repository/lhy-snapshots/</url>
    </snapshotRepository>
</distributionManagement>