Metersphere本地环境部署---非微服务版本+图片定制化

Metersphere本地环境部署—非微服务版本+图片定制化

JDK

下面是我的jdk版本

nodejs版本

安装node-v16.12.0，不要安装太高的，我尝试了三个版本，这个版本亲测可用
下载地址
选择对应的版本后，下载msi格式即可

然后安装，如果你之前安装过其他的版本，那需要先卸载再安装，重启一下电脑

下载

为什么单独拿出来说，因为自从V2.3.0版本之后，就成了微服务模式了，但是我又不会，所以选择了下载老版本的V2.2.1
这是他的git地址
git
下载命令

git clone -b v2.2.1 https://github.com/metersphere/metersphere.git

maven配置文件

可以参考我这个

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

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!--
 | This is the configuration file for Maven. It can be specified at two levels:
 |
 |  1. User Level. This settings.xml file provides configuration for a single user,
 |                 and is normally provided in ${user.home}/.m2/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -s /path/to/user/settings.xml
 |
 |  2. Global Level. This settings.xml file provides configuration for all Maven
 |                 users on a machine (assuming they're all using the same Maven
 |                 installation). It's normally provided in
 |                 ${maven.conf}/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -gs /path/to/global/settings.xml
 |
 | The sections in this sample file are intended to give you a running start at
 | getting the most out of your Maven installation. Where appropriate, the default
 | values (values used when the setting is not specified) are provided.
 |
 |-->
