docker部署微信小程序自动构建发布和更新的详细步骤_云虚拟主机

通过 jenkins 和 docker 部署微信小程序，并实现自动构建、发布和版本更新，主要涉及以下几个步骤：

设置 jenkins 环境
配置 gitlab 与 jenkins 的集成
构建 docker 镜像
部署和发布微信小程序
配置 jenkins 自动构建

以下是详细的步骤说明：

1. 设置 jenkins 环境

首先，确保你已经安装和配置了 jenkins 服务器。假设你已经安装了 jenkins，并且 jenkins 能够正常运行。

安装 jenkins 所需插件：

docker plugin：用于在 jenkins 中执行 docker 操作。
gitlab plugin：用于集成 gitlab 仓库与 jenkins。
pipeline plugin：用于通过流水线（pipeline）来定义构建过程。

在 jenkins 上安装插件的方法：

进入 jenkins dashboard，点击 manage jenkins。
选择 manage plugins。
在 available 标签页中，搜索并安装以下插件：
- gitlab plugin
- docker pipeline plugin
- pipeline plugin

2. 配置 gitlab 与 jenkins 集成

确保你在 jenkins 上配置了与 gitlab 的集成，以便 jenkins 可以从 gitlab 获取代码并触发构建。

配置 gitlab webhook

登录到你的 gitlab 仓库。

进入 settings -> webhooks。

添加一个新的 webhook，输入 jenkins 服务器的 url，格式为：

http://<jenkins_url>/project/<jenkins_job_name>

例如：

http://localhost:8080/project/wechat-miniapp-build

选择 push events 和 merge requests，这样每次代码提交到 gitlab 时，jenkins 会自动开始构建。

进入 jenkins，点击 manage jenkins -> configure system。
在 gitlab 配置部分，输入 gitlab 的 api url 和 api token。你需要创建一个 gitlab 访问令牌（token）：
在 gitlab 上，进入 user settings -> access tokens，创建一个新的访问令牌。
保存设置后，你可以通过 gitlab plugin 连接到 gitlab 仓库。

3. 构建 docker 镜像

在 jenkins 中创建一个 pipeline 作业，用来构建 docker 镜像并部署微信小程序。

dockerfile 示例

首先，在你的微信小程序项目根目录下创建一个 dockerfile，用于构建 docker 镜像。

# 使用 node.js 镜像作为基础镜像
from node:16
# 创建并设置工作目录
workdir /app
# 将当前目录下的项目文件复制到 docker 容器中
copy . .
# 安装依赖
run npm install
# 执行构建命令
run npm run build
# 暴露端口
expose 3000
# 启动微信小程序构建服务（例如，使用 nginx 或其他方式）
cmd ["npm", "start"]

jenkins pipeline 脚本

创建一个 jenkins pipeline 来执行代码的拉取、docker 镜像的构建和发布。

pipeline {
    agent any
    environment {
        docker_image = "wechat-miniapp"
        docker_registry = "your-docker-registry"  // docker registry 地址
    }
    stages {
        stage('checkout') {
            steps {
                // 从 gitlab 获取代码
                git 'http://your_gitlab_repo_url.git'
            }
        }
        stage('build docker image') {
            steps {
                script {
                    // 构建 docker 镜像
                    sh 'docker build -t ${docker_registry}/${docker_image}:latest .'
                }
            }
        }
        stage('push docker image') {
            steps {
                script {
                    // 将构建的镜像推送到 docker registry
                    sh 'docker push ${docker_registry}/${docker_image}:latest'
                }
            }
        }
        stage('deploy') {
            steps {
                script {
                    // 在服务器上拉取并运行 docker 镜像
                    sh 'docker pull ${docker_registry}/${docker_image}:latest'
                    sh 'docker run -d -p 3000:3000 ${docker_registry}/${docker_image}:latest'
                }
            }
        }
    }
    post {
        always {
            // 构建结束后执行的操作，比如清理旧的容器
            sh 'docker system prune -f'
        }
    }
}

