通過 Jenkins 和 Docker 部署微信小程序，并實現(xiàn)自動構建、發(fā)布和版本更新，主要涉及以下幾個步驟：

• 設置 Jenkins 環(huán)境
• 配置 GitLab 與 Jenkins 的集成
• 構建 Docker 鏡像
• 部署和發(fā)布微信小程序
• 配置 Jenkins 自動構建

以下是詳細的步驟說明：

1. 設置 Jenkins 環(huán)境

首先，確保你已經安裝和配置了 Jenkins 服務器。假設你已經安裝了 Jenkins，并且 Jenkins 能夠正常運行。

安裝 Jenkins 所需插件：

• Docker Plugin：用于在 Jenkins 中執(zhí)行 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 獲取代碼并觸發(fā)構建。

配置 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。你需要創(chuàng)建一個 GitLab 訪問令牌（Token）：
• 在 GitLab 上，進入 User Settings -> Access Tokens，創(chuàng)建一個新的訪問令牌。
• 保存設置后，你可以通過 GitLab Plugin 連接到 GitLab 倉庫。

3. 構建 Docker 鏡像

在 Jenkins 中創(chuàng)建一個 Pipeline 作業(yè)，用來構建 Docker 鏡像并部署微信小程序。

Dockerfile 示例

首先，在你的微信小程序項目根目錄下創(chuàng)建一個 Dockerfile，用于構建 Docker 鏡像。

# 使用 Node.js 鏡像作為基礎鏡像
FROM node:16
# 創(chuàng)建并設置工作目錄
WORKDIR /app
# 將當前目錄下的項目文件復制到 Docker 容器中
COPY . .
# 安裝依賴
RUN npm install
# 執(zhí)行構建命令
RUN npm run build
# 暴露端口
EXPOSE 3000
# 啟動微信小程序構建服務（例如，使用 Nginx 或其他方式）
CMD ["npm", "start"]

Jenkins Pipeline 腳本

創(chuàng)建一個 Jenkins Pipeline 來執(zhí)行代碼的拉取、Docker 鏡像的構建和發(fā)布。

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 {
            // 構建結束后執(zhí)行的操作，比如清理舊的容器
            sh 'docker system prune -f'
        }
    }
}

說明：

• Checkout：從 GitLab 拉取代碼。
• Build Docker Image：構建 Docker 鏡像。
• Push Docker Image：將鏡像推送到 Docker Registry（如果你使用的是私有倉庫，可以推送到私人 Docker 倉庫）。
• Deploy：在目標服務器上拉取并運行 Docker 鏡像。

4. 部署和發(fā)布微信小程序

構建微信小程序的發(fā)布版本：
使用 npm run build 命令來構建生產版本，通常會生成一個用于發(fā)布的文件夾（例如，dist/ 或 build/）。然后將這些文件部署到你選擇的 web 服務器上（例如 Nginx、Apache 等）。

上傳小程序代碼：
微信小程序通常需要使用微信開發(fā)者工具上傳到微信服務器。你可以在構建完成后，利用微信小程序開發(fā)者工具的命令行工具進行自動化上傳。

微信小程序提供了 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 自動觸發(fā)構建過程。確保你的 GitLab 項目正確配置了 Webhook，指向 Jenkins 的構建 URL。

配置 Webhook：

在 GitLab 項目中，添加 Jenkins 的 Webhook，確保它能在每次推送代碼后觸發(fā) Jenkins 構建任務。

總結

• Jenkins 安裝和配置：確保你已經安裝并配置了 Jenkins 和相關插件。
• GitLab 與 Jenkins 集成：通過 Webhook 配置 GitLab 與 Jenkins 的集成。
• Dockerfile 和 Jenkins Pipeline：編寫 Dockerfile 和 Jenkins Pipeline 腳本來構建、推送 Docker 鏡像。
• 上傳小程序：使用微信小程序 CLI 工具上傳構建的代碼。
• 自動化構建和部署：通過 Webhook 和 Jenkins 自動化構建和部署流程。

在 AlmaLinux 上配置 Jenkins 自動化構建、Docker 部署和與 GitLab 集成的步驟，涵蓋從系統(tǒng)安裝到 Jenkins 配置、Docker 部署、GitLab 集成、以及微信小程序自動構建和上傳等過程。下面是詳細的安裝和配置步驟。

1. 安裝 Jenkins 和依賴

首先，我們需要在 AlmaLinux 上安裝 Jenkins。

1.1 安裝 Java（Jenkins 的運行依賴）

Jenkins 需要 Java 運行環(huán)境，通常推薦使用 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

輸入密碼后，你可以繼續(xù)設置 Jenkins。

2. 安裝 Jenkins 插件

在 Jenkins 中，我們需要安裝一些插件來支持 Docker 和 GitLab 集成。

• 進入 Jenkins 控制臺，點擊 Manage Jenkins -> Manage Plugins。
• 在 Available 標簽下，搜索并安裝以下插件：
  • Docker Pipeline：支持在 Jenkins 中執(zhí)行 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 獲取代碼并觸發(fā)構建。

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 都能觸發(fā)構建。 4.2 配置 GitLab Plugin 在 Jenkins 中，點擊 Manage Jenkins -> Configure System。在 GitLab 配置部分，輸入 GitLab 的 URL 和 API Token。 在 GitLab 中生成 API Token：進入 User Settings -> Access Tokens 創(chuàng)建一個新的訪問令牌。 配置完成后，保存并測試連接。

