---
title: "Cách thiết lập đường ống Continuous Integration trong Jenkins trên Ubuntu 20.04"
description: "Cách thiết lập đường ống Continuous Integration trong Jenkins trên Ubuntu 20.04"
url: https://cloudfly.vn/techblog/cach-thiet-lap-duong-ong-continuous-integration-trong-jenkins-tren-ubuntu-2004
image: https://media.cloudfly.vn/posts/techblog_093I9Rt.png
---

# Cách thiết lập đường ống Continuous Integration trong Jenkins trên Ubuntu 20.04

## Giới thiệu

Jenkins là một máy chủ tự động hóa mã nguồn mở nhằm mục đích tự động hóa các tác vụ kỹ thuật lặp đi lặp lại liên quan đến việc tích hợp liên tục (continuous integration - CI) và phân phối phần mềm. Với một hệ sinh thái bổ sung mạnh mẽ và hỗ trợ rộng rãi, Jenkins có thể xử lý một loạt các khối lượng công việc để xây dựng, thử nghiệm và triển khai các ứng dụng.

Trong các hướng dẫn trước, chúng tôi đã cài đặt Jenkins trên máy chủ Ubuntu 20.04 và thiết lập cấu hình Jenkins với SSL bằng Nginx reverse proxy. Trong hướng dẫn này, chúng tôi sẽ trình bày cách thiết lập Jenkins để tự động kiểm tra ứng dụng khi các thay đổi được đẩy vào kho lưu trữ.

Đối với hướng dẫn này, chúng tôi sẽ tích hợp Jenkins với GitHub để Jenkins được thông báo khi mã mới được đẩy vào kho lưu trữ. Khi Jenkins được thông báo, nó sẽ kiểm tra mã và sau đó kiểm tra nó trong vùng chứa Docker để cách ly môi trường thử nghiệm khỏi máy chủ Jenkins. Chúng tôi sẽ sử dụng một ứng dụng Node.js mẫu để chỉ ra cách xác định quy trình CI / CD cho một dự án.

## Điều kiện

Để làm theo hướng dẫn này, bạn sẽ cần một máy chủ Ubuntu 20.04 với ít nhất 1G RAM được thiết lập cấu hình với cài đặt Jenkins an toàn. Để bảo mật đúng cách cho giao diện web, bạn sẽ cần gán một tên miền cho máy chủ Jenkins. Thực hiện theo các hướng dẫn sau để tìm hiểu cách thiết lập Jenkins ở định dạng mong đợi:
* Cách cài đặt Jenkins trên Ubuntu 20.04
* Cách cài đặt Nginx trên Ubuntu 20.04
* Cách bảo mật Nginx bằng Let’s Encrypt trên Ubuntu 20.04
* Cách thiết lập cấu hình Jenkins với SSL bằng cách sử dụng Nginx Reverse Proxy

Để kiểm soát tốt nhất môi trường thử nghiệm của mình, chúng ta sẽ chạy thử nghiệm ứng dụng của mình trong vùng chứa Docker. Sau khi Jenkins thiết lập và chạy, hãy cài đặt Docker trên máy chủ bằng cách làm theo các bước một và hai của hướng dẫn này:
* Cách cài đặt và sử dụng Docker trên Ubuntu 20.04

Khi bạn đã hoàn thành các hướng dẫn trên, bạn có thể tiếp tục với bài viết này.

## Thêm Jenkins User vào Docker Group

Sau khi làm theo các điều kiện trên, cả Jenkins và Docker đều được cài đặt trên máy chủ của bạn. Tuy nhiên, theo mặc định, Linux user chịu trách nhiệm chạy quy trình Jenkins không thể truy cập Docker.

Để khắc phục điều này, chúng ta cần thêm `jenkins` user vào nhóm `docker` bằng lệnh `usermod`:
```command
sudo usermod -aG docker jenkins
```

Bạn có thể liệt kê các thành viên của nhóm docker để xác nhận rằng `jenkins` user đã được thêm thành công:
```command
grep docker /etc/group
```