说明：

checkout：从 gitlab 拉取代码。
build docker image：构建 docker 镜像。
push docker image：将镜像推送到 docker registry（如果你使用的是私有仓库，可以推送到私人 docker 仓库）。
deploy：在目标服务器上拉取并运行 docker 镜像。

4. 部署和发布微信小程序

构建微信小程序的发布版本：
使用 npm run build 命令来构建生产版本，通常会生成一个用于发布的文件夹（例如，dist/ 或 build/）。然后将这些文件部署到你选择的 web 服务器上（例如 nginx、apache 等）。

上传小程序代码：
微信小程序通常需要使用微信开发者工具上传到微信服务器。你可以在构建完成后，利用微信小程序开发者工具的命令行工具进行自动化上传。

微信小程序提供了 cli 工具，叫做 weapp-cli，你可以通过以下方式上传代码：

npm install -g weapp-cli
weapp-cli upload --appid <your_app_id> --project <path_to_your_project>

然后可以将 upload 命令添加到 jenkins pipeline 的最后一个阶段。

stage('upload to wechat') {
    steps {
        script {
            // 上传到微信小程序
            sh 'weapp-cli upload --appid <your_app_id> --project ./dist'
        }
    }
}

5. 配置 jenkins 自动构建

每次有新代码提交到 gitlab 时，jenkins 会通过 webhook 自动触发构建过程。确保你的 gitlab 项目正确配置了 webhook，指向 jenkins 的构建 url。

配置 webhook：

在 gitlab 项目中，添加 jenkins 的 webhook，确保它能在每次推送代码后触发 jenkins 构建任务。

总结

jenkins 安装和配置：确保你已经安装并配置了 jenkins 和相关插件。
gitlab 与 jenkins 集成：通过 webhook 配置 gitlab 与 jenkins 的集成。
dockerfile 和 jenkins pipeline：编写 dockerfile 和 jenkins pipeline 脚本来构建、推送 docker 镜像。
上传小程序：使用微信小程序 cli 工具上传构建的代码。
自动化构建和部署：通过 webhook 和 jenkins 自动化构建和部署流程。

在 almalinux 上配置 jenkins 自动化构建、docker 部署和与 gitlab 集成的步骤，涵盖从系统安装到 jenkins 配置、docker 部署、gitlab 集成、以及微信小程序自动构建和上传等过程。下面是详细的安装和配置步骤。

1. 安装 jenkins 和依赖

首先，我们需要在 almalinux 上安装 jenkins。

1.1 安装 java（jenkins 的运行依赖）

jenkins 需要 java 运行环境，通常推荐使用 openjdk。

sudo dnf install java-11-openjdk-devel -y

1.2 安装 jenkins

jenkins 官方提供了 rhel/centos 8 和 almalinux 8 的安装包。你可以通过以下步骤安装 jenkins：

添加 jenkins 仓库

sudo wget -o /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat/jenkins.repo

导入 jenkins gpg 密钥

sudo rpm --import https://pkg.jenkins.io/redhat/jenkins.io.key

安装 jenkins

sudo dnf install jenkins -y

1.3 启动 jenkins 服务

安装完成后，启动 jenkins 服务并使其开机自启：

sudo systemctl start jenkins
sudo systemctl enable jenkins

1.4 开放 jenkins 的端口（默认 8080）

sudo firewall-cmd --zone=public --add-port=8080/tcp --permanent
sudo firewall-cmd --reload

1.5 访问 jenkins web ui

在浏览器中访问 jenkins：

http://<your-server-ip>:8080

首次访问时，jenkins 会要求你输入解锁密钥。你可以在以下位置找到它：

sudo cat /var/lib/jenkins/secrets/initialadminpassword

输入密码后，你可以继续设置 jenkins。

2. 安装 jenkins 插件

在 jenkins 中，我们需要安装一些插件来支持 docker 和 gitlab 集成。