<settings xmlns="http://maven.apache.org/SETTINGS/1.2.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.2.0 https://maven.apache.org/xsd/settings-1.2.0.xsd">
  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
  <localRepository>C:\\Program Files\\maven_repository</localRepository>

  <!-- interactiveMode
   | This will determine whether maven prompts you when it needs input. If set to false,
   | maven will use a sensible default value, perhaps based on some other setting, for
   | the parameter in question.
   |
   | Default: true
  <interactiveMode>true</interactiveMode>
  -->

  <!-- offline
   | Determines whether maven should attempt to connect to the network when executing a build.
   | This will have an effect on artifact downloads, artifact deployment, and others.
   |
   | Default: false
  <offline>false</offline>
  -->

  <!-- pluginGroups
   | This is a list of additional group identifiers that will be searched when resolving plugins by their prefix, i.e.
   | when invoking a command line like "mvn prefix:goal". Maven will automatically add the group identifiers
   | "org.apache.maven.plugins" and "org.codehaus.mojo" if these are not already contained in the list.
   |-->
  <pluginGroups>
    <!-- pluginGroup
     | Specifies a further group identifier to use for plugin lookup.
    <pluginGroup>com.your.plugins</pluginGroup>
    -->
  </pluginGroups>

  <!-- proxies
   | This is a list of proxies which can be used on this machine to connect to the network.
   | Unless otherwise specified (by system property or command-line switch), the first proxy
   | specification in this list marked as active will be used.
   |-->
  <proxies>
    <!-- proxy
     | Specification for one proxy, to be used in connecting to the network.
     |
    <proxy>
      <id>optional</id>
      <active>true</active>
      <protocol>http</protocol>
      <username>proxyuser</username>
      <password>proxypass</password>
      <host>proxy.host.net</host>
      <port>80</port>
      <nonProxyHosts>local.net|some.host.com</nonProxyHosts>
    </proxy>
    -->
  </proxies>

  <!-- servers
   | This is a list of authentication profiles, keyed by the server-id used within the system.
   | Authentication profiles can be used whenever maven must make a connection to a remote server.
   |-->
  <servers>
    <!-- server
     | Specifies the authentication information to use when connecting to a particular server, identified by
     | a unique name within the system (referred to by the 'id' attribute below).
     |
     | NOTE: You should either specify username/password OR privateKey/passphrase, since these pairings are
     |       used together.
     |
    <server>
      <id>deploymentRepo</id>
      <username>repouser</username>
      <password>repopwd</password>
    </server>
    -->

    <!-- Another sample, using keys to authenticate.
    <server>
      <id>siteServer</id>
      <privateKey>/path/to/private/key</privateKey>
      <passphrase>optional; leave empty if not used.</passphrase>
    </server>
    -->
  </servers>

  <!-- mirrors
   | This is a list of mirrors to be used in downloading artifacts from remote repositories.
   |
   | It works like this: a POM may declare a repository to use in resolving certain artifacts.
   | However, this repository may have problems with heavy traffic at times, so people have mirrored
   | it to several places.
   |
   | That repository definition will have a unique id, so we can create a mirror reference for that
   | repository, to be used as an alternate download site. The mirror site will be the preferred
   | server for that repository.
   |-->
  <mirrors>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
     -->
    <mirror>
      <id>nexus-aliyun</id>
      <mirrorOf>central</mirrorOf>
      <name>Nexus aliyun</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    </mirror>
       <!-- 阿里云仓库 -->
    <mirror>
        <id>alimaven</id>
        <mirrorOf>central</mirrorOf>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
    </mirror>
    <!-- 中央仓库1 -->
    <mirror>
        <id>repo1</id>
        <mirrorOf>central</mirrorOf>
        <name>Human Readable Name for this Mirror.</name>
        <url>http://repo1.maven.org/maven2/</url>
    </mirror>

    <!-- 中央仓库2 -->
    <mirror>
        <id>repo2</id>
        <mirrorOf>central</mirrorOf>
        <name>Human Readable Name for this Mirror.</name>
        <url>http://repo2.maven.org/maven2/</url>
    </mirror>
  </mirrors>


  <!-- profiles
   | This is a list of profiles which can be activated in a variety of ways, and which can modify
   | the build process. Profiles provided in the settings.xml are intended to provide local machine-
   | specific paths and repository locations which allow the build to work in the local environment.
   |
   | For example, if you have an integration testing plugin - like cactus - that needs to know where
   | your Tomcat instance is installed, you can provide a variable here such that the variable is
   | dereferenced during the build process to configure the cactus plugin.
   |
   | As noted above, profiles can be activated in a variety of ways. One way - the activeProfiles
   | section of this document (settings.xml) - will be discussed later. Another way essentially
   | relies on the detection of a system property, either matching a particular value for the property,
   | or merely testing its existence. Profiles can also be activated by JDK version prefix, where a
   | value of '1.4' might activate a profile when the build is executed on a JDK version of '1.4.2_07'.
   | Finally, the list of active profiles can be specified directly from the command line.
   |
   | NOTE: For profiles defined in the settings.xml, you are restricted to specifying only artifact
   |       repositories, plugin repositories, and free-form properties to be used as configuration
   |       variables for plugins in the POM.
   |
   |-->
  <profiles>
    <!-- profile
     | Specifies a set of introductions to the build process, to be activated using one or more of the
     | mechanisms described above. For inheritance purposes, and to activate profiles via <activatedProfiles/>
     | or the command line, profiles have to have an ID that is unique.
     |
     | An encouraged best practice for profile identification is to use a consistent naming convention
     | for profiles, such as 'env-dev', 'env-test', 'env-production', 'user-jdcasey', 'user-brett', etc.
     | This will make it more intuitive to understand what the set of introduced profiles is attempting
     | to accomplish, particularly when you only have a list of profile id's for debug.
     |
     | This profile example uses the JDK version to trigger activation, and provides a JDK-specific repo.
    <profile>
      <id>jdk-1.4</id>

      <activation>
        <jdk>1.4</jdk>
      </activation>

      <repositories>
        <repository>
          <id>jdk14</id>
          <name>Repository for JDK 1.4 builds</name>
          <url>http://www.myhost.com/maven/jdk14</url>
          <layout>default</layout>
          <snapshotPolicy>always</snapshotPolicy>
        </repository>
      </repositories>
    </profile>
    -->

    <!--
     | Here is another profile, activated by the system property 'target-env' with a value of 'dev',
     | which provides a specific path to the Tomcat instance. To use this, your plugin configuration
     | might hypothetically look like:
     |
     | ...
     | <plugin>
     |   <groupId>org.myco.myplugins</groupId>
     |   <artifactId>myplugin</artifactId>
     |
     |   <configuration>
     |     <tomcatLocation>${tomcatPath}</tomcatLocation>
     |   </configuration>
     | </plugin>
     | ...
     |
     | NOTE: If you just wanted to inject this configuration whenever someone set 'target-env' to
     |       anything, you could just leave off the <value/> inside the activation-property.
     |
    <profile>
      <id>env-dev</id>

      <activation>
        <property>
          <name>target-env</name>
          <value>dev</value>
        </property>
      </activation>

      <properties>
        <tomcatPath>/path/to/tomcat/instance</tomcatPath>
      </properties>
    </profile>
    -->
  </profiles>

  <!-- activeProfiles
   | List of profiles that are active for all builds.
   |
  <activeProfiles>
    <activeProfile>alwaysActiveProfile</activeProfile>
    <activeProfile>anotherAlwaysActiveProfile</activeProfile>
  </activeProfiles>
  -->
