Tự động triển khai trang tĩnh với Salt, Git, và Webhooks

Hướng dẫn này sẽ hướng dẫn triển khai site tĩnh bằng SaltStack , đây là hệ thống quản lý cấu hình linh hoạt. Các tệp cấu hình được tạo cho Salt sẽ được kiểm soát phiên bản bằng Git. Các bản cập nhật cho mã site tĩnh của bạn sẽ được tự động truyền đến hệ thống sản xuất bằng webhooks, một hệ thống thông báo sự kiện cho web.

Việc thiết lập các cơ chế này mang lại nhiều lợi ích:

Sử dụng webhooks sẽ giúp trang web sản xuất của bạn đồng bộ với quá trình phát triển mà không cần bạn phải thực hiện bất kỳ thao tác nào.
Sử dụng Salt cung cấp một giải pháp đáng tin cậy và có thể mở rộng để thay đổi hệ thống sản xuất của bạn và giảm thiểu lỗi của con người.
Kiểm soát phiên bản quản lý cấu hình giúp bạn theo dõi hoặc khôi phục những thay đổi đã thực hiện đối với hệ thống của mình và cộng tác với những người khác trong quá trình triển khai.

Quy trình phát triển và triển khai

Trình tạo trang tĩnh được sử dụng trong hướng dẫn này là Hugo , một khuôn khổ nhanh được viết bằng Go. Trình tạo trang tĩnh biên dịch Markdown hoặc các tệp nội dung khác thành các tệp HTML. Hướng dẫn này có thể dễ dàng được điều chỉnh cho các khuôn khổ khác.

Hai kho lưu trữ Git sẽ được tạo: một kho sẽ theo dõi các thay đổi trên trang Hugo và kho còn lại sẽ theo dõi các tệp cấu hình của Salt. Kho lưu trữ từ xa sẽ được tạo cho cả hai kho trên GitHub.

Hai Linode sẽ được tạo: một sẽ hoạt động như Salt master, và một sẽ hoạt động như Salt minion. Hướng dẫn này đã được thử nghiệm trên Debian 9, nhưng các hướng dẫn cũng có thể hoạt động với các bản phân phối khác. Salt minion sẽ chạy máy chủ web sản xuất phục vụ cho trang Hugo, và master sẽ cấu hình phần mềm của minion. Minion cũng sẽ chạy máy chủ webhook sẽ nhận thông báo cập nhật mã từ GitHub.

Có thể chạy Salt ở chế độ không có máy chủ chính , nhưng sử dụng máy chủ chính Salt sẽ giúp bạn dễ dàng mở rộng triển khai trong tương lai.

Ghi chú: Quy trình làm việc được mô tả trong hướng dẫn này tương tự như cách phát triển và triển khai trang web Hướng dẫn & Hướng dẫn sử dụng của Linode .

Trước khi bạn bắt đầu

Thiết lập môi trường phát triển

Việc phát triển trang Hugo và công thức Salt của bạn sẽ diễn ra trên máy tính cá nhân của bạn. Một số phần mềm sẽ cần được cài đặt trên máy tính của bạn trước:

1.Cài đặt Git bằng một trong các phương pháp trong hướng dẫn của Linode . Nếu bạn có máy Mac, hãy sử dụng phương pháp Homebrew vì nó cũng sẽ được sử dụng để cài đặt Hugo.

2.Cài đặt Hugo. Tài liệu Hugo có danh sách đầy đủ các phương pháp cài đặt và hướng dẫn cho một số nền tảng phổ biến như sau:

-   Debian/Ubuntu:

        sudo apt-get install hugo

-   Fedora, Red Hat and CentOS:

        sudo dnf install hugo