进入 jenkins 控制台，点击 manage jenkins -> manage plugins。
在 available 标签下，搜索并安装以下插件：
- docker pipeline：支持在 jenkins 中执行 docker 命令。
- gitlab plugin：与 gitlab 仓库集成。
- pipeline plugin：用于定义 jenkins 流水线（pipeline）。

安装完成后，重启 jenkins。

3. 安装 docker

在 jenkins 中使用 docker 来构建和部署微信小程序。首先，你需要安装 docker。

3.1 安装 docker

# 安装 docker 依赖
sudo dnf install -y yum-utils device-mapper-persistent-data lvm2
# 设置 docker 仓库
sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 安装 docker ce
sudo dnf install docker-ce docker-ce-cli containerd.io -y
# 启动并启用 docker
sudo systemctl start docker
sudo systemctl enable docker

3.2 配置 docker 用户权限

为了避免每次运行 docker 命令时都需要使用 sudo，你可以将 jenkins 用户添加到 docker 组：

sudo usermod -ag docker jenkins

然后重新启动 jenkins 服务：

sudo systemctl restart jenkins

4. 配置 gitlab 集成

jenkins 需要能够从 gitlab 获取代码并触发构建。

4.1 配置 gitlab webhook

在 gitlab 上，进入你的项目。

进入 settings -> webhooks。

添加一个新的 webhook，设置 url 为 jenkins 构建的 url：

http://<jenkins-ip>:8080/project/<jenkins-job-name>

选择 push events 和 merge request events，确保每次提交或合并时 jenkins 都能触发构建。 4.2 配置 gitlab plugin 在 jenkins 中，点击 manage jenkins -> configure system。在 gitlab 配置部分，输入 gitlab 的 url 和 api token。在 gitlab 中生成 api token：进入 user settings -> access tokens 创建一个新的访问令牌。配置完成后，保存并测试连接。

5. 创建 jenkins pipeline

使用 jenkins pipeline 来定义整个构建过程。创建一个新的 pipeline 类型的 job。

5.1 配置 job

在 jenkins 控制台，点击 new item -> pipeline。
在 pipeline 配置页面，选择 pipeline script。
在 pipeline script 部分编写你的 jenkins pipeline 脚本，定义构建、docker 镜像构建和微信小程序上传的过程。

5.2 jenkins pipeline 脚本示例

以下是一个完整的 jenkins pipeline 脚本示例：

pipeline {
    agent any
    environment {
        docker_image = "wechat-miniapp"
        docker_registry = "your-docker-registry"
    }
    stages {
        stage('checkout') {
            steps {
                // 从 gitlab 获取代码
                git 'http://your_gitlab_repo_url.git'
            }
        }
        stage('build docker image') {
            steps {
                script {
                    // 构建 docker 镜像
                    sh 'docker build -t ${docker_registry}/${docker_image}:latest .'
                }
            }
        }
        stage('push docker image') {
            steps {
                script {
                    // 推送 docker 镜像到 docker registry
                    sh 'docker push ${docker_registry}/${docker_image}:latest'
                }
            }
        }
        stage('deploy') {
            steps {
                script {
                    // 拉取并运行 docker 镜像
                    sh 'docker pull ${docker_registry}/${docker_image}:latest'
                    sh 'docker run -d -p 3000:3000 ${docker_registry}/${docker_image}:latest'
                }
            }
        }
        stage('upload to wechat') {
            steps {
                script {
                    // 使用微信小程序 cli 上传代码
                    sh 'weapp-cli upload --appid <your_app_id> --project ./dist'
                }
            }
        }
    }
    post {
        always {
            // 清理 docker 系统
            sh 'docker system prune -f'
        }
    }
}

6. 微信小程序的构建和上传

6.1 安装微信小程序 cli 工具

如果你需要自动化上传微信小程序，可以使用 weapp-cli 工具。

在你的构建过程中，安装并使用微信小程序 cli 来上传小程序代码：

npm install -g weapp-cli

6.2 配置自动上传

将上传命令添加到 jenkins pipeline 中的最后一个阶段：