```
[secondary_label Output]
docker:x:999:sammy,jenkins
```

Để Jenkins sử dụng tư cách thành viên mới, bạn cần bắt đầu lại quá trình:
```command
sudo systemctl restart jenkins
```

Nếu bạn đã cài đặt Jenkins với các plugin mặc định, bạn cần phải kiểm tra để đảm bảo rằng các plugin `docker` và `docker-pipeline` cũng được bật. Để làm như vậy, hãy nhấp vào **Manage Jenkins** từ thanh bên, sau đó nhấp vào **Manage Plugins** từ menu tiếp theo. Nhấp vào tab **Available** của menu plugin để tìm kiếm các plugin mới và nhập `docker` vào thanh tìm kiếm. Nếu cả `Docker Pipeline` và `Docker plugin` đều được trả về dưới dạng tùy chọn và chúng không được chọn, hãy chọn cả hai và khi được nhắc, hãy cho phép Jenkins khởi động lại với các plugin mới được bật.

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_2.png)

Quá trình này sẽ mất khoảng một phút và trang sẽ được làm mới sau đó.

## Tạo mã thông báo truy cập cá nhân trong GitHub

Để Jenkins xem các dự án GitHub của bạn, bạn cần tạo Mã truy cập cá nhân (Personal Access Token) trong tài khoản GitHub.

Bắt đầu bằng cách truy cập GitHub và đăng nhập vào tài khoản của bạn nếu bạn chưa làm như vậy. Sau đó, nhấp vào biểu tượng user của bạn ở góc trên bên phải và chọn **Settings** từ menu thả xuống:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_3.png)

Trên trang tiếp theo, tìm phần **Developer settings** của menu bên trái và nhấp vào **Personal access tokens**:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_4.png)

Nhấp vào nút **Generate new toke**n trên trang tiếp theo:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_5.png)

Bạn sẽ được đưa đến một trang nơi bạn có thể xác định phạm vi cho mã thông báo mới của mình.

Trong hộp **Token description**, hãy thêm mô tả cho phép bạn nhận ra nó sau này:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_6.png)

Trong phần **Select scopes**, hãy kiểm tra các hộp **repo:status**, **repo:public_repo** and **admin:org_hook**. Những điều này sẽ cho phép Jenkins cập nhật trạng thái cam kết và tạo webhook cho dự án. Nếu bạn đang sử dụng một kho lưu trữ riêng tư, bạn sẽ cần phải chọn quyền **repo** chung vì repo subitems:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_7.png)

Khi bạn hoàn tất, hãy nhấp vào **Generate token** ở dưới cùng.

Bạn sẽ được chuyển hướng trở lại trang chỉ mục Personal access tokens và mã thông báo mới của bạn sẽ hiển thị:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_8.png)

Sao chép mã thông báo ngay bây giờ để có thể tham khảo nó sau này. Như thông báo cho biết, không có cách nào để lấy lại mã khi bạn rời khỏi trang này. 

<$>[note]
**Lưu ý:** Như đã đề cập trong ảnh chụp màn hình ở trên, vì lý do bảo mật, không có cách nào để hiển thị lại mã thông báo sau khi bạn rời khỏi trang này. Nếu bạn bị mất mã thông báo, hãy xóa mã thông báo hiện tại khỏi tài khoản GitHub của bạn, sau đó tạo một mã mới.
<$>

Bây giờ bạn đã có mã thông báo truy cập cá nhân cho tài khoản GitHub của mình, chúng ta có thể thiết lập cấu hình Jenkins để xem kho lưu trữ dự án của bạn.

## Thêm GitHub Personal Access Token vào Jenkins

Bây giờ chúng ta có một mã thông báo, chúng ta cần thêm nó vào máy chủ Jenkins của mình để nó có thể tự động thiết lập webhook. Đăng nhập vào giao diện web Jenkins của bạn bằng tài khoản quản trị bạn đã thiết lập cấu hình trong khi cài đặt.

Nhấp vào username của bạn ở góc trên cùng bên phải để truy cập cài đặt user của bạn, và từ đó, nhấp vào **Credentials** trong menu bên trái. :

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_9.png)