</settings>

环境配置准备工作

安装mysql、redis、kafka、zookeeper在linux的安装，可以看我其他的博客

mysql

安装的话看我的另一篇博客
linux安装mysql
配置的修改，我们根据官方的手册来修改
官方手册

[root@MeterSphere ~]$vi /etc/my.cnf

将如下内容复制到文件中保存，default-storage-engine=INNODB 这个配置由于我的mysql本来就是这样的，所以就没复制

lower_case_table_names=1
table_open_cache=128
max_connections=2000
max_connect_errors=6000
innodb_file_per_table=1
innodb_buffer_pool_size=1G
max_allowed_packet=64M
transaction_isolation=READ-COMMITTED
innodb_flush_method=O_DIRECT
innodb_lock_wait_timeout=1800
innodb_flush_log_at_trx_commit=0
sync_binlog=0

server-id=1
log-bin=mysql-bin
expire_logs_days = 2
binlog_format=mixed

sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
skip-name-resolve

然后重启mysql服务

systemctl restart mysqld

然后我们连接上这个mysql，我在本地用的是DataGrip,执行sql

CREATE DATABASE `metersphere_dev` /*!40100 DEFAULT CHARACTER SET utf8mb4 */

jmeter-core下载打包

然后下载jmeter-core，需要先去github上下载对应版本的，比如说我的metersphere版本是v2.2.1，那jmeter-core也下载相同版本的

git clone -b v2.2.1 https://github.com/metersphere/ms-jmeter-core.git

下载好之后

mvn clean install

core的org.apache.maven.plugins爆红不用管，也可以打包成功

生成了对应的jar包

如果你不先打包jmeter-core，就会报下面这些错误

[ERROR] Failed to execute goal on project sdk: Could not resolve dependencies for project io.metersphere:sdk:jar:main: io.metersphere:ms-jmeter-core:jar:main was not found in https://maven.aliyun.com/repository/public during a previ
ous attempt. This failure was cached in the local repository and resolution is not reattempted until the update interval of aliyunmaven has elapsed or updates are forced -> [Help 1]

[ERROR] Failed to execute goal on project sdk: Could not resolve dependencies for project io.metersphere:sdk:jar:main: Could not find artifact io.metersphere:ms-jmeter-core:jar:main in nexus-aliyun (http://maven.aliyun.com/nexus/con
tent/groups/public) -> [Help 1]

前端准备工作

其实前端准备工作完全可以只做一项，那就是直接将build和build-win这两个指令的内容互换。因为直接在metersphere的主路径下面就可以用mvn clean install命令，为前端代码及后端代码下载依赖并打包。

先进入前端代码目录，然后下载对应的前端依赖，最后打包

D:\metersphere> cd .\frontend\
D:\metersphere\frontend> npm install
PS D:\metersphere\frontend> npm run build-win