stage('upload to wechat') {
    steps {
        script {
            // 上传到微信小程序
            sh 'weapp-cli upload --appid <your_app_id> --project ./dist'
        }
    }
}

你需要替换 <your_app_id> 和 ./dist 为你实际的小程序 app id 和构建后的目录。

7. 自动化构建与部署

gitlab push：每次代码提交到 gitlab 时，webhooks 会触发 jenkins 构建。
jenkins pipeline：jenkins 会从 gitlab 拉取代码，构建 docker 镜像，并进行微信小程序的自动构建与上传。
docker 部署：使用 docker 容器运行构建好的微信小程序。

8. 总结

通过这些步骤，你可以在 almalinux 上配置 jenkins，结合 docker 部署和 gitlab 集成，自动化构建和发布微信小程序：

安装 jenkins 和 docker。
配置 jenkins 与 gitlab 的集成。
使用 docker 构建镜像并发布。
使用微信小程序 cli 自动上传代码。
配置 webhook，自动触发 jenkins 构建。

要将微信小程序部署到 docker 上，并使用 jenkins 实现自动构建和更新，我们需要明确几个关键步骤。主要的步骤包括：

构建微信小程序：微信小程序的构建过程通常会生成一个可以通过 web 服务器提供服务的构建文件夹。你可以将这些文件夹作为 docker 镜像的一部分来部署。
创建 docker 镜像：我们需要为微信小程序创建一个 docker 镜像，这样可以在容器中运行它。
jenkins 自动构建和发布：在 jenkins 中配置一个流水线来自动化从 gitlab 拉取代码、构建 docker 镜像、推送到 docker 仓库，并部署到目标服务器。

详细步骤：

1. 准备微信小程序项目

微信小程序本身是一个前端项目，通常使用 npm run build 进行构建，这样会生成一个可以通过 web 服务器提供的构建文件夹（例如 dist/ 或 build/）。

首先，确保你已经准备好微信小程序的代码并能够通过以下命令构建它：

npm install
npm run build

2. dockerfile 示例

接下来，我们需要为微信小程序创建一个 dockerfile，这样就能将构建好的文件夹部署到 docker 容器中。

2.1 创建 dockerfile

在微信小程序的项目根目录下创建一个 dockerfile，示例如下：

# 使用 nginx 作为基础镜像
from nginx:alpine
# 设置工作目录
workdir /usr/share/nginx/html
# 将本地构建的文件（例如 dist 文件夹）复制到容器的工作目录中
copy ./dist /usr/share/nginx/html
# 暴露 nginx 的默认端口 80
expose 80
# 默认命令：启动 nginx
cmd ["nginx", "-g", "daemon off;"]

这里的 dockerfile 做了以下几件事情：

使用 nginx 作为 web 服务器来提供小程序的静态资源。
将构建后的文件夹（例如 dist/）复制到 nginx 默认的 web 根目录 /usr/share/nginx/html。
设置 nginx 启动命令并暴露容器的 80 端口。

2.2 构建 docker 镜像

在项目根目录下，执行以下命令来构建 docker 镜像：

docker build -t wechat-miniapp .

2.3 运行 docker 容器

构建镜像之后，运行 docker 容器：

docker run -d -p 8080:80 wechat-miniapp

这将启动一个 nginx 服务器，监听宿主机的 8080 端口。你可以通过访问 http://<your-server-ip>:8080 来查看你的微信小程序。

3. 配置 jenkins 自动构建和更新

接下来，我们要使用 jenkins 自动化构建和更新过程。主要的任务是：从 gitlab 获取代码、构建 docker 镜像、推送镜像到 docker hub 或私有仓库，然后在目标服务器上拉取最新的镜像并运行。

3.1 安装 jenkins 插件

在 jenkins 上，安装以下插件：

docker pipeline：用于在 jenkins 中执行 docker 操作。
gitlab plugin：用于与 gitlab 集成，拉取代码。
pipeline plugin：用于在 jenkins 中创建流水线脚本。

3.2 配置 jenkins 连接到 gitlab