Trên trang tiếp theo, nhấp vào mũi tên bên cạnh **(global)** trong phạm vi **Jenkins**. Trong hộp xuất hiện, nhấp vào **Add credentials**:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_10.png)

Bạn sẽ được đưa đến một biểu mẫu để thêm thông tin đăng nhập mới.

Trong menu thả xuống **Kind**, chọn **Secret text**. Trong trường **Secret**, hãy dán mã thông báo truy cập cá nhân GitHub của bạn. Điền vào trường **Description** để bạn có thể xác định mục nhập này vào một ngày sau đó. Bạn có thể để trường Scope là Global và để trống trường ID:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_11.png)

Nhấp vào nút **OK** khi bạn hoàn tất.

Bây giờ bạn sẽ có thể tham khảo các thông tin đăng nhập này từ các phần khác của Jenkins để hỗ trợ cấu hình.

## Thiết lập quyền truy cập của Jenkins vào GitHub

Quay lại trang tổng quan Jenkins chính, nhấp vào **Manage Jenkins** ở menu bên trái:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_12.png)

Trong danh sách các liên kết trên trang sau, bấm vào **Configure System**:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_13.png)

Cuộn qua các tùy chọn trên trang tiếp theo cho đến khi bạn tìm thấy phần **GitHub**. Nhấp vào nút **Add GitHub Server** và sau đó chọn **GitHub Server**:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_14.png)

Phần này sẽ mở rộng để nhắc nhở một số thông tin bổ sung. Trong menu thả xuống **Credentials**, hãy chọn mã thông báo truy cập cá nhân GitHub mà bạn đã thêm trong phần cuối cùng:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_15.png)

Nhấp vào nút **Test connection**. Jenkins sẽ thực hiện một cuộc gọi API thử nghiệm tới tài khoản của bạn và xác minh kết nối:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_16.png)

Khi bạn hoàn tất, hãy nhấp vào nút **Save** để thực hiện các thay đổi của bạn.

## Thiết lập Demonstration Application trong Tài khoản GitHub của bạn

Để chứng minh cách sử dụng Jenkins để kiểm tra một ứng dụng, chúng ta sẽ sử dụng chương trình “hello world” được tạo bằng Hapi.js. Vì chúng ta đang thiết lập Jenkins để phản ứng với các lần đẩy vào kho lưu trữ, bạn cần có bản sao demonstration code của riêng mình.

Truy cập kho lưu trữ dự án và nhấp vào nút **Fork** ở góc trên bên phải để tạo bản sao của kho lưu trữ trong tài khoản của bạn:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_17.png)

Một bản sao của kho lưu trữ sẽ được thêm vào tài khoản của bạn.

Kho lưu trữ chứa tệp `package.json` xác định thời gian chạy và phụ thuộc phát triển, cũng như cách chạy bộ thử nghiệm được bao gồm. Các phụ thuộc có thể được cài đặt bằng cách chạy `npm install` và các bài kiểm tra có thể được chạy bằng cách sử dụng `npm test`.

Chúng ta cũng đã thêm `Jenkinsfile` vào repo. Jenkins đọc tệp này để xác định các hành động chạy đối với kho lưu trữ để xây dựng, kiểm tra hoặc triển khai. Nó được viết bằng phiên bản khai báo của Jenkins Pipeline DSL.

`Jenkinsfile` có trong kho lưu trữ `hello-hapi` trông như thế này:
```nginx
[label Jenkinsfile]
#!/usr/bin/env groovy

pipeline {

    agent {
        docker {
            image 'node'
            args '-u root'
        }
    }

    stages {
        stage('Build') {
            steps {
                echo 'Building...'
                sh 'npm install'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                sh 'npm test'
            }
        }
    }
}
```

`pipeline` chứa toàn bộ định nghĩa mà Jenkins sẽ đánh giá. Bên trong, chúng ta có một phần `agent` chỉ định nơi các hành động trong đường dẫn sẽ thực thi. Để cách ly môi trường của chúng ta với hệ thống máy chủ, chúng ta sẽ thử nghiệm trong vùng chứa Docker, do tác nhân `docker` chỉ định.