5. 創(chuàng)建 Jenkins Pipeline

使用 Jenkins Pipeline 來定義整個構建過程。創(chuàng)建一個新的 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 系統(tǒng)
            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 會觸發(fā) Jenkins 構建。
• Jenkins Pipeline：Jenkins 會從 GitLab 拉取代碼，構建 Docker 鏡像，并進行微信小程序的自動構建與上傳。
• Docker 部署：使用 Docker 容器運行構建好的微信小程序。

8. 總結

通過這些步驟，你可以在 AlmaLinux 上配置 Jenkins，結合 Docker 部署和 GitLab 集成，自動化構建和發(fā)布微信小程序：

• 安裝 Jenkins 和 Docker。
• 配置 Jenkins 與 GitLab 的集成。
• 使用 Docker 構建鏡像并發(fā)布。
• 使用微信小程序 CLI 自動上傳代碼。
• 配置 Webhook，自動觸發(fā) Jenkins 構建。

要將微信小程序部署到 Docker 上，并使用 Jenkins 實現(xiàn)自動構建和更新，我們需要明確幾個關鍵步驟。主要的步驟包括：

• 構建微信小程序：微信小程序的構建過程通常會生成一個可以通過 Web 服務器提供服務的構建文件夾。你可以將這些文件夾作為 Docker 鏡像的一部分來部署。
• 創(chuàng)建 Docker 鏡像：我們需要為微信小程序創(chuàng)建一個 Docker 鏡像，這樣可以在容器中運行它。
• Jenkins 自動構建和發(fā)布：在 Jenkins 中配置一個流水線來自動化從 GitLab 拉取代碼、構建 Docker 鏡像、推送到 Docker 倉庫，并部署到目標服務器。

詳細步驟：

1. 準備微信小程序項目

微信小程序本身是一個前端項目，通常使用 npm run build 進行構建，這樣會生成一個可以通過 Web 服務器提供的構建文件夾（例如 dist/ 或 build/）。

首先，確保你已經準備好微信小程序的代碼并能夠通過以下命令構建它：

npm install
npm run build

2. Dockerfile 示例

接下來，我們需要為微信小程序創(chuàng)建一個 Dockerfile，這樣就能將構建好的文件夾部署到 Docker 容器中。

2.1 創(chuàng)建 Dockerfile

在微信小程序的項目根目錄下創(chuàng)建一個 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 服務器來提供小程序的靜態(tài)資源。
• 將構建后的文件夾（例如 dist/）復制到 Nginx 默認的 Web 根目錄 /usr/share/nginx/html。
• 設置 Nginx 啟動命令并暴露容器的 80 端口。

2.2 構建 Docker 鏡像

在項目根目錄下，執(zhí)行以下命令來構建 Docker 鏡像：

docker build -t wechat-miniapp .

2.3 運行 Docker 容器

構建鏡像之后，運行 Docker 容器：

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

這將啟動一個 Nginx 服務器，監(jiān)聽宿主機的 8080 端口。你可以通過訪問 http://<your-server-ip>:8080 來查看你的微信小程序。

3. 配置 Jenkins 自動構建和更新

接下來，我們要使用 Jenkins 自動化構建和更新過程。主要的任務是：從 GitLab 獲取代碼、構建 Docker 鏡像、推送鏡像到 Docker Hub 或私有倉庫，然后在目標服務器上拉取最新的鏡像并運行。

3.1 安裝 Jenkins 插件

在 Jenkins 上，安裝以下插件：

• Docker Pipeline：用于在 Jenkins 中執(zhí)行 Docker 操作。
• GitLab Plugin：用于與 GitLab 集成，拉取代碼。
• Pipeline Plugin：用于在 Jenkins 中創(chuàng)建流水線腳本。

3.2 配置 Jenkins 連接到 GitLab

在 Jenkins 上配置 GitLab 集成：

• 進入 Jenkins，點擊 Manage Jenkins -> Configure System。
• 在 GitLab 配置部分，添加 GitLab 服務器的 URL 和 API Token。你可以在 GitLab 上創(chuàng)建一個新的 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 容器，將微信小程序部署到生產環(huán)境。
• Post Actions：清理 Docker 鏡像和容器，釋放資源。

3.4 配置 GitLab Webhook

在 GitLab 中，進入你的項目設置，配置 Webhook，使每次代碼推送后自動觸發(fā) Jenkins 構建：

在 GitLab 中，進入項目設置 -> Webhooks。

添加 Jenkins 的 Webhook 地址：

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

選擇 Push events 和 Merge requests，這樣每次代碼提交或合并時，Jenkins 會自動構建。

4. 總結

通過以上步驟，你可以實現(xiàn)以下目標：

• Docker 部署微信小程序：使用 Nginx 作為 Web 服務器，部署構建好的微信小程序。
• Jenkins 自動構建和發(fā)布：通過 Jenkins Pipeline，自動化從 GitLab 拉取代碼、構建 Docker 鏡像、推送鏡像到 Docker 倉庫、部署到目標服務器。
• 自動更新：每次代碼提交到 GitLab，Jenkins 會自動觸發(fā)構建并部署最新版本的小程序。

這樣，你就可以通過 Docker 容器化的方式，利用 Jenkins 自動化構建和部署微信小程序，從而提高開發(fā)和發(fā)布的效率。

到此這篇關于docker部署微信小程序自動構建發(fā)布和更新的文章就介紹到這了,更多相關docker部署微信小程序內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論