在 jenkins 上配置 gitlab 集成：

进入 jenkins，点击 manage jenkins -> configure system。
在 gitlab 配置部分，添加 gitlab 服务器的 url 和 api token。你可以在 gitlab 上创建一个新的 api token。
在 gitlab plugin 中，测试连接是否成功。

3.3 配置 jenkins pipeline

在 jenkins 中，点击 new item -> pipeline。
在 pipeline 配置页面中，选择 pipeline script。
在 pipeline script 中编写你的构建脚本，示例如下：

pipeline {
    agent any
    environment {
        docker_image = "wechat-miniapp"
        docker_registry = "your-docker-registry"  // docker 仓库地址（例如 docker hub 或私有仓库）
        docker_tag = "latest"  // docker 镜像标签
    }
    stages {
        stage('checkout') {
            steps {
                // 从 gitlab 获取代码
                git 'http://your_gitlab_repo_url.git'
            }
        }
        stage('install dependencies') {
            steps {
                script {
                    // 安装依赖
                    sh 'npm install'
                }
            }
        }
        stage('build') {
            steps {
                script {
                    // 构建微信小程序
                    sh 'npm run build'
                }
            }
        }
        stage('build docker image') {
            steps {
                script {
                    // 构建 docker 镜像
                    sh 'docker build -t ${docker_registry}/${docker_image}:${docker_tag} .'
                }
            }
        }
        stage('push docker image') {
            steps {
                script {
                    // 将镜像推送到 docker 仓库
                    sh 'docker push ${docker_registry}/${docker_image}:${docker_tag}'
                }
            }
        }
        stage('deploy docker container') {
            steps {
                script {
                    // 在目标服务器上拉取最新镜像并运行 docker 容器
                    sh 'docker pull ${docker_registry}/${docker_image}:${docker_tag}'
                    sh 'docker stop wechat-miniapp || true'
                    sh 'docker rm wechat-miniapp || true'
                    sh 'docker run -d --name wechat-miniapp -p 8080:80 ${docker_registry}/${docker_image}:${docker_tag}'
                }
            }
        }
    }
    post {
        always {
            // 清理 docker 镜像和容器
            sh 'docker system prune -f'
        }
    }
}

说明：

checkout：从 gitlab 仓库中拉取代码。
install dependencies：安装微信小程序的依赖。
build：构建微信小程序，通常会生成一个 dist/ 或 build/ 文件夹。
build docker image：使用 dockerfile 构建 docker 镜像。
push docker image：将构建好的 docker 镜像推送到 docker 仓库（例如 docker hub 或私有 docker registry）。
deploy docker container：在目标服务器上拉取镜像并运行 docker 容器，将微信小程序部署到生产环境。
post actions：清理 docker 镜像和容器，释放资源。

3.4 配置 gitlab webhook

在 gitlab 中，进入你的项目设置，配置 webhook，使每次代码推送后自动触发 jenkins 构建：

在 gitlab 中，进入项目设置 -> webhooks。

添加 jenkins 的 webhook 地址：

http://<jenkins-ip>:8080/project/<jenkins-job-name>

选择 push events 和 merge requests，这样每次代码提交或合并时，jenkins 会自动构建。

4. 总结

通过以上步骤，你可以实现以下目标：

docker 部署微信小程序：使用 nginx 作为 web 服务器，部署构建好的微信小程序。
jenkins 自动构建和发布：通过 jenkins pipeline，自动化从 gitlab 拉取代码、构建 docker 镜像、推送镜像到 docker 仓库、部署到目标服务器。
自动更新：每次代码提交到 gitlab，jenkins 会自动触发构建并部署最新版本的小程序。

这样，你就可以通过 docker 容器化的方式，利用 jenkins 自动化构建和部署微信小程序，从而提高开发和发布的效率。

到此这篇关于docker部署微信小程序自动构建发布和更新的文章就介绍到这了,更多相关docker部署微信小程序内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

docker部署微信小程序自动构建发布和更新的详细步骤