Vì Hapi.js là một khuôn khổ cho Node.js, chúng ta sẽ sử dụng hình ảnh `node` Docker làm cơ sở. Chúng ta chỉ định `root` user trong vùng chứa để user có thể ghi đồng thời vào cả ổ đĩa đính kèm có chứa mã đã kiểm tra và vào ổ đĩa mà tập lệnh ghi đầu ra của nó.

Tiếp theo, tệp xác định hai giai đoạn, tức là phân chia công việc hợp lý. Chúng ta đã đặt tên cho phần đầu tiên là “Build” và phần thứ hai là “Test”. Bước xây dựng in một thông báo chẩn đoán và sau đó chạy `npm install` để lấy các phụ thuộc cần thiết. Bước kiểm tra in một thông báo khác và sau đó chạy các kiểm tra như được xác định trong tệp `package.json`.

Bây giờ bạn có một kho lưu trữ với `Jenkinsfile` hợp lệ, chúng ta có thể thiết lập Jenkins để xem kho lưu trữ này và chạy tệp khi các thay đổi được giới thiệu.

## Tạo một Pipeline mới trong Jenkins

Tiếp theo, chúng ta có thể thiết lập Jenkins sử dụng mã thông báo truy cập cá nhân GitHub để xem kho lưu trữ.

Quay lại trang tổng quan Jenkins chính, nhấp vào **New Item** ở menu bên trái:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_18.png)

Nhập tên cho pipeline mới của bạn trong trường **Enter an item name**. Sau đó, chọn **Pipeline** làm loại mục:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_19.png)

Nhấp vào nút **OK** ở dưới cùng để tiếp tục.

Trên màn hình tiếp theo, chọn hộp **GitHub project**. Trong trường **Project url** xuất hiện, hãy nhập URL kho lưu trữ GitHub của dự án của bạn.

<$>[note]
**Lưu ý:** Đảm bảo trỏ đến nhánh ứng dụng Hello Hapi của bạn để Jenkins có quyền thiết lập cấu hình webhook.
<$>

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_20.png)

Tiếp theo, trong phần **Build Triggers**, hãy kiểm tra hộp **GitHub hook trigger for GITScm polling**:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_21.png)

Trong phần **Pipeline**, chúng ta cần yêu cầu Jenkins chạy pipeline được xác định trong `Jenkinsfile` trong kho lưu trữ của chúng ta. Thay đổi loại **Definition** thành **Pipeline script from SCM**.

Trong phần mới xuất hiện, chọn **Git** trong menu **SCM**. Trong trường **Repository URL** xuất hiện, hãy nhập lại URL tới nhánh kho lưu trữ của bạn:

<$>[note]
**Lưu ý:** Một lần nữa, hãy đảm bảo trỏ đến nhánh của ứng dụng Hello Hapi.
<$>

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_22.png)

<$>[note]
**Lưu ý:** Ví dụ của chúng ta tham chiếu đến `Jenkinsfile` có sẵn trong kho lưu trữ công khai. Nếu dự án của bạn không thể truy cập công khai, bạn sẽ cần sử dụng nút **add credentials** để thêm quyền truy cập bổ sung vào kho lưu trữ. Bạn có thể thêm mã thông báo truy cập cá nhân như chúng ta đã làm với cấu hình hooks trước đó.
<$>

Khi bạn hoàn tất, hãy nhấp vào nút **Save** ở cuối trang.

## Thực hiện xây dựng ban đầu và thiết lập cấu hình Webhooks

Jenkins không tự động thiết lập cấu hình webhook khi bạn xác định đường dẫn cho kho lưu trữ trong giao diện. Để kích hoạt Jenkins thiết lập các hook thích hợp, chúng ta cần thực hiện xây dựng thủ công lần đầu tiên.

Trong trang chính của kênh của bạn, nhấp vào **Build Now** ở menu bên trái:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_23.png)