打包的命令，取决于你电脑的系统
如果你的是windows的，那就用：npm run build-win
如果你的是mac或者linux的，那就用： npm run build
我的推荐是如果你用windows的话，直接将build和build-win这两个指令的内容互换。
原因是export命令在windows上是没有的，但是可以用set命令来代替

配置文件目录

jmeter.home

比如说我的metersphere下载到了D盘，那直接在D盘新建这个目录即可

把整个目录复制到/opt/jmeter下

metersphere.properties

和jmeter的配置文件一样，我们需要新建对应目录，然后新建一个metersphere.properties文件，内容为
官方文档


并将内容修改为你自己项目的配置

自动建表

由于我的表是由于之前搭建过spring-cloud版本的，没有完全搭建成功，但是表建立成功了，所以这里抄了一部分其他人的

flyway enable(第一次可以用true用来自动建表，之后最好手工升级，要不然每次启动要跑很久)
spring.flyway.enabled=false

但是吧，我这里一直是true没改过，也没问题

尝试启动后端项目

首先通过mvn clean install打包后端项目

会构建失败，是因为使用了xpack，收费的，咱们没有
把爆红的行数全部注释掉即可
再次mvn claen install
然后就打包成功了，但是我们看右边，ms-jmeter-core还是没有

主要集中有下面几个问题
我们先不管，直接启动项目

可我们明明已经有了，为什么没有发现呢，这个和每个人环境的设置有关系，比如我的maven就弄了自己的目录，没有按照默认的来，所以需要修改一下项目对应的maven环境

再次mvn clean install

再次启动项目
还是报错

org.apache.ibatis.builder.BuilderException: Error parsing Mapper XML. The XML location is 'io/metersphere/base/mapper/UiScenarioReferenceMapper.xml'. Cause: org.apache.ibatis.builder.BuilderException: Error resolving class. Cause: org.apache.ibatis.type.TypeException: Could not resolve type alias 'io.metersphere.xpack.ui.dto.RefReq'.  Cause: java.lang.ClassNotFoundException: Cannot find class: io.metersphere.xpack.ui.dto.RefReq

发现这个报错的文件不就是在上面咱们npm clean install报错的时候注释掉的mapper对应的xml文件么
再把这个文件中对应报错的代码注释掉

再启动一下
成功了
至于下面这个报错，不重要，反正可用

下载整体依赖及打包

项目根目录下执行打包命令，就会自动下载前端及后端的依赖，并给后端打包成jar包，前端打包出dist文件夹

启动

前端的话，进入前端目录

启动后发现，前端的请求到了https上，说明我们的后端出问题了

我们先看前端的配置
port是我自己改的，这个没啥关系，只是vue的端口，重要的是target，应该是http而不是https

同时呢，在后端也有一个类，就是下面这个类，将http转换成了https

直接删除即可

后端的话，可以直接找target里的jar包，或者直接就idea启动都没关系

进入前端页面后，发现很多图片都是缺失的，那就在前端目录里重新打包一下

npm run build

就可以解决了

kafka

其实我的kafka一直没有连接成功，在报错，但是并没有影响我的接口测试，具体原因，等之后再研究

部署在服务器上