-   Mac, using [Homebrew](https://brew.sh):

        brew install hugo

-   Windows, using [Chocolatey](https://chocolatey.org)

        choco install hugo -confirm

Triển khai Linodes

Làm theo hướng dẫn Tạo phiên bản máy tính và triển khai hai Linode chạy Debian 9.
Trong tab cài đặt của bảng điều khiển Linodes, hãy gắn nhãn một trong salt-masterhai Linodes là salt-minion. Điều này không bắt buộc nhưng sẽ giúp theo dõi Linode nào phục vụ mục đích nào.
Hoàn tất hướng dẫn Thiết lập và bảo mật phiên bản máy tính trên mỗi Linode để tạo tài khoản người dùng Linux giới hạn với sudonhiều đặc quyền, tăng cường quyền truy cập SSH và xóa các dịch vụ mạng không cần thiết.Ghi chúHướng dẫn này được viết cho người dùng không phải root. Các lệnh yêu cầu quyền nâng cao được thêm tiền tố sudo. Nếu bạn không quen với sudolệnh này, hãy truy cập hướng dẫn Người dùng và Nhóm của chúng tôi .Tất cả các tệp cấu hình phải được chỉnh sửa với quyền cao hơn. Hãy nhớ bao gồm sudotrước khi chạy trình soạn thảo văn bản của bạn.
Cấu hình DNS cho trang web của bạn bằng cách thêm vùng miền và thiết lập DNS ngược trên địa chỉ IP của Salt minion.

Thiết lập Salt Master và Salt Minion

Trước khi bạn có thể bắt đầu thiết lập công thức Salt cho minion, trước tiên bạn cần cài đặt phần mềm Salt trên máy chủ và minion và thiết lập giao tiếp giữa chúng.

1.Đăng nhập vào Salt master Linode qua SSH và chạy tập lệnh khởi động cài đặt Salt:

wget -O bootstrap-salt.sh https://bootstrap.saltproject.io
sudo sh bootstrap-salt.sh -M -N

Ghi chú: Tùy chọn này -Myêu cầu tập lệnh cài đặt phần mềm Salt master và -Ntùy chọn này yêu cầu tập lệnh không cài đặt phần mềm minion.

2.Đăng nhập vào Linode Salt minion qua SSH và đặt tên máy chủ . Hướng dẫn này sử dụng hugo-webservertên máy chủ làm ví dụ:

sudo hostnamectl set-hostname hugo-webserver

Ghi chú: Bước này cần phải được hoàn tất trước khi cài đặt Salt trên minion vì Salt sẽ sử dụng tên máy chủ của bạn để tạo Salt ID cho minion.

3.Chỉnh sửa tệp của minion /etc/hostsvà thêm một dòng mới cho tên máy chủ của bạn sau localhostdòng đó; thay thế 192.0.2.3 bằng địa chỉ IP công khai của minion :

127.0.0.1       localhost
192.0.2.3       hugo-webserver
# [...]

4.Chạy tập lệnh bootstrap trên minion:

wget -O bootstrap-salt.sh https://bootstrap.saltproject.io
sudo sh bootstrap-salt.sh

5.Chỉnh sửa /etc/salt/miniontrên Salt minion. Bỏ chú thích dòng bắt đầu bằng #master:và nhập IP của Salt master sau dấu hai chấm (thay cho 192.0.2.2):

# [...]
master: 192.0.2.2
# [...]

Ghi chú: Linode không tính phí lưu lượng truy cập trong trung tâm dữ liệu qua các địa chỉ IP riêng. Nếu Salt master và minion của bạn nằm trong cùng một trung tâm dữ liệu và cả hai đều có địa chỉ IP riêng, bạn có thể sử dụng địa chỉ IP riêng của Salt master trong bước này để tránh phải chịu phí lưu lượng dữ liệu.

6.Khởi động lại Salt trên minion:

sudo systemctl restart salt-minion

Xác thực Salt Minion

Bây giờ, minion có thể tìm thấy master, nhưng vẫn chưa được xác thực để giao tiếp với master. Salt sử dụng cặp khóa công khai-riêng tư để xác thực minion với master.

1.Trên máy chủ chính , liệt kê dấu vân tay cho tất cả các khóa cục bộ của máy chủ chính, các khóa minion được chấp nhận và các khóa không được chấp nhận:

sudo salt-key --finger-all

Đầu ra sẽ giống như sau:

Local Keys:
master.pem:  fe:1f:e8:3d:26:83:1c:...
master.pub:  2b:93:72:b3:3a:ae:cb:...
Unaccepted Keys:
hugo-webserver:  29:d8:f3:ed:91:9b:51:...

Ghi chú: Các dấu vân tay mẫu trong phần này đã được cắt bớt để ngắn gọn hơn.

2.Sao chép dấu vân tay master.pubtừ đầu ra của salt-key --finger-all. Trên Salt minion của bạn , mở /etc/salt/miniontrong trình soạn thảo văn bản. Bỏ chú thích dòng bắt đầu bằng #master_finger:và nhập giá trị cho master.pubsau dấu hai chấm trong dấu ngoặc đơn:

# [...]
master_finger: '0f:d6:5f:5e:f3:4f:d3:...'
# [...]

3.Khởi động lại Salt trên minion:

sudo systemctl restart salt-minion

4.Xem dấu vân tay khóa cục bộ của minion:

sudo salt-call key.finger --local

local:
    29:d8:f3:ed:91:9b:51:...

So sánh dấu vân tay được liệt kê của đầu ra với dấu vân tay được liệt kê bởi Salt master cho bất kỳ Unaccepted Keys. Đây là đầu ra của salt-key --finger-alllệnh chạy trên master ở đầu phần này.

5.Sau khi xác minh dấu vân tay của minion giống với dấu vân tay được Salt master phát hiện, hãy chạy lệnh sau trên master để chấp nhận khóa của minion:

sudo salt-key -a hugo-webserver

6.Từ máy chủ, hãy xác minh rằng minion đang chạy:

sudo salt-run manage.up

Bạn cũng có thể chạy lệnh ping kiểm tra Salt từ máy chủ đến máy con:

sudo salt 'hugo-webserver' test.ping

hugo-webserver:
    True

Khởi tạo công thức của Salt Minion

Minion Salt đã sẵn sàng để được cấu hình bởi master. Các cấu hình này sẽ được viết trong công thức Salt sẽ được lưu trữ trên GitHub .

1.Trên máy tính của bạn, hãy tạo một thư mục mới để lưu công thức của minion và chuyển đến thư mục đó:

mkdir hugo-webserver-salt-formula
cd hugo-webserver-salt-formula

2.Bên trong thư mục công thức, tạo một hugothư mục mới để lưu trữ cấu hình máy chủ web của bạn:

mkdir hugo

3.Bên trong thư hugomục, tạo một tệp mới install.sls:

nginx_pkg:
  pkg.installed:
    - name: nginx

Ghi chú: Cấu hình Salt được khai báo trong YAML – một ngôn ngữ đánh dấu kết hợp khoảng trắng/thụt lề trong cú pháp của nó. Hãy đảm bảo sử dụng cùng một thụt lề như các đoạn trích được trình bày trong hướng dẫn này.

Một .slstệp là tệp S a L t S state. Trạng thái Salt mô tả trạng thái mà một minion phải có sau khi trạng thái được áp dụng cho nó: ví dụ, tất cả phần mềm cần được cài đặt, tất cả các dịch vụ cần được chạy, v.v.

Đoạn mã trên cho biết một gói có tên nginx(tức là máy chủ web NGINX) phải được cài đặt thông qua trình quản lý gói của bản phân phối. Salt biết cách đàm phán cài đặt phần mềm thông qua trình quản lý gói tích hợp cho nhiều bản phân phối khác nhau. Salt cũng biết cách cài đặt phần mềm thông qua NPM và các trình quản lý gói khác.

Chuỗi nginx_pkglà ID cho thành phần trạng thái, pkglà tên của mô-đun Salt được sử dụng và pkg.installedđược gọi là khai báo hàm . ID thành phần là tùy ý, vì vậy bạn có thể đặt tên theo ý thích.

Ghi chú: Nếu bạn đặt tên ID giống với gói cài đặt có liên quan, thì bạn không cần phải chỉ định tùy - namechọn, vì nó sẽ được suy ra từ ID. Ví dụ, đoạn mã này cũng cài đặt NGINX:

nginx:
  pkg.installed

4.Bên trong thư hugomục, tạo một tệp mới service.sls:

nginx_service:
  service.running:
    - name: nginx
    - enable: True
    - require:
      - pkg: nginx_pkg

Trạng thái này cho biết nginxdịch vụ phải được chạy ngay lập tức và được bật để chạy khi khởi động. Đối với hệ thống Debian 9, Salt sẽ thiết lập cấu hình systemd phù hợp để bật dịch vụ. Salt cũng hỗ trợ các hệ thống init khác.

Các dòng này requirechỉ rõ rằng thành phần trạng thái này không được áp dụng cho đến khi nginx_pkgthành phần kia đã được áp dụng.

Ghi chú: Trừ khi được chỉ định trong một requiretuyên bố, Salt không đảm bảo về thứ tự các thành phần khác nhau được áp dụng. Thứ tự các thành phần được liệt kê trong tệp trạng tháikhông nhất thiết phải tương ứng với thứ tự chúng được áp dụng.

6.Bên trong hugothư mục, tạo một init.slstệp mới với nội dung sau:

include:
  - hugo.install
  - hugo.service

Sử dụng includekhai báo theo cách này chỉ đơn giản là nối các tệp install.slsvà service.slsthành một tệp trạng thái kết hợp duy nhất.

Hiện tại, các tệp trạng thái này chỉ cài đặt và kích hoạt NGINX. Nhiều chức năng hơn sẽ được kích hoạt sau trong hướng dẫn này.

Các trạng thái installand servicesẽ không được áp dụng cho minion riêng lẻ–thay vào đó, chỉ có inittrạng thái kết hợp mới được áp dụng. Trong Salt, khi một tệp có tên init.slstồn tại bên trong một thư mục, Salt sẽ tham chiếu đến trạng thái cụ thể đó theo tên của thư mục mà nó thuộc về (tức là hugotrong ví dụ của chúng tôi).

Ghi chú: Việc tổ chức các tệp trạng thái được sử dụng ở đây không phải là bắt buộc của Salt. Salt không đặt ra hạn chế về cách bạn tổ chức các trạng thái của mình. Cấu trúc cụ thể này được trình bày như một ví dụ về phương pháp hay nhất .

Đẩy công thức muối lên GitHub

1.Bên trong hugo-webserver-salt-formulathư mục trên máy tính của bạn, hãy khởi tạo kho lưu trữ Git mới:

cd ~/hugo-webserver-salt-formula
git init

2.Sắp xếp các tập tin bạn vừa tạo:

git add .

3.Xem lại các tập tin đã dàn dựng:

git status

On branch master
No commits yet
Changes to be committed:
  (use "git rm --cached <file>..." to unstage)

  new file:   hugo/init.sls
  new file:   hugo/install.sls
  new file:   hugo/service.sls

4.Cam kết các tập tin:

git commit -m "Initial commit"

5.Đăng nhập vào trang web GitHub trên trình duyệt của bạn và điều hướng đến trang Tạo kho lưu trữ mới .

6.Tạo một kho lưu trữ công khai mới với tên hugo-webserver-salt-formula:

7.Sao chép URL HTTPS cho kho lưu trữ mới của bạn:8.Trong kho lưu trữ công thức Salt cục bộ của bạn, hãy thêm kho lưu trữ GitHub làm kho lưu trữ origintừ xa và đẩy các tệp mới của bạn vào đó. Thay thế github-usernamebằng người dùng GitHub của bạn:

git remote add origin https://github.com/github-username/hugo-webserver-salt-formula.git
git push -u origin master

Ghi chú: Nếu bạn chưa từng đẩy bất kỳ thứ gì khác vào tài khoản GitHub của mình từ dòng lệnh trước đây, bạn có thể được nhắc xác thực với GitHub. Nếu bạn đã bật xác thực hai yếu tố cho tài khoản của mình, bạn sẽ cần tạo và sử dụng mã thông báo truy cập cá nhân .

9.Nếu bạn quay lại hugo-webserver-salt-formulakho lưu trữ trên GitHub và làm mới trang, bây giờ bạn sẽ thấy các tệp mới của mình.

Bật GitFS trên Salt Master

Cập nhật Salt master của bạn để phục vụ công thức mới từ GitHub:

1.Salt yêu cầu bạn phải cài đặt giao diện Python vào Git để sử dụng GitFS. Trên Salt master Linode:

sudo apt-get install python-git

2.Mở /etc/salt/mastertrong trình soạn thảo văn bản. Bỏ chú thích cho fileserver_backendphần khai báo và nhập rootsvà gitfsvào danh sách khai báo:

fileserver_backend:
  - roots
  - gitfs

rootsđề cập đến các tệp Salt được lưu trữ trên hệ thống tệp của máy chủ chính. Trong khi công thức Salt của máy chủ web Hugo được lưu trữ trên GitHub, tệp Salt Top sẽ được lưu trữ trên máy chủ chính. Tệp Top là cách Salt ánh xạ các trạng thái đến các minion mà chúng sẽ được áp dụng.

3.Trong cùng một tệp, bỏ chú thích ở phần gitfs_remoteskhai báo và nhập URL kho lưu trữ công thức Salt của bạn:

gitfs_remotes:
  - https://github.com/your_github_user/hugo-webserver-salt-formula.git

4.Bỏ chú thích cho gitfs_providerphần khai báo và đặt giá trị của nó thành gitpython:

gitfs_provider: gitpython

Áp dụng trạng thái của công thức cho Minion

1.Trong /etc/salt/master, bỏ chú thích ở phần file_rootskhai báo và đặt các giá trị sau:

file_roots:
  base:
    - /srv/salt/

file_rootschỉ rõ nơi lưu trữ các tệp trạng thái trên hệ thống tệp của Master. Điều này được tham chiếu khi - rootsđược khai báo trong fileserver_backendphần. tham chiếu đến môi trườngbase Salt , là cây các tệp trạng thái có thể áp dụng cho minion. Hướng dẫn này sẽ chỉ sử dụng môi trường, nhưng có thể tạo các môi trường khác cho mục đích phát triển, QA, v.v.base

2.Khởi động lại Salt trên máy chủ chính để kích hoạt các thay đổi trong /etc/salt/master:

sudo systemctl restart salt-master

3.Tạo /srv/saltthư mục trên máy chủ Salt:

sudo mkdir /srv/salt

4.Tạo một tập tin mới top.slstrong /srv/salt:

base:
  'hugo-webserver':
    - hugo

Đây là tệp Top của Salt và đoạn mã này tuyên bố rằng hugo-webserverminion sẽ nhận init.slstrạng thái từ hugothư mục (từ công thức Salt do GitHub lưu trữ của bạn).

5.Yêu cầu Salt áp dụng trạng thái từ tệp Top vào minion:

sudo salt 'hugo-webserver' state.apply

Salt as tham chiếu lệnh này như một highstate . Chạy highstate có thể mất một chút thời gian để hoàn tất và đầu ra của lệnh sẽ mô tả những hành động nào đã được thực hiện trên minion. Đầu ra cũng sẽ hiển thị nếu bất kỳ hành động nào không thành công.

6.Nếu bạn truy cập tên miền của mình trên trình duyệt web, bây giờ bạn sẽ thấy trang thử nghiệm mặc định của NGINX do Salt minion cung cấp.

Khởi tạo trang Hugo

1.Trên máy tính của bạn, hãy tạo một trang Hugo mới. Đảm bảo rằng bạn không chạy lệnh này trong hugo-webserver-salt-formulathư mục của mình:

hugo new site example-hugo-site

2.Điều hướng đến thư mục trang web Hugo mới và khởi tạo kho lưu trữ Git:

cd example-hugo-site
git init

3.Cài đặt một chủ đề vào themes/thư mục. Hướng dẫn này sử dụng chủ đề Cactus :

git submodule add https://github.com/digitalcraftsman/hugo-cactus-theme.git themes/hugo-cactus-theme

4.Chủ đề đi kèm với một số nội dung ví dụ. Sao chép nó vào gốc trang web của bạn để có thể xem:

cp -r themes/hugo-cactus-theme/exampleSite/ .

5.Chỉnh sửa các tùy chọn baseurl, themesDir, và như sau; thay thế bằng tên miền và tên của riêng bạn:nameconfig.tomlexample.comYour Name

# [...]
baseURL = "http://example.com"
# [...]
themesDir = "themes"
# [...]
  name = "Your Name"

6.Chạy máy chủ phát triển Hugo trên máy tính của bạn:

hugo server

Đầu ra của lệnh này sẽ kết thúc bằng một dòng như sau:

Web Server is available at http://localhost:1313/ (bind address 127.0.0.1)

7.Nếu bạn xem URL từ đầu ra này trong trình duyệt, bạn có thể thấy trang Hugo mới của mình:

8.Nhập CTRL-C vào phiên terminal trên máy tính của bạn để dừng máy chủ phát triển Hugo. Mở tệp .gitignorevà đảm bảo public/được liệt kê. Mặc định .gitignoretừ chủ đề Cactus sẽ trông như sau:

public/
themes

Thư publicmục là kết quả của việc Hugo biên dịch các tệp nội dung Markdown thành HTML. Những tệp này có thể được tạo lại bởi bất kỳ ai tải xuống mã trang web của bạn, vì vậy chúng sẽ không được kiểm tra trong kiểm soát phiên bản.

Đẩy trang Hugo lên GitHub

1.Trong thư mục site Hugo, hãy xác nhận các tệp site mới:

git add .
git commit -m "Initial commit"

2.Tạo một kho lưu trữ công khai mới trên GitHub có tên là example-hugo-sitevà sao chép URL HTTPS của kho lưu trữ.

3.Trong thư mục trang web, thêm kho lưu trữ GitHub làm kho lưu origintrữ từ xa và đẩy các tệp mới của bạn vào đó; thay thế github-usernamebằng người dùng GitHub của bạn:

git remote add origin https://github.com/github-username/example-hugo-site.git
git push -u origin master

Triển khai trang Hugo

Công thức của Salt minion cần được cập nhật để phục vụ cho trang Hugo. Cụ thể, công thức sẽ cần có các trạng thái sau:

Cài đặt Git và sao chép kho lưu trữ trang web Hugo từ GitHub.
Cài đặt Hugo và xây dựng các tệp HTML từ nội dung Markdown.
Cập nhật cấu hình NGINX để phục vụ cho trang web đã xây dựng.

Một số thành phần trạng thái mới sẽ tham chiếu đến dữ liệu được lưu trữ trong Salt Pillar . Pillar là hệ thống Salt lưu trữ dữ liệu riêng tư và các tham số khác mà bạn không muốn liệt kê trong công thức của mình. Dữ liệu Pillar sẽ được lưu dưới dạng tệp trên Salt master và không được kiểm tra trong kiểm soát phiên bản.

Ghi chú: Có những phương pháp để kiểm tra dữ liệu này một cách an toàn vào kiểm soát phiên bản hoặc sử dụng các chương trình phụ trợ khác để lưu trữ dữ liệu, nhưng những chiến lược đó nằm ngoài phạm vi của hướng dẫn này.

Dữ liệu trụ cột được đưa vào các tệp trạng thái với tính năng tạo mẫu Jinja của Salt . Các tệp trạng thái đầu tiên được đánh giá dưới dạng mẫu Jinja và sau đó là YAML.

Cài đặt Git và Hugo

Trong kho lưu trữ công thức Salt cục bộ của bạn, hãy chỉnh sửa install.slstệp để thêm git_pkgvà hugo_pkgcác trạng thái:

# [...]

git_pkg:
  pkg.installed:
    - name: git

hugo_pkg:
  pkg.installed:
    - name: hugo
    - sources:
      - hugo: https://github.com/gohugoio/hugo/releases/download/v{{ pillar['hugo_deployment_data']['hugo_version'] }}/hugo_{{ pillar['hugo_deployment_data']['hugo_version'] }}_Linux-64bit.deb

Thành phần trạng thái đầu tiên cài đặt Git và thành phần thứ hai cài đặt Hugo. sourcesKhai báo của thành phần thứ hai chỉ định rằng gói phải được tải xuống từ kho lưu trữ GitHub của Hugo (thay vì từ trình quản lý gói phân phối).

Cú {{ }}pháp xuất hiện trong {{ pillar['hugo_deployment_data']['hugo_version'] }}là câu lệnh thay thế Jinja. pillar['hugo_deployment_data']['hugo_version']trả về giá trị của hugo_versionkhóa từ một từ điển có tên hugo_deployment_datatrong Pillar. Giữ phiên bản Hugo trong Pillar cho phép bạn cập nhật Hugo mà không cần cập nhật công thức của mình.

Sao chép kho lưu trữ Git của Hugo Site

Tạo một config.slstệp mới trong hugothư mục kho lưu trữ công thức Salt cục bộ của bạn:

hugo_group:
  group.present:
    - name: {{ pillar['hugo_deployment_data']['group'] }}

hugo_user:
  user.present:
    - name: {{ pillar['hugo_deployment_data']['user'] }}
    - gid: {{ pillar['hugo_deployment_data']['group'] }}
    - home: {{ pillar['hugo_deployment_data']['home_dir'] }}
    - createhome: True
    - require:
      - group: hugo_group

hugo_site_repo:
  cmd.run:
    - name: git clone --recurse-submodules https://github.com/{{ pillar['hugo_deployment_data']['github_account'] }}/{{ pillar['hugo_deployment_data']['site_repo_name'] }}.git
    - cwd: {{ pillar['hugo_deployment_data']['home_dir'] }}
    - runas: {{ pillar['hugo_deployment_data']['user'] }}
    - creates: {{ pillar['hugo_deployment_data']['home_dir'] }}/{{ pillar['hugo_deployment_data']['site_repo_name'] }}
    - require:
      - pkg: git_pkg
      - user: hugo_user

Thành phần cuối cùng hugo_site_repotrong đoạn mã này chịu trách nhiệm sao chép kho lưu trữ trang Hugo mẫu từ GitHub. Kho lưu trữ được sao chép này được đặt trong thư mục gốc của người dùng hệ thống mà Salt tạo ra trong các thành phần trước đó. Lệnh sao chép cũng tải xuống đệ quy mô-đun phụ chủ đề Cactus.

Ghi chú: Tuyên - createsbố cho Salt biết rằng chạy cmdmô-đun lệnh sẽ dẫn đến việc tạo tệp được chỉ định. Nếu trạng thái được áp dụng lại sau đó, Salt sẽ kiểm tra xem tệp đó đã tồn tại chưa. Nếu tồn tại, Salt sẽ không chạy lại mô-đun.

Các requirekhai báo trong mỗi thành phần đảm bảo rằng:

Bản sao sẽ không được chạy cho đến khi người dùng hệ thống và thư mục chính được tạo và cho đến khi gói phần mềm Git được cài đặt.
Người dùng sẽ không được tạo cho đến khi nhóm mà người dùng đó thuộc về được tạo.

Thay vì mã hóa cứng các tham số cho người dùng, nhóm, thư mục chính, tài khoản GitHub và tên kho lưu trữ, những thông tin này sẽ được lấy từ Pillar.

Cấu hình NGINX

1.Thêm các trạng thái sau vào config.sls:

nginx_default:
  file.absent:
    - name: '/etc/nginx/sites-enabled/default'
    - require:
      - pkg: nginx_pkg

nginx_config:
  file.managed:
    - name: /etc/nginx/sites-available/hugo_site
    - source: salt://hugo/files/hugo_site
    - user: root
    - group: root
    - mode: 0644
    - template: jinja
    - require:
      - pkg: nginx_pkg

nginx_symlink:
  file.symlink:
    - name: /etc/nginx/sites-enabled/hugo_site
    - target: /etc/nginx/sites-available/hugo_site
    - user: root
    - group: root
    - require:
      - file: nginx_config

nginx_document_root:
  file.directory:
    - name: {{ pillar['hugo_deployment_data']['nginx_document_root'] }}/{{ pillar['hugo_deployment_data']['site_repo_name'] }}
    - user: {{ pillar['hugo_deployment_data']['user'] }}
    - group: {{ pillar['hugo_deployment_data']['group'] }}
    - dir_mode: 0755
    - require:
      - user: hugo_user

Thành phần này nginx_defaultxóa liên kết tượng trưng sites-enabledcho cấu hình NGINX mặc định, vô hiệu hóa cấu hình đó.
nginx_configvà nginx_symlinksau đó tạo một tệp cấu hình mới trong sites-availablevà một liên kết tượng trưng đến tệp đó trong sites-enabled.
Thành phần này nginx_document_roottạo thư mục mà NGINX sẽ dùng để lưu trữ các tệp trang Hugo của bạn (khi điền dữ liệu Pillar, thư mục này sẽ trông như thế này /var/www/example-hugo-site).

2.Tuyên - source: salt://hugo/files/hugo_sitebố trong nginx_configtham chiếu đến tệp cấu hình NGINX hiện chưa có trong kho lưu trữ của bạn. Tạo thư files/mục:

cd ~/hugo-webserver-salt-formula/hugo
mkdir files

3.Tạo hugo_sitetập tin bên trong files/:

server {
    listen 80;
    listen [::]:80;
    server_name {{ pillar['hugo_deployment_data']['domain_name'] }};

    root {{ pillar['hugo_deployment_data']['nginx_document_root'] }}/{{ pillar['hugo_deployment_data']['site_repo_name'] }};

    index index.html index.htm index.nginx-debian.html;

    location / {
        try_files $uri $uri/ = /404.html;
    }
}

Thành nginx_configphần quản lý tệp này cũng liệt kê - template: jinjakhai báo, do đó tệp nguồn được diễn giải là mẫu Jinja. Tệp nguồn có thể thay thế các giá trị từ Pillar bằng cú pháp thay thế Jinja.

4.Thay thế nội dung của bạn service.slsbằng đoạn trích này:

nginx_service:
  service.running:
    - name: nginx
    - enable: True
    - require:
      - file: nginx_symlink
    - watch:
      - file: nginx_config

Thành phần này nginx_servicehiện yêu cầu nginx_symlinkthay vì nginx_pkg. Nếu không có thay đổi này, dịch vụ có thể được bật và chạy trước khi cấu hình NGINX mới được thiết lập. - watchTuyên bố này cũng hướng dẫn NGINX khởi động lại bất cứ khi nào có thay đổi được nginx_configthực hiện.

Xây dựng Hugo

1.Thêm build_scripttrạng thái vào config.sls:

build_script:
  file.managed:
    - name: {{ pillar['hugo_deployment_data']['home_dir'] }}/deploy.sh
    - source: salt://hugo/files/deploy.sh
    - user: {{ pillar['hugo_deployment_data']['user'] }}
    - group: {{ pillar['hugo_deployment_data']['group'] }}
    - mode: 0755
    - template: jinja
    - require:
      - user: hugo_user
  cmd.run:
    - name: ./deploy.sh
    - cwd: {{ pillar['hugo_deployment_data']['home_dir'] }}
    - runas: {{ pillar['hugo_deployment_data']['user'] }}
    - creates: {{ pillar['hugo_deployment_data']['nginx_document_root'] }}/{{ pillar['hugo_deployment_data']['site_repo_name'] }}/index.html
    - require:
      - file: build_script
      - cmd: hugo_site_repo
      - file: nginx_document_root

Trạng thái này sử dụng nhiều hơn một mô-đun. Mô-đun đầu tiên sẽ tải xuống tệp deploy.shtừ salt master và đặt tệp đó vào minion. Tập lệnh này sẽ chịu trách nhiệm biên dịch các tệp trang web Hugo của bạn. Sau đó, mô-đun thứ hai gọi tập lệnh đó. Mô-đun đầu tiên được liệt kê là yêu cầu của mô-đun thứ hai, cùng với lệnh Git clone và việc tạo thư mục gốc của tài liệu

Ghi chú: Tùy - createschọn trong mô-đun thứ hai đảm bảo rằng Salt không xây dựng lại Hugo nếu trạng thái được áp dụng lại cho minion.

2.Tạo deploy.shtập lệnh trong files/:

#!/bin/bash

cd {{ pillar['hugo_deployment_data']['site_repo_name'] }}
hugo --destination={{ pillar['hugo_deployment_data']['nginx_document_root'] }}/{{ pillar['hugo_deployment_data']['site_repo_name'] }}

Hàm xây dựng của Hugo được gọi với gốc tài liệu NGINX là đích đến cho các tệp được xây dựng.

3.Cập nhật init.slsđể bao gồm tệp mới config.sls:

include:
  - hugo.install
  - hugo.config
  - hugo.service

Đẩy các bản cập nhật công thức Salt lên GitHub

Tệp trạng thái của bạn bây giờ sẽ có những nội dung sau: init.sls , install.sls , config.sls , service.sls .

Các tập tin có trong kho lưu trữ công thức Salt của bạn phải là:

hugo
├── config.sls
├── files
│   ├── deploy.sh
│   └── hugo_site
├── init.sls
├── install.sls
└── service.sls

1.Sắp xếp tất cả các thay đổi bạn đã thực hiện đối với tệp công thức Salt cục bộ của mình theo các bước trước đó, sau đó xác nhận các thay đổi:

cd ~/hugo-webserver-salt-formula
git add .
git commit -m "Deploy the Hugo site"

2.Đẩy cam kết vào kho lưu trữ GitHub của bạn:

git push origin master

Tạo Salt Pillar File

1.Mở /etc/salt/mastertrên Salt master trong trình soạn thảo văn bản. Bỏ chú thích pillar_rootsphần:

pillar_roots:
  base:
    - /srv/pillar

pillar_rootsthực hiện chức năng tương tự như file_roots: nó chỉ định nơi dữ liệu Pillar được lưu trữ trên hệ thống tập tin của máy chủ.

2.Khởi động lại Salt trên máy chủ chính để kích hoạt các thay đổi trong /etc/salt/master:

sudo systemctl restart salt-master

3.Tạo /srv/pillarthư mục trên máy chủ Salt:

sudo mkdir /srv/pillar

4.Tạo một example-hugo-site.slstệp /srv/pillarđể chứa dữ liệu Pillar cho minion. Tệp này sử dụng cú pháp YAML giống như các tệp trạng thái khác. Thay thế các giá trị cho github_accountvà domain_namebằng tài khoản GitHub và tên miền của trang web của bạn:

hugo_deployment_data:
  hugo_version: 0.49
  group: hugo
  user: hugo
  home_dir: /home/hugo
  github_account: your_github_user
  site_repo_name: example-hugo-site
  nginx_document_root: /var/www
  domain_name: yourdomain.com

5.Tạo một top.slstệp trong /srv/pillar. Tương tự như tệp Top trong cây trạng thái của bạn, tệp Top của Pillar ánh xạ dữ liệu Pillar thành các minion:

base:
  'hugo-webserver':
    - example-hugo-site

Áp dụng Cập nhật trạng thái cho Minion

Trên Salt master, áp dụng trạng thái mới cho tất cả minion:

sudo salt '*' state.apply

Ghi chú: Trong hướng dẫn này chỉ có một minion, nhưng Salt có thể sử dụng globbing theo kiểu shell và biểu thức chính quy để khớp với ID minion khi bạn có nhiều hơn một. Ví dụ, lệnh này sẽ chạy highstate trên tất cả các minion có ID bắt đầu bằng hugo:

sudo salt 'hugo*' state.apply

Nếu không có thay đổi nào được thực hiện, hãy thử tải thủ công các bản cập nhật công thức Salt từ GitHub rồi chạy state.applylại lệnh:

sudo salt-run fileserver.update

Khi quá trình hoàn tất, trang Hugo của bạn sẽ hiển thị trên tên miền của bạn.

Triển khai Cập nhật Trang web bằng Webhooks

Trang web của bạn hiện đã được triển khai để sản xuất, nhưng vẫn chưa có cơ chế tự động nào để cập nhật máy chủ sản xuất khi bạn cập nhật nội dung trang web Hugo của mình. Để cập nhật máy chủ sản xuất, minion của bạn sẽ cần:

Kéo những thay đổi mới nhất được đẩy lên masternhánh kho lưu trữ trang Hugo của bạn trên GitHub.
Chạy quy trình xây dựng Hugo với nội dung mới.

Có thể thay đổi tập deploy.shlệnh để kéo các thay đổi từ GitHub. Những thay đổi tập lệnh này sẽ được thực hiện trong kho lưu trữ công thức Salt. Sau đó, chúng tôi sẽ thiết lập webhooks để thông báo cho minion Salt rằng các bản cập nhật đã được thực hiện cho trang web Hugo.

Webhooks là các yêu cầu HTTP POST được thiết kế và gửi bởi các hệ thống để truyền đạt một số loại sự kiện quan trọng. Máy chủ webhook lắng nghe các yêu cầu này và sau đó thực hiện một số hành động khi nhận được yêu cầu. Ví dụ: kho lưu trữ GitHub có thể được cấu hình để gửi thông báo webhook bất cứ khi nào có lệnh đẩy đến kho lưu trữ. Đây là loại thông báo mà chúng ta sẽ cấu hình và minion Salt sẽ chạy máy chủ webhook để nhận chúng. Các thông báo sự kiện khác cũng có thể được thiết lập trên GitHub.

Thiết lập máy chủ Webhook trên Salt Minion

1.Trong kho lưu trữ công thức Salt cục bộ của bạn, hãy thêm webhook_pkgtrạng thái mới vào install.slsđể cài đặt gói máy chủ webhook theo adnanh :

webhook_pkg:
  pkg.installed:
    - name: webhook

Ghi chú: Máy chủ webhook được adnanh viết bằng Go là một triển khai phổ biến của khái niệm này, nhưng vẫn có thể viết các máy chủ HTTP khác để phân tích cú pháp tải trọng webhook.

2.Thêm hai thành phần mới vào config.sls:

webhook_systemd_unit:
  file.managed:
    - name: '/etc/systemd/system/webhook.service'
    - source: salt://hugo/files/webhook.service
    - user: root
    - group: root
    - mode: 0644
    - template: jinja
    - require:
      - pkg: webhook_pkg
  module.run:
    - name: service.systemctl_reload
    - onchanges:
      - file: webhook_systemd_unit

webhook_config:
  file.managed:
    - name: '/etc/webhook.conf'
    - source: salt://hugo/files/webhook.conf
    - user: root
    - group: {{ pillar['hugo_deployment_data']['group'] }}
    - mode: 0640
    - template: jinja
    - require:
      - pkg: webhook_pkg
      - group: hugo_group

Trạng thái đầu tiên tạo tệp đơn vị systemd cho dịch vụ webhook. Trạng thái thứ hai tạo cấu hình webhook. Máy chủ webhook đọc cấu hình và tạo URL webhook từ đó.

3.Tạo một webhook.servicetệp trong thư mục kho lưu trữ của bạn files/:

[Unit]
Description=Small server for creating HTTP endpoints (hooks)
Documentation=https://github.com/adnanh/webhook/

[Service]
User={{ pillar['hugo_deployment_data']['user'] }}
ExecStart=/usr/bin/webhook -nopanic -hooks /etc/webhook.conf

[Install]
WantedBy=multi-user.target

4.Tạo một webhook.conftệp trong thư mục kho lưu trữ của bạn files/:

[
  {
    "id": "github_push",
    "execute-command": "{{ pillar['hugo_deployment_data']['home_dir'] }}/deploy.sh",
    "command-working-directory": "{{ pillar['hugo_deployment_data']['home_dir'] }}",
    "trigger-rule":
    {
      "and":
      [
        {
          "match":
          {
            "type": "payload-hash-sha1",
            "secret": "{{ pillar['hugo_deployment_data']['webhook_secret'] }}",
            "parameter":
            {
              "source": "header",
              "name": "X-Hub-Signature"
            }
          }
        },
        {
          "match":
          {
            "type": "value",
            "value": "refs/heads/master",
            "parameter":
            {
              "source": "payload",
              "name": "ref"
            }
          }
        }
      ]
    }
  }
]

Cấu hình này thiết lập một URL có tên là http://example.com:9000/hooks/github_push, trong đó thành phần cuối cùng của URL được lấy từ giá trị của cấu hình id.

Ghi chú: Máy chủ webhook chạy trên cổng 9000 và đặt webhook của bạn bên trong một hooks/thư mục theo mặc định.

Khi yêu cầu POST được gửi đến URL:

Máy chủ webhook kiểm tra xem dữ liệu tiêu đề và dữ liệu tải trọng từ yêu cầu có đáp ứng các quy tắc trong trigger-ruletừ điển hay không, đó là:
- Mã băm SHA1 của bí mật webhook của máy chủ khớp với bí mật trong tiêu đề yêu cầu. Điều này ngăn những người không biết bí mật webhook của bạn kích hoạt hành động của webhook.
- Tham refsố trong payload khớp với refs/heads/master. Điều này đảm bảo rằng chỉ có các lệnh đẩy đến masternhánh mới kích hoạt hành động.
Nếu các quy tắc được đáp ứng, lệnh được liệt kê trong đó execute-commandsẽ được chạy, đó chính là deploy.shtập lệnh.

Ghi chú: Bạn có thể xem thêm tài liệu về các tùy chọn cấu hình webhook trên kho lưu trữ GitHub của dự án .

5.Thêm trạng thái mới webhook_servicevào trạng service.slsthái cho phép và khởi động máy chủ webhook:

webhook_service:
  service.running:
    - name: webhook
    - enable: True
    - watch:
      - file: webhook_config
      - module: webhook_systemd_unit

6.Cập nhật deploy.shtập lệnh để nó có thể lấy những thay đổi mastertrước khi xây dựng trang web:

#!/bin/bash

cd {{ pillar['hugo_deployment_data']['site_repo_name'] }}
git pull origin master
hugo --destination={{ pillar['hugo_deployment_data']['nginx_document_root'] }}//{{ pillar['hugo_deployment_data']['site_repo_name'] }}

7.Các tệp trạng thái của bạn bây giờ sẽ có các nội dung sau: init.sls (unchanged) , install.sls , config.sls , service.sls . Lưu các thay đổi đã thực hiện đối với các tệp Salt của bạn, sau đó cam kết và đẩy chúng lên GitHub:

cd ~/hugo-webserver-salt-formula
git add .
git commit -m "Webhook server states"
git push origin master

8.Trên Salt master, thêm a webhook_secretvào example-hugo-site.slsPillar. Bí mật của bạn phải là một chuỗi chữ số phức tạp, ngẫu nhiên.

hugo_deployment_data:
  # [...]
  webhook_secret: your_webhook_secret

9.Từ Salt master, áp dụng công thức cập nhật cho minion:

sudo salt-run fileserver.update
sudo salt 'hugo-webserver' state.apply

10.Máy chủ webhook của bạn bây giờ sẽ chạy trên minion. Nếu bạn chạy curltrên nó, bạn sẽ thấy:

curl http://example.com:9000/hooks/github_push

Hook rules were not satisfied.⏎

Cấu hình Webhook trên GitHub

Truy cập kho lưu trữ trang Hugo mẫu của bạn trên GitHub và điều hướng đến phần Webhooks của tab Cài đặt . Nhấp vào nút Thêm webhook :
Điền vào mẫu:
- Nhập http://example.com:9000/hooks/github_pushURL tải trọng (thay thế example.combằng tên miền của bạn).
- Chọn application/jsonloại nội dung.
- Dán bí mật webhook mà bạn đã thêm trước đó vào Salt Pillar.
Theo mặc định, webhook được cấu hình để thông báo về các sự kiện đẩy. Giữ nguyên tùy chọn này.
Nhấp vào nút Thêm webhook màu xanh lá cây để hoàn tất thiết lập.

Cập nhật trang web Hugo

1.Trong kho lưu trữ trang Hugo cục bộ của bạn, hãy tạo bài đăng mới bằng tính năng nguyên mẫu của Hugo :

hugo new post/test-post.md

2.Lệnh này tạo một tài liệu Markdown mới được điền một phần trong content/post/. Mở tệp này trong trình soạn thảo của bạn, xóa draft: truedòng khỏi frontmatter và thêm một số văn bản thân bài:

---
title: "Test Post"
date: 2018-10-19T11:39:15-04:00
---

Test post body text

3.Nếu bạn chạy hugo servertrong thư mục kho lưu trữ, bạn có thể thấy bài đăng mới:

4.Cam kết và đẩy bài đăng mới lên GitHub:

cd ~/example-hugo-site
git add .
git commit -m "Test post"
git push origin master

5.Truy cập tên miền của bạn trên trình duyệt; bài đăng thử nghiệm của bạn sẽ tự động xuất hiện.

Ghi chú

Nếu bài đăng của bạn không xuất hiện, hãy xem lại phần Giao hàng gần đây ở cuối trang cấu hình webhook của bạn trên GitHub:

Nếu bạn nhấp vào một lần giao hàng, thông tin đầy đủ về tiêu đề yêu cầu và tải trọng cũng như phản hồi của máy chủ sẽ được hiển thị và những thông tin này có thể cung cấp một số thông tin khắc phục sự cố. Chỉnh sửa tệp webhook.serviceđể khởi động dịch vụ ở chế độ chi tiết có thể hữu ích.

Các bước tiếp theo

Cấu hình Salt hiện tại có thể được sử dụng làm nền tảng cho các triển khai phức tạp hơn:

Lưu trữ nhiều trang web Hugo bằng cách cập nhật Pillar với nhiều kho lưu trữ GitHub khác.
Lưu trữ nhiều loại trang web tĩnh khác nhau bằng cách thay đổi công thức Salt để hỗ trợ chúng.
Cân bằng tải trang web của bạn bằng cách tạo thêm minion và áp dụng cùng dữ liệu Pillar và trạng thái Salt cho chúng. Sau đó, thiết lập NodeBalancer để hướng lưu lượng truy cập đến các minion.
Thiết lập nhánh phát triển và máy chủ phát triển riêng biệt với tính năng môi trường của Salt.

Thông tin thêm

Bạn có thể muốn tham khảo các nguồn sau để biết thêm thông tin về chủ đề này. Mặc dù chúng tôi cung cấp với hy vọng rằng chúng sẽ hữu ích, nhưng xin lưu ý rằng chúng tôi không thể đảm bảo tính chính xác hoặc tính kịp thời của các tài liệu được lưu trữ bên ngoài.

Nguồn: https://www.linode.com/docs/guides/automate-a-static-site-deployment-with-salt/