Một bản xây dựng mới sẽ được lên lịch. Trong hộp **Build History** ở góc dưới bên trái, một công trình mới sẽ xuất hiện trong giây lát. Ngoài ra, **Stage View** sẽ bắt đầu được vẽ trong khu vực chính của giao diện. Điều này sẽ theo dõi tiến trình chạy thử nghiệm của bạn khi các giai đoạn khác nhau được hoàn thành:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_24.png)

Trong hộp **Build History**, bấm vào số được liên kết với bản dựng để chuyển đến trang chi tiết bản dựng. Từ đây, bạn có thể nhấp vào nút **Console Output** ở menu bên trái để xem chi tiết các bước đã chạy:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_25.png)

Nhấp vào mục **Back to Project** trong menu bên trái khi bạn hoàn tất để quay lại chế độ xem đường dẫn chính.

Bây giờ chúng ta đã xây dựng dự án một lần, chúng ta có thể nhờ Jenkins tạo webhook cho dự án của chúng ta. Nhấp vào **Configure** trong menu bên trái của đường dẫn:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_26.png)

Không cần thay đổi trên màn hình này, chỉ cần nhấp vào nút **Save** ở dưới cùng. Bây giờ Jenkins đã có thông tin về dự án từ quá trình xây dựng ban đầu, nó sẽ đăng ký webhook với dự án GitHub của chúng ta khi bạn lưu trang.

Bạn có thể xác minh điều này bằng cách truy cập kho lưu trữ GitHub của mình và nhấp vào nút **Settings**. Trên trang tiếp theo, nhấp vào **Webhooks** từ menu bên. Bạn sẽ thấy webhook máy chủ Jenkins của mình trong giao diện chính:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_27.png)

Nếu vì bất kỳ lý do nào mà Jenkins không đăng ký được hook (ví dụ: do các thay đổi hoặc ngừng hoạt động của API ngược dòng giữa Jenkins và Github), bạn có thể nhanh chóng tự thêm một hook bằng cách nhấp vào **Add webhook** và đảm bảo rằng **Payload URL** được đặt thành `https://<^>my-jenkins-server<^>:8080/github-webhook` và **Content type** được đặt thành `application/json`, sau đó nhấp lại vào **Add webhook** ở cuối lời nhắc.

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_28.png)

Bây giờ, khi bạn đẩy các thay đổi mới vào kho lưu trữ của mình, Jenkins sẽ được thông báo. Sau đó, nó sẽ kéo mã mới và kiểm tra lại bằng quy trình tương tự.

Để ước tính điều này, trong trang kho lưu trữ của chúng ta trên GitHub, bạn có thể nhấp vào nút **Create new file** ở bên trái của nút màu xanh **Clone or download**:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_29.png)

Trên trang tiếp theo, chọn tên tệp và một số nội dung giả:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_30.png)

Nhấp vào nút **Commit new file** ở dưới cùng khi bạn hoàn tất.

Nếu bạn quay lại giao diện Jenkins của mình, bạn sẽ thấy một bản dựng mới tự động bắt đầu:

![description image](https://media.cloudfly.vn/posts/cach-thiet-lap-duong-ong-Continuous-Integration-trong-Jenkins-tren-Ubuntu-20.04_31.png)

Bạn có thể bắt đầu các bản dựng bổ sung bằng cách thực hiện cam kết đối với bản sao cục bộ của kho lưu trữ và đẩy nó trở lại GitHub.

## Kết luận

Trong hướng dẫn này, chúng ta đã thiết lập cấu hình Jenkins để xem một dự án GitHub và tự động kiểm tra mọi thay đổi mới được cam kết. Jenkins kéo mã từ kho lưu trữ và sau đó chạy các thủ tục xây dựng và thử nghiệm từ bên trong các vùng chứa Docker bị cô lập. Mã kết quả có thể được triển khai hoặc lưu trữ bằng cách thêm các hướng dẫn bổ sung vào cùng một `Jenkinsfile`.

Để tìm hiểu thêm về Tác vụ GitHub, hãy tham khảo tài liệu của GitHub.