你可以将在本地修改好的代码上传到服务器上，但是要记得修改几个点
1、我是先在服务器上用git重新下载了jmeter-core的代码然后重新打包的，然后再将已修改的代码上传到服务器上
2、前端打包的命令记得改回来，因为你要在linux上启动嘛
3、修改/opt/metersphere/conf/metersphere.properties，比如我原来在window上，连接的jmeter、kafka、mysql，都是在这台服务器上，那我在windows的配置文件里对应的ip，就是这台服务器，那我现在这些服务和我的代码都在这台服务器了，那就不能用ip了，直接将ip修改为localhost即可
4、和windows一样新建对应的目录并添加对应的文件
5、在项目的根目录执行打包命令 mvn clean install，应该是会报错的，前端会有很多东西下载不下来，原因是npm下载的地址需要配置一下镜像
这是我的镜像，供大家参考

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">


  <parent>
    <artifactId>metersphere-server</artifactId>
    <groupId>io.metersphere</groupId>
    <version>${revision}</version>
  </parent>

  <packaging>pom</packaging>

  <modelVersion>4.0.0</modelVersion>
  <artifactId>frontend</artifactId>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <frontend-maven-plugin.version>1.9.1</frontend-maven-plugin.version>
  </properties>

  <build>
    <plugins>
      <plugin>
        <groupId>com.github.eirslett</groupId>
        <artifactId>frontend-maven-plugin</artifactId>
        <version>${frontend-maven-plugin.version}</version>
        <executions>
          <execution>
            <!-- optional: you don't really need execution ids, but it looks nice in your build log. -->
            <id>install node and npm</id>
            <goals>
              <goal>install-node-and-npm</goal>
            </goals>
            <!-- optional: default phase is "generate-resources" -->
            <phase>generate-resources</phase>
            <configuration>
              <nodeVersion>v16.10.0</nodeVersion>
              <npmVersion>6.14.15</npmVersion>
                    <!--配置公网的镜像地址-->
                    <nodeDownloadRoot>http://npm.taobao.org/mirrors/node/</nodeDownloadRoot>
                    <npmDownloadRoot>http://npm.taobao.org/mirrors/npm/</npmDownloadRoot>
                    <!--配置公网的npm仓库地址-->
                    <npmRegistryURL>http://npm.thunisoft.com</npmRegistryURL>
            </configuration>
          </execution>
          <!-- Install all project dependencies -->
          <execution>
            <id>npm install</id>
            <goals>
              <goal>npm</goal>
            </goals>
            <configuration>
              <!-- optional: The default argument is actually
              "install", so unless you need to run some other yarn command,
              you can remove this whole <configuration> section.
              -->
              <arguments>install</arguments>
            </configuration>
          </execution>
          <!-- Build and minify static files -->
          <execution>
            <id>npm run build</id>
            <goals>
              <goal>npm</goal>
            </goals>
            <configuration>
              <arguments>run build</arguments>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <artifactId>maven-clean-plugin</artifactId>
        <configuration>
          <filesets>
            <fileset>
              <directory>dist</directory>
              <includes>
                <include>**</include>
              </includes>
              <followSymlinks>false</followSymlinks>
            </fileset>
          </filesets>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

那后端服务启动很好说,以我的项目为例

[root@MeterSphere /usr/local/metersphere/backend/target]$ls
antrun  backend-2.2.jar  backend-2.2.jar.original  classes  generated-sources  maven-archiver  maven-status  nohup.out  test-classes
[root@MeterSphere /usr/local/metersphere/backend/target]$nohp java -jar backend-2.2.jar &

这样就可以后台启动了

那前端项目怎么办，总不能npm run serve运行吧。然后我就去扒代码，看他们的到底是怎么做到https访问的，去了解证书、秘钥、nginx部署，很繁琐，后来我就想，我只会http的方式，那我就把这个项目的水平拉到和我一样认知的水平不就可以了，于是，我这样做了
首先，修改后端

然后删除了HTTPSConfig.java
然后修改前端配置

然后重新打包，将生成的dist文件里的内容全部导入到nginx的html文件夹下
再设置nginx，重启nginx
我的配置文件如下，其中比较重要的是对websocket的支持，如果没有这个的话，在接口测试的时候就会报错，别问我怎么知道的，这个配置文件也是误打误撞成功的，因为websocket默认是443端口的，我把它配置到了80端口下，http的还是，竟然也成功了。暂时就这样吧。

#user  nobody;
worker_processes  1;

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

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


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

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

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    server {
        listen       80;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
            proxy_pass http://localhost:8443/;
            # 配置 websocket 支持
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";
        }

        #error_page  404              /404.html;

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

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

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

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


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

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


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

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

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

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

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

}

图片定制化