## Giới thiệu

Hệ thống quản lý cấu hình được thiết kế để hợp lý hóa quy trình kiểm soát số lượng lớn máy chủ, dành cho quản trị viên và nhóm vận hành. Chúng cho phép bạn điều khiển nhiều hệ thống khác nhau theo cách tự động từ một vị trí trung tâm.

Mặc dù có nhiều công cụ quản lý cấu hình phổ biến dành cho các hệ thống Linux, chẳng hạn như Chef và Puppet, nhưng những công cụ này thường phức tạp hơn mức nhiều người muốn hoặc cần. Ansible là một giải pháp thay thế tuyệt vời cho các tùy chọn này vì nó cung cấp một kiến trúc không yêu cầu cài đặt phần mềm đặc biệt trên các nút, sử dụng SSH để thực thi các tác vụ tự động hóa và các tệp YAML để xác định chi tiết cung cấp.

Trong hướng dẫn này, chúng ta sẽ thảo luận cách cài đặt Ansible trên máy chủ Ubuntu 20.04 và tìm hiểu một số điều cơ bản về cách sử dụng phần mềm này. Để biết tổng quan cấp cao hơn về Ansible dưới dạng công cụ quản lý cấu hình, vui lòng tham khảo Giới thiệu về quản lý cấu hình với Ansible.

## Điều kiện tiên quyết

Để làm theo hướng dẫn này, bạn sẽ cần:

* **Một Ansible Control Node**: Ansible Control Node là máy mà chúng tôi sẽ sử dụng để kết nối và kiểm soát các máy chủ Ansible qua SSH. Ansible Control Node của bạn có thể là máy cục bộ của bạn hoặc máy chủ dành riêng để chạy Ansible, mặc dù hướng dẫn này giả định rằng control node của bạn là một hệ thống Ubuntu 20.04. Đảm bảo rằng nút điều khiển có:

  - non-root user có đặc quyền sudo. Để thiết lập điều này, bạn có thể làm theo **Bước 2 và 3** trong Hướng dẫn thiết lập máy chủ ban đầu cho Ubuntu 20.04 của chúng tôi. Tuy nhiên, xin lưu ý rằng nếu bạn đang sử dụng máy chủ từ xa làm Ansible Control node, bạn nên làm theo **từng bước** của hướng dẫn này. Làm như vậy sẽ định cấu hình tường lửa trên máy chủ với `ufw` và cho phép truy cập bên ngoài vào hồ sơ non-root user của bạn, cả hai điều này sẽ giúp giữ an toàn cho máy chủ từ xa.
  - SSH keypair được liên kết với người dùng này. Để thiết lập tính năng này, bạn có thể làm theo **Bước 1** trong hướng dẫn của chúng tôi về Cách thiết lập khóa SSH trên Ubuntu 20.04.

* **Một hoặc nhiều Máy chủ Ansible**: Máy chủ Ansible là bất kỳ máy nào mà Ansible control node của bạn được định cấu hình để tự động hóa. Hướng dẫn này giả định rằng máy chủ Ansible của bạn là máy chủ Ubuntu 20.04 từ xa. Đảm bảo mỗi máy chủ Ansible có:
  * Đã thêm khóa công khai SSH của Ansible control node vào `authorized_keys` của system user. Người dùng này có thể là **root** hoặc người dùng thông thường có đặc quyền sudo. Để thiết lập tính năng này, bạn có thể làm theo **Bước 2** của Cách thiết lập khóa SSH trên Ubuntu 20.04.

## Bước 1 — Cài đặt Ansible

Để bắt đầu sử dụng Ansible như một phương tiện quản lý cơ sở hạ tầng máy chủ của bạn, bạn cần cài đặt phần mềm Ansible trên máy sẽ đóng vai trò là Ansible control node.

Từ nút điều khiển của bạn, hãy chạy lệnh sau để đưa PPA (kho lưu trữ gói cá nhân) của dự án chính thức vào danh sách nguồn của hệ thống:
```command
sudo apt-add-repository ppa:ansible/ansible
```

Nhấn `ENTER` khi được nhắc chấp nhận bổ sung PPA.

Tiếp theo, hãy làm mới chỉ mục gói của hệ thống để nó biết các gói có sẵn trong PPA mới được đưa vào:
```command
sudo apt update
```

Sau bản cập nhật này, bạn có thể cài đặt phần mềm Ansible với:
```command
sudo apt install ansible
```

Ansible control node của bạn hiện có tất cả phần mềm cần thiết để quản lý máy chủ của bạn. Tiếp theo, chúng ta sẽ tìm hiểu cách thêm máy chủ của bạn vào tệp inventory của control node để nó có thể kiểm soát chúng.

## Bước 2 — Thiết lập tệp inventory

*Tệp inventory* chứa thông tin về các máy chủ mà bạn sẽ quản lý bằng Ansible. Bạn có thể bao gồm từ một đến vài trăm máy chủ ở bất kỳ đâu trong tệp inventory của mình và các máy chủ có thể được tổ chức thành các nhóm và nhóm phụ. Tệp inventory cũng thường được sử dụng để đặt các biến chỉ hợp lệ cho các máy chủ hoặc nhóm cụ thể, để được sử dụng trong playbook và mẫu. Một số biến cũng có thể ảnh hưởng đến cách chạy playbook, chẳng hạn như biến `ansible_python_interpreter` mà chúng ta sẽ thấy trong giây lát.

Để chỉnh sửa nội dung của Ansible inventory mặc định của bạn, hãy mở tệp `/etc/ansible/hosts` bằng trình soạn thảo văn bản bạn chọn, trên Ansible control node của bạn:
```command
sudo nano /etc/ansible/hosts
```

<$>[note]
**Lưu ý:** Mặc dù Ansible thường tạo tệp inventory mặc định tại `etc/ansible/hosts`, nhưng bạn có thể tự do tạo tệp inventory ở bất kỳ vị trí nào phù hợp hơn với nhu cầu của mình. Trong trường hợp này, bạn sẽ cần cung cấp đường dẫn đến tệp inventory tùy chỉnh của mình với tham số `-i` khi chạy các lệnh và playbook Ansible. Sử dụng các tệp inventory cho mỗi dự án là một phương pháp hay để giảm thiểu rủi ro khi chạy playbook trên nhóm máy chủ không phù hợp.
<$>

Tệp inventory mặc định do cài đặt Ansible cung cấp chứa một số ví dụ mà bạn có thể sử dụng làm tài liệu tham khảo để thiết lập inventory của mình. Ví dụ sau xác định một nhóm có tên `[servers]` với ba máy chủ khác nhau trong đó, mỗi máy chủ được xác định bằng một bí danh tùy chỉnh: server1, server2, và server3. Đảm bảo thay thế các IP được đánh dấu bằng địa chỉ IP của máy chủ Ansible của bạn.

```nginx
[label /etc/ansible/hosts]
[servers]
server1 ansible_host=<^>203.0.113.111<^>
server2 ansible_host=<^>203.0.113.112<^>
server3 ansible_host=<^>203.0.113.113<^>

[all:vars]
ansible_python_interpreter=/usr/bin/python3
```

Nhóm phụ `all:vars` đặt tham số máy chủ `ansible_python_interpreter` sẽ hợp lệ cho tất cả các máy chủ có trong inventory này. Tham số này đảm bảo rằng máy chủ từ xa sử dụng tệp thực thi `/usr/bin/python3` Python 3 thay vì `/usr/bin/python` (Python 2.7), vốn không có trên các phiên bản Ubuntu gần đây.

Khi bạn hoàn tất, hãy lưu và đóng tệp bằng cách nhấn `CTRL+X` rồi nhấn `Y` và `ENTER` để xác nhận các thay đổi của bạn.

Bất cứ khi nào bạn muốn kiểm tra kho của mình, bạn có thể chạy:
```command
ansible-inventory --list -y
```

Bạn sẽ thấy đầu ra tương tự như thế này, nhưng chứa cơ sở hạ tầng máy chủ của riêng bạn như được xác định trong tệp inventory của bạn:
```
[secondary_label Output]
all:
  children:
    servers:
      hosts:
        server1:
          ansible_host: <^>203.0.113.111<^>
          ansible_python_interpreter: /usr/bin/python3
        server2:
          ansible_host: <^>203.0.113.112<^>
          ansible_python_interpreter: /usr/bin/python3
        server3:
          ansible_host: <^>203.0.113.113<^>
          ansible_python_interpreter: /usr/bin/python3
    ungrouped: {}
```

Bây giờ bạn đã định cấu hình tệp inventory của mình, bạn có mọi thứ cần thiết để kiểm tra kết nối với máy chủ Ansible của mình.

## Bước 3 — Kiểm tra kết nối

Sau khi thiết lập tệp inventory để bao gồm các máy chủ của bạn, đã đến lúc kiểm tra xem Ansible có thể kết nối với các máy chủ này và chạy lệnh qua SSH hay không.

Đối với hướng dẫn này, chúng tôi sẽ sử dụng tài khoản **root** của Ubuntu vì đó thường là tài khoản duy nhất có sẵn theo mặc định trên các máy chủ mới được tạo. Nếu máy chủ Ansible của bạn đã có người dùng sudo thông thường được tạo, bạn nên sử dụng tài khoản đó để thay thế.

Bạn có thể sử dụng đối số `-u` để chỉ định người dùng hệ thống từ xa. Khi không được cung cấp, Ansible sẽ cố gắng kết nối với tư cách là người dùng hệ thống hiện tại của bạn trên control node.

Từ máy cục bộ của bạn hoặc Ansible control node, hãy chạy:
```command
ansible all -m ping -u <^>root<^>
```

Lệnh này sẽ sử dụng mô-đun `ping` tích hợp của Ansible để chạy thử nghiệm kết nối trên tất cả các node từ kho lưu trữ mặc định của bạn, kết nối với quyền **root**. Mô-đun `ping` sẽ kiểm tra:

* nếu máy chủ có thể truy cập được;
* nếu bạn có thông tin đăng nhập SSH hợp lệ;
* nếu máy chủ có thể chạy các mô-đun Ansible bằng Python.

Bạn sẽ nhận được đầu ra tương tự như thế này:
```
[secondary_label Output]
server1 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
server2 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
server3 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
```

Nếu đây là lần đầu tiên bạn kết nối với các máy chủ này qua SSH, bạn sẽ được yêu cầu xác nhận tính xác thực của các máy chủ mà bạn đang kết nối qua Ansible. Khi được nhắc, hãy nhập `yes` rồi nhấn `ENTER` để xác nhận.

Sau khi bạn nhận được phản hồi `"pong"` từ máy chủ, điều đó có nghĩa là bạn đã sẵn sàng chạy các lệnh và playbook Ansible trên máy chủ đó.

<$>[note]
**Lưu ý:** Nếu bạn không thể nhận được phản hồi thành công từ máy chủ của mình, hãy kiểm tra Hướng dẫn về Bảng cheat Ansible của chúng tôi để biết thêm thông tin về cách chạy các lệnh Ansible với các tùy chọn kết nối khác nhau.
<$>

## Bước 4 — Chạy các lệnh Ad-Hoc (Tùy chọn)

Sau khi xác nhận rằng Ansible control node của bạn có thể giao tiếp với máy chủ của bạn, bạn có thể bắt đầu chạy các lệnh và playbook đặc biệt trên máy chủ của mình.

Bất kỳ lệnh nào bạn thường thực thi trên máy chủ từ xa qua SSH đều có thể chạy bằng Ansible trên máy chủ được chỉ định trong tệp inventory của bạn. Ví dụ: bạn có thể kiểm tra mức sử dụng đĩa trên tất cả các máy chủ bằng:
```command
ansible all -a "<^>df -h<^>" -u <^>root<^>
```

```
[secondary_label Output]
server1 | CHANGED | rc=0 >>
Filesystem      Size  Used Avail Use% Mounted on
udev            3.9G     0  3.9G   0% /dev
tmpfs           798M  624K  798M   1% /run
/dev/vda1       155G  2.3G  153G   2% /
tmpfs           3.9G     0  3.9G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           3.9G     0  3.9G   0% /sys/fs/cgroup
/dev/vda15      105M  3.6M  101M   4% /boot/efi
tmpfs           798M     0  798M   0% /run/user/0

server2 | CHANGED | rc=0 >>
Filesystem      Size  Used Avail Use% Mounted on
udev            2.0G     0  2.0G   0% /dev
tmpfs           395M  608K  394M   1% /run
/dev/vda1        78G  2.2G   76G   3% /
tmpfs           2.0G     0  2.0G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           2.0G     0  2.0G   0% /sys/fs/cgroup
/dev/vda15      105M  3.6M  101M   4% /boot/efi
tmpfs           395M     0  395M   0% /run/user/0

...
```

Lệnh được đánh dấu `df -h` có thể được thay thế bằng bất kỳ lệnh nào bạn muốn.

Bạn cũng có thể thực thi các mô-đun Ansible thông qua các lệnh đặc biệt, tương tự như những gì chúng tôi đã thực hiện trước đây với mô-đun `ping` để kiểm tra kết nối. Ví dụ: đây là cách chúng tôi có thể sử dụng mô-đun `apt` để cài đặt phiên bản `vim` mới nhất trên tất cả các máy chủ trong inventory của bạn:
```command
ansible all -m <^>apt<^> -a "name=<^>vim<^> state=latest" -u <^>root<^>
```

Bạn cũng có thể nhắm mục tiêu các máy chủ riêng lẻ, cũng như các nhóm và nhóm con khi chạy các lệnh Ansible. Chẳng hạn, đây là cách bạn kiểm tra `uptime` của mọi máy chủ trong nhóm `servers`:
```command
ansible <^>servers<^> -a "<^>uptime<^>" -u <^>root<^>
```

Chúng tôi có thể chỉ định nhiều máy chủ bằng cách tách chúng bằng dấu hai chấm:
```command
ansible <^>server1<^>:<^>server2<^> -m ping -u <^>root<^>
```

Để biết thêm thông tin về cách sử dụng Ansible, bao gồm cách thực thi playbooks để tự động thiết lập máy chủ, bạn có thể xem Hướng dẫn tham khảo Ansible của chúng tôi.

## Kết luận

Trong hướng dẫn này, bạn đã cài đặt Ansible và thiết lập tệp inventory để thực thi các lệnh đặc biệt từ Ansible Control Node.

Khi bạn đã xác nhận rằng bạn có thể kết nối và điều khiển cơ sở hạ tầng của mình từ máy điều khiển Ansible trung tâm, bạn có thể thực thi bất kỳ lệnh hoặc playbook nào bạn muốn trên các máy chủ đó.

Để biết thêm thông tin về cách sử dụng Ansible, hãy xem Hướng dẫn bảng cheat Ansible của chúng tôi.

Cách cài đặt và định cấu hình Ansible trên Ubuntu 20.04

## Giới thiệu

Tự động hóa máy chủ hiện đóng một vai trò thiết yếu trong quản trị hệ thống, do tính chất dùng một lần của môi trường ứng dụng hiện đại. Các công cụ quản lý cấu hình như Ansible thường được sử dụng để hợp lý hóa quy trình tự động hóa thiết lập máy chủ bằng cách thiết lập các quy trình chuẩn cho máy chủ mới, đồng thời giảm lỗi do con người liên quan đến thiết lập thủ công.

Ansible cung cấp một kiến trúc đơn giản không yêu cầu cài đặt phần mềm đặc biệt trên các node. Nó cũng cung cấp một bộ tính năng mạnh mẽ và các mô-đun tích hợp giúp tạo điều kiện thuận lợi cho việc viết các tập lệnh tự động hóa.

Hướng dẫn này giải thích cách sử dụng Ansible để tự động hóa các bước có trong Hướng dẫn thiết lập máy chủ ban đầu cho máy chủ Ubuntu 20.04 của chúng tôi.

## Điều kiện tiên quyết

Để thực hiện thiết lập tự động do playbook cung cấp trong hướng dẫn này, bạn sẽ cần:

* **Một Ansible control node**: một máy Ubuntu 20.04 được cài đặt và định cấu hình Ansible để kết nối với các máy chủ Ansible của bạn bằng các SSH key. Đảm bảo control node có người dùng thông thường với đặc quyền sudo và bật tường lửa, như được giải thích trong hướng dẫn Thiết lập Máy chủ Ban đầu của chúng tôi. Để thiết lập Ansible, vui lòng làm theo hướng dẫn của chúng tôi về Cách cài đặt và định cấu hình Ansible trên Ubuntu 20.04.
* **Một máy chủ từ xa có bản cài đặt Ubuntu 20.04 mới**: không yêu cầu thiết lập trước trên máy chủ này, nhưng bạn phải có quyền truy cập SSH vào máy chủ này từ Ansible control node đã đề cập ở trên. Máy chủ này sẽ trở thành một máy chủ lưu trữ từ xa Ansible, được nhắm mục tiêu để cung cấp tự động bởi Ansible control node.

## Playbook này làm gì?

Playbook Ansible này cung cấp giải pháp thay thế cho việc chạy thủ công quy trình được nêu trong hướng dẫn thiết lập máy chủ ban đầu Ubuntu 20.04 và hướng dẫn thiết lập SSH key trên Ubuntu 20.04 mỗi khi bạn khởi động máy chủ. Thiết lập playbook của bạn một lần và sử dụng nó cho mọi máy chủ sau đó.

Chạy playbook này sẽ thực hiện các tác vụ sau trên máy chủ Ansible của bạn:

1. Cài đặt `aptitude`, được Ansible ưa thích như một giải pháp thay thế cho trình quản lý gói `apt`.
2. Tạo người dùng **sudo** mới và thiết lập `sudo` không mật khẩu.
3. Sao chép SSH public key cục bộ và đưa nó vào tệp `authorized_keys` cho người dùng quản trị mới trên máy chủ từ xa.
4. Vô hiệu hóa xác thực dựa trên mật khẩu cho **root** user.
5. Cài đặt các gói hệ thống.
6. Định cấu hình tường lửa UFW để chỉ cho phép các kết nối SSH và từ chối mọi yêu cầu khác.

Sau khi playbook chạy xong, bạn sẽ có một người dùng mới mà bạn có thể sử dụng để đăng nhập vào máy chủ.

Để bắt đầu, hãy đăng nhập vào người dùng đã bật `sudo` trên máy chủ Ansible control node của bạn.

## Bước 1 — Chuẩn bị Ansible control node của bạn

Trên máy chủ Ansible control node của bạn, hãy thêm IP của máy chủ lưu trữ từ xa Ansible vào tệp Ansible inventory của bạn. Sử dụng trình soạn thảo văn bản ưa thích của bạn:
```command
sudo nano /etc/ansible/hosts
```

Thao tác này sẽ mở tệp Ansible inventory của bạn. Thêm IP của máy chủ lưu trữ từ xa Ansible của bạn vào khối `[servers]`:
```nginx
[label /etc/ansible/hosts]
[servers]
<^>server1<^> ansible_host=<^>your_remote_server_ip<^>

. . .
```

Bây giờ, bạn sẽ kiểm tra và xác thực kết nối SSH giữa Ansible control node này và máy chủ lưu trữ từ xa Ansible của bạn:
```command
ssh root@<^>your_remote_server_ip<^>
```

Chấp nhận yêu cầu xác thực và nhập mật khẩu của bạn nếu được nhắc. Khi bạn đã xác minh kết nối SSH, hãy nhấn `CTRL+D` để đóng kết nối và quay lại control node của bạn.

## Bước 2 — Chuẩn bị Playbook của bạn

Tệp `playbook.yml` là nơi xác định tất cả các *task* của bạn. Task là đơn vị hành động nhỏ nhất mà bạn có thể tự động hóa bằng Playbook Ansible. Nhưng trước tiên, hãy tạo tệp playbook của bạn bằng trình soạn thảo văn bản ưa thích của bạn:
```command
nano playbook.yml
```

Điều này sẽ mở một tệp YAML trống. Trước khi đi sâu vào việc thêm các tác vụ vào playbook của bạn, hãy bắt đầu bằng cách thêm các mục sau:
```nginx
[label playbook.yml]
---
- hosts: all
  become: true
  vars:
    created_username: <^>sammy<^>
```

Vui lòng thay thế tên người dùng bằng một trong những lựa chọn của bạn.

Hầu hết mọi playbook bạn gặp sẽ bắt đầu với các khai báo tương tự như thế này. `hosts` tuyên bố máy chủ nào mà Ansible control node sẽ nhắm mục tiêu với playbook này. `become` cho biết liệu tất cả các lệnh sẽ được thực hiện với các đặc quyền gốc được nâng cấp hay không.

`vars` cho phép bạn lưu trữ dữ liệu trong các biến. Nếu bạn quyết định thay đổi tên người dùng này trong tương lai, bạn sẽ chỉ phải chỉnh sửa một dòng này trong tệp của mình.

<$>[note]
**Lưu ý:** Nếu bạn muốn xem tệp playbook ở trạng thái hoàn thiện cuối cùng, hãy chuyển sang Bước 8. Các tệp YAML có thể đặc biệt với cấu trúc thụt lề của chúng, vì vậy bạn có thể muốn kiểm tra lại playbook của mình sau khi bạn đã thêm tất cả các tác vụ của mình.
<$>

## Bước 3 — Thêm task cài đặt Aptitude vào Playbook của bạn

Theo mặc định, các task được Ansible thực thi đồng bộ theo thứ tự từ trên xuống dưới trong playbook của bạn. Điều này có nghĩa là thứ tự nhiệm vụ rất quan trọng và bạn có thể yên tâm cho rằng một nhiệm vụ sẽ hoàn thành việc thực thi trước khi nhiệm vụ tiếp theo bắt đầu.

Tất cả các nhiệm vụ trong playbook này có thể độc lập và được sử dụng lại trong các playbook khác của bạn.

Thêm nhiệm vụ đầu tiên của bạn là cài đặt `aptitude`, một công cụ để giao tiếp với trình quản lý gói Linux:
```nginx
[label playbook.yml]
tasks:
    - name: Install aptitude
      apt:
        name: aptitude
        state: latest
        update_cache: true
```

Tại đây, bạn đang sử dụng *mô-đun* tích hợp `apt` Ansible để hướng dẫn Ansible cài đặt `aptitude`. Các mô-đun trong Ansible là các phím tắt để thực thi các thao tác mà bạn sẽ phải chạy dưới dạng các lệnh bash thô. Ansible quay trở lại `apt` một cách an toàn để cài đặt các gói nếu `aptitude` không khả dụng. Vì vậy, trong khi bước này là tùy chọn về mặt kỹ thuật, thì Ansible Ansible trước đây đã ưu tiên `aptitude`.

## Bước 4 — Thêm tác vụ thiết lập người dùng Sudo vào Playbook của bạn

Đó là một thực hành tốt để tránh sử dụng rộng rãi **root** user. Bạn có thể tự động hóa việc tạo người dùng được cấp đặc quyền `sudo` bằng cách thêm:
```nginx
[label playbook.yml]
- name: Setup passwordless sudo
      lineinfile:
        path: /etc/sudoers
        state: present
        regexp: '^%sudo'
        line: '%sudo ALL=(ALL) NOPASSWD: ALL'
        validate: '/usr/sbin/visudo -cf %s' 

    - name: Create a new regular user with sudo privileges
      user:
        name: "{{ created_username }}"
        state: present
        groups: sudo
        append: true
        create_home: true
```

Bạn đang sử dụng mô-đun Ansible `lineinfile` để nhắm mục tiêu và thay thế một dòng cụ thể trong một tệp. Trong trường hợp này, bạn đang sử dụng regex để nhắm mục tiêu một dòng cụ thể trong tệp `sudoers`, sau đó sửa đổi nó để cho phép sử dụng `sudo` không cần mật khẩu. Bạn cũng sử dụng `visudo` để xác thực các thay đổi của mình nhằm ngăn mọi thứ bị hỏng.

Để tận dụng điều này, bạn sẽ thêm một người dùng mới với mô-đun `user`. Ansible sẽ đảm bảo người dùng này được tạo nếu chưa tồn tại, rằng người dùng thuộc về nhóm `sudo` trong khi không bị xóa khỏi các nhóm khác và một thư mục chính được tạo.

<$>[note]
**Lưu ý:** Đảm bảo bạn bao gồm các dấu ngoặc kép xung quanh dấu ngoặc nhọn biểu thị một biến. Việc bỏ qua các trích dẫn này là một lỗi cú pháp Ansible rất phổ biến.
<$>

## Bước 5 — Thêm thiết lập SSH key và vô hiệu hóa task mật khẩu gốc vào Playbook của bạn

Ansible hoạt động theo giả định rằng bạn đang sử dụng các SSH key. Chúng tôi thực sự khuyên bạn nên kết hợp việc sử dụng SSH key với việc vô hiệu hóa xác thực mật khẩu **gốc**. Để tự động hóa việc này, hãy thêm:
```nginx
[label playbook.yml]
- name: Set authorized key for remote user
      ansible.posix.authorized_key:
        user: "{{ created_username }}"
        state: present
        key: "{{ lookup('file', lookup('env','HOME') + '/.ssh/id_rsa.pub') }}"

    - name: Disable password authentication for root
      lineinfile:
        path: /etc/ssh/sshd_config
        state: present
        regexp: '^#?PermitRootLogin'
        line: 'PermitRootLogin prohibit-password'
```

Mô-đun `authorized_key` có thể được sử dụng nếu bạn cung cấp tên người dùng và vị trí của key. Tại đây, đường dẫn tới key của bạn được tạo bằng chức năng tra cứu của Ansible.

Mô-đun `lineinfile` được sử dụng để tìm kiếm và thay thế một dòng trong `sshd_config` nhằm vô hiệu hóa xác thực mật khẩu cho **root**, hạn chế quyền truy cập vào các đặc quyền của nó để tăng cường bảo mật.

## Bước 6 — Thêm task cài đặt gói vào Playbook của bạn

Ansible có thể đảm bảo các gói nhất định luôn được cài đặt trên máy chủ của bạn. Thay vì gọi `apt install` trên từng gói riêng lẻ hoặc chia nó thành nhiều tác vụ, bạn có thể liệt kê tất cả các gói mong muốn của mình:
```nginx
[label playbook.yml]
- name: Update apt and install required system packages
      apt:
        pkg:
          - curl
          - vim
          - git
          - ufw
        state: latest
        update_cache: true}
```

Bạn có thể thêm bớt các gói theo ý thích của mình. Điều này sẽ đảm bảo tất cả các gói không chỉ hiện diện mà còn trên phiên bản mới nhất và được thực hiện sau khi cập nhật với apt được gọi.

## Bước 7 — Thêm Task Thiết lập Tường lửa vào Playbook của bạn

Tường lửa là không thể thiếu đối với bất kỳ máy chủ nào đối mặt với internet. Bạn có thể có Ansible đảm bảo UFW (Uncomplicated Firewall) được định cấu hình đúng bằng cách thêm:
```nginx
[label playbook.yml]
- name: UFW - Allow SSH connections
      community.general.ufw:
        rule: allow
        name: OpenSSH

    - name: UFW - Enable and deny by default
      community.general.ufw:
        state: enabled
        default: deny
```

Mô-đun `ufw` trước tiên đảm bảo quyền truy cập SSH được cho phép thông qua. Sau đó, mô-đun này kích hoạt tường lửa của bạn trong khi mặc định từ chối tất cả lưu lượng truy cập khác đến máy chủ của bạn.

## Bước 8 — Xem lại toàn bộ Playbook của bạn

Playbook của bạn sẽ trông giống như sau, với những khác biệt nhỏ tùy thuộc vào các tùy chỉnh của bạn:
```nginx
[label playbook.yml]
---
- hosts: all
  become: true
  vars:
    created_username: sammy

  tasks:
    - name: Install aptitude
      apt:
        name: aptitude
        state: latest
        update_cache: true

    - name: Setup passwordless sudo
      lineinfile:
        path: /etc/sudoers
        state: present
        regexp: '^%sudo'
        line: '%sudo ALL=(ALL) NOPASSWD: ALL'
        validate: '/usr/sbin/visudo -cf %s'

    - name: Create a new regular user with sudo privileges
      user:
        name: "{{ created_username }}"
        state: present
        groups: sudo
        append: true
        create_home: true

    - name: Set authorized key for remote user
      ansible.posix.authorized_key:
        user: "{{ created_username }}"
        state: present
        key: "{{ lookup('file', lookup('env','HOME') + '/.ssh/id_rsa.pub') }}"

    - name: Disable password authentication for root
      lineinfile:
        path: /etc/ssh/sshd_config
        state: present
        regexp: '^#?PermitRootLogin'
        line: 'PermitRootLogin prohibit-password'

    - name: Update apt and install required system packages
      apt:
        pkg:
          - curl
          - vim
          - git
          - ufw
        state: latest
        update_cache: true

    - name: UFW - Allow SSH connections
      community.general.ufw:
        rule: allow
        name: OpenSSH

    - name: UFW - Enable and deny by default
      community.general.ufw:
        state: enabled
        default: deny
```

<$>[note]
**Lưu ý:** Đây là một lời nhắc nhở nhẹ nhàng để chú ý đến các vết lõm của bạn. Nếu bạn gặp lỗi, đây rất có thể là thủ phạm. YAML gợi ý sử dụng 2 dấu cách làm thụt lề, như đã được thực hiện trong ví dụ này.
<$>

Sau khi hài lòng với playbook của mình, bạn có thể thoát khỏi trình soạn thảo văn bản và lưu lại.

## Bước 9 — Chạy Playbook của bạn lần đầu tiên

Bây giờ bạn đã sẵn sàng để chạy cẩm nang này trên một hoặc nhiều máy chủ. Theo mặc định, hầu hết các sách giải trí đều được định cấu hình để thực thi trên mọi máy chủ trong kho của bạn, nhưng lần này bạn sẽ chỉ định máy chủ của mình.

Để chỉ thực thi playbook trên `<^>server1<^>`, kết nối với quyền `<^>root<^>`, bạn có thể sử dụng lệnh sau:
```command
ansible-playbook playbook.yml -l <^>server1<^> -u <^>root<^> -k
```

Cờ `-l` chỉ định máy chủ của bạn và cờ `-u` chỉ định người dùng nào sẽ đăng nhập trên máy chủ từ xa. Vì bạn chưa thiết lập máy chủ từ xa nên **root** là lựa chọn duy nhất của bạn. Cờ `-k` rất quan trọng trong lần chạy playbook đầu tiên của bạn, vì nó cho phép bạn nhập mật khẩu SSH của mình.

Bạn sẽ nhận được đầu ra tương tự như thế này:
```
[secondary_label Output]
. . .

TASK [UFW - Allow SSH connections] ***************************************************************************************************************************************************************************************************************************
changed: [server1]

TASK [UFW - Enable and deny by default] **********************************************************************************************************************************************************************************************************************
changed: [server1]

PLAY RECAP ***************************************************************************************************************************************************************************************************************************************************
server1                    : ok=9    changed=8    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

```

Điều này cho biết quá trình thiết lập máy chủ của bạn đã hoàn tất! Kết quả đầu ra của bạn không nhất thiết phải giống hệt nhau, nhưng điều quan trọng là bạn không có lỗi nào.

Bây giờ bạn đã thực hiện thiết lập đầu tiên cho playbook của mình, tất cả các cuộc gọi ansible tiếp theo có thể được thực hiện với người dùng `sammy` và không có cờ `-k`:
```command
ansible-playbook playbook.yml -l <^>server1<^> -u <^>sammy<^>
```

Bạn cũng có thể đăng nhập vào máy chủ bằng:
```command
ssh <^>sammy<^>@<^>your_remote_server_ip<^>
```

Hãy nhớ thay thế <^>sammy<^> bằng người dùng được xác định bởi biến `created_username` và <^>server_host_or_IP<^> bằng tên máy chủ hoặc địa chỉ IP của máy chủ của bạn.

Sau khi đăng nhập vào máy chủ, bạn có thể kiểm tra các quy tắc hoạt động của tường lửa UFW để xác nhận rằng nó được cấu hình đúng:
```command
sudo ufw status
```

Bạn sẽ nhận được đầu ra tương tự như thế này:
```
[secondary_label Output]
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
OpenSSH (v6)               ALLOW       Anywhere (v6)
```

Điều này có nghĩa là tường lửa UFW đã được kích hoạt thành công. Vì đây là task cuối cùng trong playbook, nên nó xác nhận rằng playbook đã được thực hiện đầy đủ trên máy chủ này.

## Kết luận

Tự động hóa thiết lập máy chủ ban đầu có thể giúp bạn tiết kiệm thời gian, đồng thời đảm bảo máy chủ của bạn sẽ tuân theo cấu hình tiêu chuẩn có thể được cải thiện và tùy chỉnh theo nhu cầu của bạn. Với bản chất phân tán của các ứng dụng hiện đại và nhu cầu nhất quán hơn giữa các môi trường dàn dựng khác nhau, việc tự động hóa như thế này trở nên cần thiết.

Trong hướng dẫn này, bạn đã trình bày cách sử dụng Ansible để tự động hóa các tác vụ ban đầu sẽ được thực thi trên một máy chủ mới, chẳng hạn như tạo non-**root** user với quyền truy cập `sudo`, bật UFW và vô hiệu hóa đăng nhập **root** dựa trên mật khẩu từ xa.

Để biết thêm thông tin về cách chạy Ansible playbooks, hãy xem Hướng dẫn về Ansible Cheat Sheet của chúng tôi.

Nếu bạn muốn đưa các tác vụ mới vào playbook này để tùy chỉnh thêm thiết lập máy chủ ban đầu của mình, vui lòng tham khảo hướng dẫn Ansible giới thiệu của chúng tôi Quản lý cấu hình 101: Viết Ansible Playbooks. Bạn cũng có thể xem hướng dẫn của chúng tôi về Cách sử dụng vai trò Ansible để trừu tượng hóa môi trường cơ sở hạ tầng của bạn.

Cách sử dụng Ansible để tự động thiết lập máy chủ ban đầu trên Ubuntu 20.04

Cách thiết lập Django với Postgres, Nginx và Gunicorn trên Ubuntu 20.04

Cách bảo vệ máy chủ Nginx với Fail2Ban trên Ubuntu 14.04

## Giới thiệu

Let's Encrypt là Tổ chức phát hành chứng chỉ (Certificate Authority  - CA) hỗ trợ lấy và cài đặt chứng chỉ TLS/SSL miễn phí, từ đó cho phép HTTPS được mã hóa trên các máy chủ web. Nó đơn giản hóa quy trình bằng cách cung cấp ứng dụng khách phần mềm, Certbot, cố gắng tự động hóa hầu hết (nếu không phải tất cả) các bước cần thiết. Hiện tại, toàn bộ quá trình lấy và cài đặt chứng chỉ hoàn toàn tự động trên cả Apache và Nginx.

Trong hướng dẫn này, chúng tôi sẽ sử dụng Certbot để lấy chứng chỉ SSL miễn phí cho Apache trên Ubuntu 20.04 và đảm bảo rằng chứng chỉ này được thiết lập để tự động gia hạn.

Hướng dẫn này sử dụng một tệp máy chủ ảo riêng biệt thay vì tệp cấu hình mặc định của Apache để thiết lập trang web sẽ được bảo mật bởi Let's Encrypt. Chúng tôi khuyên bạn nên tạo các tệp máy chủ ảo Apache mới cho mỗi miền được lưu trữ trong một máy chủ vì nó giúp tránh các lỗi phổ biến và duy trì các tệp cấu hình mặc định làm thiết lập dự phòng.

## Điều kiện tiên quyết

Để làm theo hướng dẫn này, bạn sẽ cần:

* Một máy chủ Ubuntu 20.04 được thiết lập bằng cách làm theo thiết lập máy chủ ban đầu này cho hướng dẫn Ubuntu 20.04, bao gồm sudo non-root user và tường lửa.
* Một tên miền được đăng ký đầy đủ. Hướng dẫn này sẽ sử dụng **your_domain** làm ví dụ xuyên suốt. 
* Cả hai bản ghi DNS sau được thiết lập cho máy chủ của bạn. 
1. Một bản ghi A với `<^>your_domain<^>` trỏ đến địa chỉ IP công cộng của máy chủ của bạn.
2. Một bản ghi A với `www.<^>your_domain<^>` trỏ đến địa chỉ IP công cộng của máy chủ của bạn.

Apache được cài đặt bằng cách làm theo Cách cài đặt Apache trên Ubuntu 20.04. Đảm bảo rằng bạn có tệp máy chủ ảo cho miền của mình. Hướng dẫn này sẽ sử dụng `/etc/apache2/sites-available/<^>your_domain<^>.conf` làm ví dụ.

## Bước 1 — Cài đặt Certbot

Để có được chứng chỉ SSL với Let's Encrypt, trước tiên chúng tôi cần cài đặt phần mềm Certbot trên máy chủ của bạn. Chúng tôi sẽ sử dụng kho lưu trữ gói Ubuntu mặc định cho điều đó.

Chúng tôi cần hai gói: `certbot` và `python3-certbot-apache`. Cái sau là một plugin tích hợp Certbot với Apache, giúp tự động lấy chứng chỉ và định cấu hình HTTPS trong máy chủ web của bạn bằng một lệnh duy nhất.
```command
sudo apt install certbot python3-certbot-apache
```

Bạn sẽ được nhắc xác nhận cài đặt bằng cách nhấn `Y`, sau đó `ENTER`.

Certbot hiện đã được cài đặt trên máy chủ của bạn. Trong bước tiếp theo, chúng tôi sẽ xác minh cấu hình của Apache để đảm bảo máy chủ ảo của bạn được đặt phù hợp. Điều này sẽ đảm bảo rằng tập lệnh máy khách `certbot` sẽ có thể phát hiện các miền của bạn và định cấu hình lại máy chủ web của bạn để tự động sử dụng chứng chỉ SSL mới được tạo.

## Bước 2 — Kiểm tra cấu hình máy chủ ảo Apache của bạn

Để có thể tự động lấy và định cấu hình SSL cho máy chủ web của bạn, Certbot cần tìm đúng máy chủ ảo trong các tệp cấu hình Apache của bạn. (Các) tên miền máy chủ của bạn sẽ được truy xuất từ các lệnh `ServerName` và `ServerAlias` được xác định trong khối cấu hình `VirtualHost` của bạn.

Nếu bạn đã làm theo bước thiết lập máy chủ ảo trong hướng dẫn cài đặt Apache, thì bạn nên thiết lập một khối VirtualHost cho miền của mình tại `/etc/apache2/sites-available/<^>your_domain<^>.conf` với `ServerName` và cả các lệnh `ServerAlias` đã được đặt thích hợp.

Để kiểm tra điều này, hãy mở tệp máy chủ ảo cho miền của bạn bằng cách sử dụng `nano` hoặc trình soạn thảo văn bản ưa thích của bạn:
```command
sudo nano /etc/apache2/sites-available/<^>your_domain<^>.conf
```

Tìm các dòng `ServerName` và `ServerAlias` hiện có. Chúng sẽ trông như thế này:
```nginx
[label /etc/apache2/sites-available/your_domain.conf]
...
ServerName <^>your_domain<^>
ServerAlias <^>www.your_domain<^>
...
```

Nếu bạn đã thiết lập `ServerName` và `ServerAlias` như thế này, bạn có thể thoát khỏi trình soạn thảo văn bản và chuyển sang bước tiếp theo. Nếu đang sử dụng `nano`, bạn có thể thoát bằng cách nhập `CTRL+X`, sau đó `Y` và `ENTER` để xác nhận.

Nếu cấu hình máy chủ ảo hiện tại của bạn không khớp với ví dụ, hãy cập nhật nó cho phù hợp. Khi bạn hoàn tất, hãy lưu tệp và thoát khỏi trình chỉnh sửa. Sau đó, chạy lệnh sau để xác thực các thay đổi của bạn:
```command
sudo apache2ctl configtest
```

Bạn sẽ nhận được `Syntax OK` dưới dạng phản hồi. Nếu bạn gặp lỗi, hãy mở lại tệp máy chủ ảo và kiểm tra xem có lỗi đánh máy hoặc thiếu ký tự nào không. Khi cú pháp của tệp cấu hình của bạn là chính xác, hãy tải lại Apache để các thay đổi có hiệu lực:
```command
sudo systemctl reload apache2
```

Với những thay đổi này, Certbot sẽ có thể tìm đúng khối VirtualHost và cập nhật nó.

Tiếp theo, chúng tôi sẽ cập nhật tường lửa để cho phép lưu lượng HTTPS.

## Bước 3 — Cho phép HTTPS qua Tường lửa

Nếu bạn đã bật tường lửa UFW, theo đề xuất của hướng dẫn điều kiện tiên quyết, thì bạn sẽ cần điều chỉnh cài đặt để cho phép lưu lượng HTTPS. Sau khi cài đặt, Apache đăng ký một vài cấu hình ứng dụng UFW khác nhau. Chúng tôi có thể tận dụng cấu hình **Apache Full** để cho phép cả lưu lượng HTTP và HTTPS trên máy chủ của bạn.

Để xác minh loại lưu lượng nào hiện được phép trên máy chủ của bạn, bạn có thể sử dụng:
```command
sudo ufw status
```

Nếu bạn đã làm theo một trong các hướng dẫn cài đặt Apache của chúng tôi, đầu ra của bạn sẽ giống như thế này, nghĩa là hiện tại chỉ cho phép lưu lượng HTTP trên cổng `80`:
```
[secondary_label Output]
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
<^>Apache                     ALLOW       Anywhere<^>             
OpenSSH (v6)               ALLOW       Anywhere (v6)             
<^>Apache (v6)                ALLOW       Anywhere (v6)<^>
```

Ngoài ra, để cho phép lưu lượng truy cập HTTPS, hãy bật cấu hình “Apache Full” và xóa cấu hình “Apache” dư thừa:
```command
sudo ufw allow 'Apache Full'
sudo ufw delete allow 'Apache'
```

Trạng thái của bạn bây giờ sẽ trông như thế này:
```command
sudo ufw status
```

```
[secondary_label Output]
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
<^>Apache Full                ALLOW       Anywhere<^>                  
OpenSSH (v6)               ALLOW       Anywhere (v6)             
<^>Apache Full (v6)           ALLOW       Anywhere (v6)<^>
```

Bây giờ bạn đã sẵn sàng để chạy Certbot và lấy chứng chỉ của mình.

## Bước 4 — Lấy chứng chỉ SSL

Certbot cung cấp nhiều cách khác nhau để lấy chứng chỉ SSL thông qua plugin. Plugin Apache sẽ đảm nhận việc cấu hình lại Apache và tải lại cấu hình bất cứ khi nào cần thiết. Để sử dụng plugin này, gõ như sau:
```command
sudo certbot --apache
```

Tập lệnh này sẽ nhắc bạn trả lời một loạt câu hỏi để định cấu hình chứng chỉ SSL của bạn. Đầu tiên, nó sẽ hỏi bạn một địa chỉ e-mail hợp lệ. Email này sẽ được sử dụng cho các thông báo gia hạn và thông báo bảo mật:
```
[secondary_label Output]
Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator apache, Installer apache
Enter email address (used for urgent renewal and security notices) (Enter 'c' to
cancel): <^>you@your_domain<^>
```

Sau khi cung cấp địa chỉ e-mail hợp lệ, nhấn `ENTER` để chuyển sang bước tiếp theo. Sau đó, bạn sẽ được nhắc xác nhận nếu bạn đồng ý với các điều khoản dịch vụ của Let's Encrypt. Bạn có thể xác nhận bằng cách nhấn `A` rồi `ENTER`:
```custom_prefix()
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf. You must
agree in order to register with the ACME server at
https://acme-v02.api.letsencrypt.org/directory
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(A)gree/(C)ancel: <^>A<^>
```

Tiếp theo, bạn sẽ được hỏi liệu bạn có muốn chia sẻ email của mình với Electronic Frontier Foundation để nhận tin tức và thông tin khác hay không. Nếu bạn không muốn đăng ký nội dung của họ, hãy nhập `N`. Nếu không, hãy nhập `Y`. Sau đó, nhấn `ENTER` để chuyển sang bước tiếp theo.
```custom_prefix()
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Would you be willing to share your email address with the Electronic Frontier
Foundation, a founding partner of the Let's Encrypt project and the non-profit
organization that develops Certbot? We'd like to send you email about our work
encrypting the web, EFF news, campaigns, and ways to support digital freedom.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(Y)es/(N)o: <^>N<^>
```

Bước tiếp theo sẽ nhắc bạn thông báo cho Certbot về những miền mà bạn muốn kích hoạt HTTPS. Các tên miền được liệt kê được tự động lấy từ cấu hình máy chủ ảo Apache của bạn, đó là lý do tại sao điều quan trọng là phải đảm bảo rằng bạn có các cài đặt `ServerName` và `ServerAlias` chính xác được định cấu hình trong máy chủ ảo của mình. Nếu bạn muốn bật HTTPS cho tất cả các tên miền được liệt kê (được khuyến nghị), bạn có thể để trống lời nhắc và nhấn `ENTE` để tiếp tục. Nếu không, hãy chọn các miền bạn muốn bật HTTPS bằng cách liệt kê từng số thích hợp, được phân tách bằng dấu phẩy và/hoặc dấu cách, sau đó nhấn `ENTER`.
```custom_prefix()
Which names would you like to activate HTTPS for?
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: <^>your_domain<^>
2: www.<^>your_domain<^>
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate numbers separated by commas and/or spaces, or leave input
blank to select all options shown (Enter 'c' to cancel): 
```

Bạn sẽ thấy đầu ra như thế này:
```custom_prefix()
Obtaining a new certificate
Performing the following challenges:
http-01 challenge for <^>your_domain<^>
http-01 challenge for www.<^>your_domain<^>
Enabled Apache rewrite module
Waiting for verification...
Cleaning up challenges
Created an SSL vhost at /etc/apache2/sites-available/<^>your_domain<^>-le-ssl.conf
Enabled Apache socache_shmcb module
Enabled Apache ssl module
Deploying Certificate to VirtualHost /etc/apache2/sites-available/<^>your_domain<^>-le-ssl.conf
Enabling available site: /etc/apache2/sites-available/<^>your_domain<^>-le-ssl.conf
Deploying Certificate to VirtualHost /etc/apache2/sites-available/<^>your_domain<^>-le-ssl.conf
```

Tiếp theo, bạn sẽ được nhắc chọn có muốn chuyển hướng lưu lượng HTTP sang HTTPS hay không. Trên thực tế, điều đó có nghĩa là khi ai đó truy cập trang web của bạn thông qua các kênh không được mã hóa (HTTP), họ sẽ tự động được chuyển hướng đến địa chỉ HTTPS của trang web của bạn. Chọn `2` để bật chuyển hướng hoặc `1` nếu bạn muốn giữ cả HTTP và HTTPS làm các phương thức truy cập trang web riêng biệt.
```custom_prefix()
Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate number [1-2] then [enter] (press 'c' to cancel): <^>2<^>
```

Sau bước này, cấu hình của Certbot đã hoàn tất và bạn sẽ được cung cấp những nhận xét cuối cùng về chứng chỉ mới của mình, nơi xác định vị trí các tệp được tạo và cách kiểm tra cấu hình của bạn bằng công cụ bên ngoài phân tích tính xác thực của chứng chỉ của bạn:
```custom_prefix()
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Congratulations! You have successfully enabled https://<^>your_domain<^> and
https://www.<^>your_domain<^>

You should test your configuration at:
https://www.ssllabs.com/ssltest/analyze.html?d=<^>your_domain<^>
https://www.ssllabs.com/ssltest/analyze.html?d=www.<^>your_domain<^>
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at:
   /etc/letsencrypt/live/<^>your_domain<^>/fullchain.pem
   Your key file has been saved at:
   /etc/letsencrypt/live/<^>your_domain<^>/privkey.pem
   Your cert will expire on 2020-07-27. To obtain a new or tweaked
   version of this certificate in the future, simply run certbot again
   with the "certonly" option. To non-interactively renew *all* of
   your certificates, run "certbot renew"
 - Your account credentials have been saved in your Certbot
   configuration directory at /etc/letsencrypt. You should make a
   secure backup of this folder now. This configuration directory will
   also contain certificates and private keys obtained by Certbot so
   making regular backups of this folder is ideal.
 - If you like Certbot, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le
```

Chứng chỉ của bạn hiện đã được cài đặt và tải vào cấu hình của Apache. Hãy thử tải lại trang web của bạn bằng `https://` và chú ý đến chỉ báo bảo mật của trình duyệt. Nó sẽ chỉ ra rằng trang web của bạn được bảo mật đúng cách, thường bằng cách thêm biểu tượng khóa vào thanh địa chỉ.

Bạn có thể sử dụng SSL Labs Server Test để xác minh cấp chứng chỉ của bạn và nhận thông tin chi tiết về nó, từ quan điểm của một dịch vụ bên ngoài.

Trong bước tiếp theo và cũng là bước cuối cùng, chúng tôi sẽ kiểm tra tính năng tự động gia hạn của Certbot, tính năng này đảm bảo rằng chứng chỉ của bạn sẽ được tự động gia hạn trước ngày hết hạn.

## Bước 5 — Xác minh tính năng tự động gia hạn của Certbot

Chứng chỉ của Let's Encrypt chỉ có hiệu lực trong chín mươi ngày. Điều này nhằm khuyến khích người dùng tự động hóa quy trình gia hạn chứng chỉ của họ, cũng như để đảm bảo rằng các chứng chỉ bị sử dụng sai mục đích hoặc khóa bị đánh cắp sẽ hết hạn sớm hơn.

Gói `certbot` mà chúng tôi đã cài đặt đảm nhận việc gia hạn bằng cách đưa tập lệnh gia hạn vào `/etc/cron.d`, được quản lý bởi dịch vụ `systemctl` có tên là `certbot.timer`. Tập lệnh này chạy hai lần một ngày và sẽ tự động gia hạn bất kỳ chứng chỉ nào trong vòng ba mươi ngày kể từ ngày hết hạn.

Để kiểm tra trạng thái của dịch vụ này và đảm bảo rằng nó đang hoạt động và đang chạy, bạn có thể sử dụng:
```command
sudo systemctl status certbot.timer
```

Bạn sẽ nhận được đầu ra tương tự như sau:
```
[secondary_label Output]
● certbot.timer - Run certbot twice daily
     Loaded: loaded (/lib/systemd/system/certbot.timer; enabled; vendor preset: enabled)
     Active: active (waiting) since Tue 2020-04-28 17:57:48 UTC; 17h ago
    Trigger: Wed 2020-04-29 23:50:31 UTC; 12h left
   Triggers: ● certbot.service

Apr 28 17:57:48 fine-turtle systemd[1]: Started Run certbot twice daily.
```

Để kiểm tra quy trình gia hạn, bạn có thể chạy thử với certbot:
```command
sudo certbot renew --dry-run
```

Nếu bạn không thấy lỗi, bạn đã hoàn tất. Khi cần, Certbot sẽ gia hạn chứng chỉ của bạn và tải lại Apache để nhận các thay đổi. Nếu quá trình gia hạn tự động không thành công, Let's Encrypt sẽ gửi một thông báo đến email bạn đã chỉ định, cảnh báo bạn khi chứng chỉ của bạn sắp hết hạn.

## Kết luận

Trong hướng dẫn này, bạn đã cài đặt `certbot` ứng dụng khách Let's Encrypt, định cấu hình và cài đặt chứng chỉ SSL cho miền của mình, đồng thời xác nhận rằng dịch vụ gia hạn tự động của Certbot đang hoạt động trong `systemctl`. Nếu bạn có thêm câu hỏi về việc sử dụng Certbot, tài liệu của họ là một nơi tốt để bắt đầu.

Cách bảo mật Apache với Let's Encrypt trên Ubuntu 20.04

## Giới thiệu

Máy chủ HTTP Apache là máy chủ web được sử dụng rộng rãi nhất trên thế giới. Nó cung cấp nhiều tính năng mạnh mẽ bao gồm các mô-đun có thể tải động, hỗ trợ phương tiện mạnh mẽ và tích hợp rộng rãi với phần mềm phổ biến khác.

Trong hướng dẫn này, chúng tôi sẽ giải thích cách cài đặt máy chủ web Apache trên máy chủ Ubuntu 20.04 của bạn.

## Điều kiện tiên quyết

Trước khi bạn bắt đầu hướng dẫn này, bạn nên có một non-root user với các đặc quyền sudo được định cấu hình trên máy chủ của bạn. Ngoài ra, bạn sẽ cần bật tường lửa cơ bản để chặn các cổng không cần thiết. Bạn có thể tìm hiểu cách định cấu hình tài khoản người dùng thông thường và thiết lập tường lửa cho máy chủ của mình bằng cách làm theo hướng dẫn thiết lập máy chủ Ban đầu cho Ubuntu 20.04 của chúng tôi.

Khi bạn có sẵn một tài khoản, hãy đăng nhập với tư cách là non-root user của bạn để bắt đầu.

## Bước 1 — Cài đặt Apache

Apache có sẵn trong kho phần mềm mặc định của Ubuntu, cho phép cài đặt nó bằng các công cụ quản lý gói thông thường.

Hãy bắt đầu bằng cách cập nhật chỉ mục gói cục bộ để phản ánh những thay đổi ngược dòng mới nhất:
```command
sudo apt update
```

Sau đó, cài đặt gói `apache2`:
```command
sudo apt install apache2
```

Sau khi xác nhận cài đặt, `apt` sẽ cài đặt Apache và tất cả các phụ thuộc cần thiết.

## Bước 2 — Điều chỉnh Tường lửa

Trước khi kiểm tra Apache, cần sửa đổi cài đặt tường lửa để cho phép bên ngoài truy cập vào các cổng web mặc định. Giả sử rằng bạn đã làm theo hướng dẫn trong phần điều kiện tiên quyết, bạn nên cấu hình tường lửa UFW để hạn chế quyền truy cập vào máy chủ của mình.

Trong quá trình cài đặt, Apache tự đăng ký với UFW để cung cấp một vài cấu hình ứng dụng có thể được sử dụng để bật hoặc tắt quyền truy cập vào Apache thông qua tường lửa.

Liệt kê các hồ sơ ứng dụng `ufw` bằng cách gõ:
```command
sudo ufw app list
```

Bạn sẽ nhận được một danh sách các hồ sơ ứng dụng:
```
[secondary_label Output]
Available applications:
  Apache
  Apache Full
  Apache Secure
  OpenSSH
```

Như được chỉ ra bởi đầu ra, có ba cấu hình có sẵn cho Apache:

* **Apache**: Hồ sơ này chỉ mở cổng 80 (lưu lượng truy cập web bình thường, không được mã hóa)
* **Apache Full**: Cấu hình này mở cả cổng 80 (lưu lượng truy cập web bình thường, không được mã hóa) và cổng 443 (lưu lượng được mã hóa TLS/SSL)
* **Apache Secure**: Cấu hình này chỉ mở cổng 443 (lưu lượng được mã hóa TLS/SSL)

Bạn nên bật cấu hình hạn chế nhất vẫn cho phép lưu lượng truy cập mà bạn đã định cấu hình. Vì chúng tôi chưa định cấu hình SSL cho máy chủ của mình trong hướng dẫn này, chúng tôi sẽ chỉ cần cho phép lưu lượng truy cập trên cổng 80:
```command
sudo ufw allow 'Apache'
```

Bạn có thể xác minh thay đổi bằng cách nhập:
```command
sudo ufw status
```

Đầu ra sẽ cung cấp danh sách lưu lượng HTTP được phép:
```
[secondary_label Output]
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
<^>Apache                     ALLOW       Anywhere<^>                
OpenSSH (v6)               ALLOW       Anywhere (v6)             
<^>Apache (v6)                ALLOW       Anywhere (v6)<^>
```

Như được chỉ ra bởi đầu ra, cấu hình đã được kích hoạt để cho phép truy cập vào máy chủ web Apache.

## Bước 3 — Kiểm tra Máy chủ Web của bạn

Khi kết thúc quá trình cài đặt, Ubuntu 20.04 khởi động Apache. Máy chủ web đã được thiết lập và đang chạy.

Kiểm tra với hệ thống init `systemd` để đảm bảo dịch vụ đang chạy bằng cách gõ:
```command
sudo systemctl status apache2
```

```
[secondary_label Output]
● apache2.service - The Apache HTTP Server
     Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: enabled)
     Active: active (running) since Thu 2020-04-23 22:36:30 UTC; 20h ago
       Docs: https://httpd.apache.org/docs/2.4/
   Main PID: 29435 (apache2)
      Tasks: 55 (limit: 1137)
     Memory: 8.0M
     CGroup: /system.slice/apache2.service
             ├─29435 /usr/sbin/apache2 -k start
             ├─29437 /usr/sbin/apache2 -k start
             └─29438 /usr/sbin/apache2 -k start
```

Theo xác nhận của đầu ra này, dịch vụ đã bắt đầu thành công. Tuy nhiên, cách tốt nhất để kiểm tra điều này là yêu cầu một trang từ Apache.

Bạn có thể truy cập trang đích mặc định của Apache để xác nhận rằng phần mềm đang chạy đúng thông qua địa chỉ IP của bạn. Nếu bạn không biết địa chỉ IP của máy chủ, bạn có thể lấy địa chỉ đó bằng một vài cách khác nhau từ dòng lệnh.

Hãy thử gõ cái này tại dấu nhắc lệnh của máy chủ của bạn:
```command
hostname -I
```

Bạn sẽ nhận lại một vài địa chỉ được phân tách bằng dấu cách. Bạn có thể thử từng cái trong trình duyệt web của mình để xác định xem chúng có hoạt động không.

Một tùy chọn khác là sử dụng công cụ Icanhazip, công cụ này sẽ cung cấp cho bạn địa chỉ IP công khai của bạn khi được đọc từ một vị trí khác trên internet:
```command
curl -4 icanhazip.com
```

Khi bạn có địa chỉ IP của máy chủ, hãy nhập địa chỉ đó vào thanh địa chỉ của trình duyệt:
```custom_prefix()
http://<^>your_server_ip<^>
```

Bạn sẽ thấy trang web mặc định của Ubuntu 20.04 Apache:

![description image](https://media.cloudfly.vn/posts/small_apache_default.png)

Trang này chỉ ra rằng Apache đang hoạt động bình thường. Nó cũng bao gồm một số thông tin cơ bản về các tệp Apache và vị trí thư mục quan trọng.

## Bước 4 - Quản lý quy trình Apache

Bây giờ bạn đã thiết lập và chạy máy chủ web của mình, hãy xem qua một số lệnh quản lý cơ bản bằng `systemctl`.

Để dừng máy chủ web của bạn, gõ:
```command
sudo systemctl stop apache2
```

Để khởi động máy chủ web khi nó bị dừng, hãy nhập:
```command
sudo systemctl start apache2
```

Để dừng và sau đó bắt đầu lại dịch vụ, hãy nhập:
```command
sudo systemctl restart apache2
```

Nếu bạn chỉ thực hiện thay đổi cấu hình, Apache thường có thể tải lại mà không làm mất kết nối. Để làm điều này, sử dụng lệnh này:
```command
sudo systemctl reload apache2
```

Theo mặc định, Apache được cấu hình để khởi động tự động khi máy chủ khởi động. Nếu đây không phải là điều bạn muốn, hãy tắt hành vi này bằng cách nhập:
```command
sudo systemctl disable apache2
```

Để kích hoạt lại dịch vụ để khởi động khi khởi động, hãy nhập:
```command
sudo systemctl enable apache2
```

Bây giờ Apache sẽ tự động bắt đầu khi máy chủ khởi động lại.

## Bước 5 — Thiết lập máy chủ ảo (Được khuyến nghị)

Khi sử dụng máy chủ web Apache, bạn có thể sử dụng *các máy chủ ảo* (tương tự như các khối máy chủ trong Nginx) để đóng gói các chi tiết cấu hình và lưu trữ nhiều miền từ một máy chủ. Chúng tôi sẽ thiết lập một miền gọi là **your_domain**, nhưng bạn nên **thay thế miền này bằng tên miền của riêng bạn**. 

Apache trên Ubuntu 20.04 có một khối máy chủ được bật theo mặc định, khối này được định cấu hình để phục vụ tài liệu từ thư mục `/var/www/html`. Mặc dù điều này hoạt động tốt cho một trang web, nhưng nó có thể trở nên khó sử dụng nếu bạn đang lưu trữ nhiều trang web. Thay vì sửa đổi `/var/www/html`, hãy tạo cấu trúc thư mục bên trong `var/www` cho trang web **your_domain**, để nguyên `/var/www/html` làm thư mục mặc định sẽ được phục vụ nếu yêu cầu của khách hàng không khớp với bất kỳ các trang web khác.

Tạo thư mục cho **your_domain** như sau:
```command
sudo mkdir /var/www/<^>our_domain<^>
```

Tiếp theo, gán quyền sở hữu thư mục với biến môi trường `$USER`:
```command
sudo chown -R $USER:$USER /var/www/<^>your_domain<^>
```

Các quyền của gốc web của bạn phải chính xác nếu bạn chưa sửa đổi giá trị ô của mình, giá trị này đặt quyền cho tệp mặc định. Để đảm bảo rằng các quyền của bạn là chính xác và cho phép chủ sở hữu đọc, ghi và thực thi các tệp trong khi chỉ cấp quyền đọc và thực thi cho các nhóm và những người khác, bạn có thể nhập lệnh sau:
```command
sudo chmod -R 755 /var/www/<^>your_domain<^>
```

Tiếp theo, tạo một trang `index.html` mẫu bằng cách sử dụng `nano` hoặc trình chỉnh sửa yêu thích của bạn:
```command
sudo nano /var/www/<^>your_domain<^>/index.html
```

Bên trong, thêm HTML mẫu sau:
```nginx
[label /var/www/your_domain/index.html]
<html>
    <head>
        <title>Welcome to <^>Your_domain<^>!</title>
    </head>
    <body>
        <h1>Success!  The <^>your_domain<^> virtual host is working!</h1>
    </body>
</html>
```

Lưu và đóng tệp khi bạn hoàn tất.

Để Apache phục vụ nội dung này, cần phải tạo một tệp máy chủ ảo với các chỉ thị chính xác. Thay vì sửa đổi trực tiếp tệp cấu hình mặc định có tại `/etc/apache2/sites-available/000-default.conf`, hãy tạo một tệp mới tại `/etc/apache2/sites-available/<^>your_domain<^>.conf`:
```command
sudo nano /etc/apache2/sites-available/<^>your_domain<^>.conf
```

Dán vào khối cấu hình sau, tương tự như mặc định, nhưng được cập nhật cho thư mục và tên miền mới của chúng tôi:
```nginx
[label /etc/apache2/sites-available/your_domain.conf]
<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    ServerName <^>your_domain<^>
    ServerAlias <^>www.your_domain<^>
    DocumentRoot /var/www/<^>your_domain<^>
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
```

Lưu ý rằng chúng tôi đã cập nhật `DocumentRoot` vào thư mục mới của chúng tôi và `ServerAdmin` thành một email mà quản trị viên trang **your_domain** có thể truy cập. Chúng tôi cũng đã thêm hai chỉ thị: `ServerName`, thiết lập miền cơ sở phù hợp với định nghĩa máy chủ ảo này và `ServerAlias`, xác định các tên khác sẽ khớp như thể chúng là tên cơ sở.

Lưu và đóng tệp khi bạn hoàn tất.

Hãy kích hoạt tệp bằng công cụ `a2ensite`:
```command
sudo a2ensite <^>your_domain<^>.conf
```

Vô hiệu hóa trang mặc định được xác định trong `000-default.conf`:
```command
sudo a2dissite 000-default.conf
```

Tiếp theo, hãy kiểm tra lỗi cấu hình:
```command
sudo apache2ctl configtest
```

Bạn sẽ nhận được đầu ra sau:
```
[secondary_label Output]
Syntax OK
```

Khởi động lại Apache để thực hiện các thay đổi của bạn:
```command
sudo systemctl restart apache2
```

Bây giờ Apache sẽ phục vụ tên miền của bạn. Bạn có thể kiểm tra điều này bằng cách điều hướng đến `http://<^>your_domain<^>`, tại đây bạn sẽ thấy nội dung như sau:

![description image](https://media.cloudfly.vn/posts/vhost_your_domain.png)

## Bước 6 – Làm quen với các tệp và thư mục quan trọng của Apache

Bây giờ bạn đã biết cách tự quản lý dịch vụ Apache, bạn nên dành vài phút để tự làm quen với một số thư mục và tệp quan trọng.

### Nội dung

* `/var/www/html`: Nội dung web thực tế, theo mặc định chỉ bao gồm trang Apache mặc định mà bạn đã thấy trước đó, được cung cấp ngoài thư mục `/var/www/html`. Điều này có thể được thay đổi bằng cách thay đổi các tệp cấu hình Apache.

### Cấu hình máy chủ

* `/etc/apache2`: Thư mục cấu hình Apache. Tất cả các tệp cấu hình Apache nằm ở đây.
* `/etc/apache2/apache2.conf`: Tệp cấu hình chính của Apache. Điều này có thể được sửa đổi để thay đổi cấu hình toàn cầu của Apache. Tệp này chịu trách nhiệm tải nhiều tệp khác trong thư mục cấu hình.
* `/etc/apache2/ports.conf`: Tệp này chỉ định các cổng mà Apache sẽ lắng nghe. Theo mặc định, Apache lắng nghe trên cổng 80 và bổ sung lắng nghe trên cổng 443 khi mô-đun cung cấp khả năng SSL được bật.
* `/etc/apache2/sites-available/`: Thư mục nơi có thể lưu trữ các máy chủ ảo trên mỗi trang web. Apache sẽ không sử dụng các tệp cấu hình được tìm thấy trong thư mục này trừ khi chúng được liên kết với thư mục `sites-enabled`. Thông thường, tất cả cấu hình khối máy chủ được thực hiện trong thư mục này, sau đó được kích hoạt bằng cách liên kết với thư mục khác bằng lệnh `a2ensite`.
* `/etc/apache2/sites-enabled/`: Thư mục lưu trữ các máy chủ ảo trên mỗi trang đã bật. Thông thường, chúng được tạo bằng cách liên kết với các tệp cấu hình được tìm thấy trong thư mục `sites-available` với `a2ensite`. Apache đọc các tệp cấu hình và các liên kết được tìm thấy trong thư mục này khi nó khởi động hoặc tải lại để biên dịch một cấu hình hoàn chỉnh.
* `/etc/apache2/conf-available/`, `/etc/apache2/conf-enabled/`: Các thư mục này có cùng mối quan hệ với các thư mục `sites-available` và `sites-enabled`, nhưng được sử dụng để lưu trữ các đoạn cấu hình không thuộc về một Máy chủ ảo. Các tệp trong thư mục `conf-available` có thể được kích hoạt bằng lệnh `a2enconf` và bị vô hiệu hóa bằng lệnh `a2disconf`.
* `/etc/apache2/mods-available/`, `/etc/apache2/mods-enabled/`: Các thư mục này lần lượt chứa các mô-đun khả dụng và đã kích hoạt. Các tệp kết thúc bằng `.load` chứa các đoạn để tải các mô-đun cụ thể, trong khi các tệp kết thúc bằng `.conf` chứa cấu hình cho các mô-đun đó. Có thể bật và tắt các mô-đun bằng lệnh `a2enmod` và `a2dismod`.

### Nhật ký máy chủ

* `/var/log/apache2/access.log`: Theo mặc định, mọi yêu cầu đối với máy chủ web của bạn được ghi lại trong tệp nhật ký này trừ khi Apache được cấu hình để thực hiện theo cách khác.
* `/var/log/apache2/error.log`: Theo mặc định, tất cả các lỗi được ghi trong tệp này. Chỉ thị `LogLevel` trong cấu hình Apache chỉ định mức độ chi tiết của nhật ký lỗi.

## Kết luận

Bây giờ bạn đã cài đặt máy chủ web của mình, bạn có nhiều tùy chọn cho loại nội dung bạn có thể phục vụ và các công nghệ bạn có thể sử dụng để tạo trải nghiệm phong phú hơn.

Nếu bạn muốn xây dựng một ngăn xếp ứng dụng hoàn chỉnh hơn, bạn có thể đọc bài viết này về cách định cấu hình LAMP stack trên Ubuntu 20.04

Cách cài đặt máy chủ web Apache trên Ubuntu 20.04

## Giới thiệu

Cloudflare là một dịch vụ nằm giữa khách truy cập và máy chủ của chủ sở hữu trang web, hoạt động như một proxy ngược cho các trang web. Cloudflare cung cấp Mạng phân phối nội dung (Content Delivery Network - CDN), cũng như các dịch vụ máy chủ tên miền phân tán và giảm thiểu DDoS.

Nginx là một máy chủ web phổ biến chịu trách nhiệm lưu trữ một số trang web lớn nhất và có lưu lượng truy cập cao nhất trên internet. Các tổ chức thường phục vụ các trang web bằng Nginx và sử dụng Cloudflare làm nhà cung cấp CDN và DNS.

Trong hướng dẫn này, bạn sẽ bảo mật trang web của mình do Nginx cung cấp bằng chứng chỉ CA gốc từ Cloudflare, sau đó định cấu hình Nginx để sử dụng các yêu cầu kéo được xác thực. Ưu điểm của việc sử dụng thiết lập này là bạn được hưởng lợi từ CDN của Cloudflare và độ phân giải DNS nhanh trong khi vẫn đảm bảo rằng tất cả các kết nối đều đi qua Cloudflare. Điều này ngăn chặn bất kỳ yêu cầu độc hại nào đến máy chủ của bạn.

## Điều kiện tiên quyết

Để hoàn thành hướng dẫn này, bạn sẽ cần những thứ sau:

* Một máy chủ Ubuntu 20.04 được thiết lập bằng cách làm theo hướng dẫn thiết lập máy chủ ban đầu của Ubuntu 20.04, bao gồm `sudo` non-root user và tường lửa.
* Nginx được cài đặt trên máy chủ của bạn. Bạn có thể làm theo hướng dẫn của chúng tôi về cách cài đặt Nginx trên Ubuntu 20.04.
* Một tài khoản Cloudflare.
* Miền đã đăng ký được thêm vào tài khoản Cloudflare trỏ đến máy chủ Nginx của bạn. Hướng dẫn của chúng tôi về cách giảm thiểu các cuộc tấn công DDoS vào trang web của bạn bằng Cloudflare có thể giúp bạn thiết lập điều này. Phần giới thiệu của chúng tôi về thuật ngữ, thành phần và khái niệm DNS cũng có thể cung cấp hỗ trợ.
* Khối máy chủ Nginx được định cấu hình cho miền của bạn, bạn có thể thực hiện việc này bằng cách làm theo Bước 5 của Cách cài đặt Nginx trên Ubuntu 20.04.

## Bước 1 — Tạo chứng chỉ TLS gốc CA

Cloudflare Origin CA cho phép bạn tạo chứng chỉ TLS miễn phí do Cloudflare ký để cài đặt trên máy chủ Nginx của bạn. Bằng cách sử dụng chứng chỉ TLS do Cloudflare tạo, bạn có thể bảo mật kết nối giữa máy chủ của Cloudflare và máy chủ Nginx của bạn.

Để tạo chứng chỉ với Origin CA, hãy đăng nhập vào tài khoản Cloudflare của bạn trong trình duyệt web. Chọn miền mà bạn muốn bảo mật và điều hướng đến phần **SSL/TLS** trên bảng điều khiển Cloudflare của bạn. Từ đó, điều hướng đến tab **Origin Server** và nhấp vào nút **Create Certificate**:

![description image](https://media.cloudfly.vn/posts/KcTiCQW.png)

Để tùy chọn mặc định **Generate private key and CSR with Cloudflare** được chọn.

![description image](https://media.cloudfly.vn/posts/cloudflare.png)

Nhấp vào **Next** và bạn sẽ thấy hộp thoại có **Origin Certificate** và **Private key**. Bạn cần chuyển cả origin certificate và private key từ Cloudflare sang máy chủ của mình. Vì lý do bảo mật, thông tin **Private key** sẽ không được hiển thị lại, vì vậy hãy sao chép khóa vào máy chủ của bạn trước khi nhấp vào **Ok**.

![description image](https://media.cloudfly.vn/posts/bIBA8tf.png)

Bạn sẽ sử dụng thư mục `/etc/ssl` trên máy chủ để giữ origin certificate và các tệp private key. Thư mục đã tồn tại trên máy chủ.

Đầu tiên, sao chép nội dung của **Origin Certificate** xuất xứ được hiển thị trong hộp thoại trên trình duyệt của bạn.

Sau đó, trên máy chủ của bạn, hãy mở `/etc/ssl/cert.pem` trong trình soạn thảo văn bản ưa thích của bạn:
```command
sudo nano /etc/ssl/cert.pem
```

Dán nội dung chứng chỉ vào tệp. Sau đó lưu và thoát khỏi trình chỉnh sửa. Nếu bạn đang sử dụng `nano`, hãy nhấn `Ctrl + X`, sau đó khi được nhắc, hãy nhấn `Y` rồi `Enter`.

Sau đó quay lại trình duyệt của bạn và sao chép nội dung của **Private key**. Mở file `/etc/ssl/key.pem` để chỉnh sửa:
```command
sudo nano /etc/ssl/key.pem
```

Dán private key vào tệp, lưu tệp và thoát khỏi trình chỉnh sửa.

<$>[note]
**Lưu ý:** Đôi khi, khi bạn sao chép chứng chỉ và khóa từ bảng điều khiển Cloudflare và dán vào các tệp có liên quan trên máy chủ, các dòng trống sẽ được chèn vào. Nginx sẽ coi các chứng chỉ và khóa đó là không hợp lệ, vì vậy hãy đảm bảo rằng không có dòng trống nào trong tệp của bạn.
<$>

<$>[warning]
**Cảnh báo:** Chứng chỉ CA gốc của Cloudflare chỉ được Cloudflare tin cậy và do đó chỉ nên được sử dụng bởi các máy chủ gốc được kết nối tích cực với Cloudflare. Nếu tại bất kỳ thời điểm nào bạn tạm dừng hoặc tắt Cloudflare, chứng chỉ CA gốc của bạn sẽ đưa ra lỗi chứng chỉ không đáng tin cậy.
<$>

Bây giờ bạn đã sao chép các tệp khóa và chứng chỉ vào máy chủ của mình, bạn cần cập nhật cấu hình Nginx để sử dụng chúng.

## Bước 2 — Cài đặt Chứng chỉ CA gốc trong Nginx

Trong phần trước, bạn đã tạo origin certificate và private key bằng bảng điều khiển của Cloudflare và lưu các tệp vào máy chủ của bạn. Bây giờ, bạn sẽ cập nhật cấu hình Nginx cho trang web của mình để sử dụng chứng chỉ gốc và khóa riêng nhằm bảo mật kết nối giữa máy chủ của Cloudflare và máy chủ của bạn.

Trước tiên, hãy đảm bảo rằng UFW sẽ cho phép lưu lượng HTTPS. Bật `Nginx Full`, thao tác này sẽ mở cả cổng `80` (HTTP) và cổng `443` (HTTPS):
```command
sudo ufw allow 'Nginx Full'
```

Bây giờ hãy tải lại UFW:
```command
sudo ufw reload
```

Cuối cùng, hãy kiểm tra xem các quy tắc mới của bạn có được cho phép không và UFW có đang hoạt động không:
```command
sudo ufw status
```

Bạn sẽ thấy một đầu ra như thế này:
```
[secondary_label Output]
Status: <^>active<^>

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
<^>Nginx Full<^>                <^>ALLOW<^>       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
<^>Nginx Full (v6)<^>           <^>ALLOW<^>       Anywhere (v6)
```

Bây giờ bạn đã sẵn sàng để điều chỉnh khối máy chủ Nginx của mình. Nginx tạo khối máy chủ mặc định trong quá trình cài đặt. Xóa nó nếu nó vẫn tồn tại, vì bạn đã định cấu hình khối máy chủ tùy chỉnh cho miền của mình:
```command
sudo rm /etc/nginx/sites-enabled/default
```

Tiếp theo, mở tệp cấu hình Nginx cho miền của bạn:
```command
sudo nano /etc/nginx/sites-available/<^>your_domain<^>
```

Các tập tin sẽ trông như thế này:
```nginx
[label /etc/nginx/sites-available/your_domain]
server {
        listen 80;
        listen [::]:80;

        root /var/www/<^>your_domain<^>/html;
        index index.html index.htm index.nginx-debian.html;

        server_name <^>your_domain<^> <^>www.your_domain<^>;

        location / {
                try_files $uri $uri/ =404;
        }
}
```

Bạn sẽ sửa đổi tệp cấu hình Nginx để thực hiện các thao tác sau:

* Nghe trên cổng `80` và chuyển hướng tất cả các yêu cầu sử dụng `https`.
* Nghe trên cổng `443` và sử dụng origin certificate và private key được thêm vào trong phần trước.

Sửa đổi tệp để nó trông giống như sau:
```nginx
[label /etc/nginx/sites-available/your_domain]
server {
    listen 80;
    listen [::]:80;
    server_name <^>your_domain<^> <^>www.your_domain<^>;
    <^>return 302 https://$server_name$request_uri;<^>
}

<^>server {<^>

    <^># SSL configuration<^>

    <^>listen 443 ssl http2;<^>
    <^>listen [::]:443 ssl http2;<^>
    <^>ssl_certificate         /etc/ssl/cert.pem;<^>
    <^>ssl_certificate_key     /etc/ssl/key.pem;<^>

    server_name <^>your_domain<^> <^>www.your_domain<^>;

    root /var/www/<^>your_domain<^>/html;
    index index.html index.htm index.nginx-debian.html;


    location / {
            try_files $uri $uri/ =404;
    }
}
```

Lưu tệp và thoát khỏi trình chỉnh sửa.

Tiếp theo, hãy kiểm tra để đảm bảo rằng không có lỗi cú pháp trong bất kỳ tệp cấu hình Nginx nào của bạn:
```command
sudo nginx -t
```

Nếu bạn không tìm thấy vấn đề gì, hãy khởi động lại Nginx để kích hoạt các thay đổi của bạn:
```command
sudo systemctl restart nginx
```

Bây giờ, hãy chuyển đến phần **SSL/TLS** của bảng điều khiển Cloudflare, điều hướng đến tab **Overview** và thay đổi **SSL/TLS encryption mode** thành **Full (strict)**. Điều này thông báo cho Cloudflare luôn mã hóa kết nối giữa Cloudflare và máy chủ Nginx gốc của bạn.

![description image](https://media.cloudfly.vn/posts/xtqRI9b.png)

Bây giờ, hãy truy cập trang web của bạn tại `https://<^>your_domain<^>` để xác minh rằng trang web được thiết lập đúng cách. Bạn sẽ thấy trang chủ của mình được hiển thị và trình duyệt sẽ báo cáo rằng trang web này an toàn.

![description image](https://media.cloudfly.vn/posts/cert.png)

Trong phần tiếp theo, bạn sẽ thiết lập Authenticated Origin Pulls để xác minh rằng máy chủ gốc của bạn thực sự đang nói chuyện với Cloudflare chứ không phải một số máy chủ khác. Bằng cách đó, Nginx sẽ được định cấu hình để chỉ chấp nhận các yêu cầu sử dụng chứng chỉ ứng dụng khách hợp lệ từ Cloudflare; tất cả các yêu cầu chưa được chuyển qua Cloudflare sẽ bị hủy.

## Bước 3 — Thiết lập Authenticated Origin Pulls

Chứng chỉ CA gốc sẽ giúp Cloudflare xác minh rằng nó đang giao tiếp với đúng máy chủ gốc. Bước này sẽ sử dụng TLS Client Authentication (Xác thực ứng dụng khách TLS) để xác minh rằng máy chủ Nginx ban đầu của bạn đang kết nối với Cloudflare.

Trong quá trình bắt tay TLS do khách hàng xác thực, cả hai bên đều cung cấp chứng chỉ để được xác minh. Máy chủ gốc được định cấu hình để chỉ chấp nhận các yêu cầu sử dụng chứng chỉ ứng dụng khách hợp lệ từ Cloudflare. Các yêu cầu chưa được chuyển qua Cloudflare sẽ bị hủy vì chúng sẽ không có chứng chỉ của Cloudflare. Điều này có nghĩa là những kẻ tấn công không thể phá vỡ các biện pháp bảo mật của Cloudflare và kết nối trực tiếp với máy chủ Nginx của bạn.

Cloudflare xuất trình các chứng chỉ được CA ký với chứng chỉ sau:
```custom_prefix()
-----BEGIN CERTIFICATE-----
MIIGCjCCA/KgAwIBAgIIV5G6lVbCLmEwDQYJKoZIhvcNAQENBQAwgZAxCzAJBgNV
BAYTAlVTMRkwFwYDVQQKExBDbG91ZEZsYXJlLCBJbmMuMRQwEgYDVQQLEwtPcmln
aW4gUHVsbDEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzETMBEGA1UECBMKQ2FsaWZv
cm5pYTEjMCEGA1UEAxMab3JpZ2luLXB1bGwuY2xvdWRmbGFyZS5uZXQwHhcNMTkx
MDEwMTg0NTAwWhcNMjkxMTAxMTcwMDAwWjCBkDELMAkGA1UEBhMCVVMxGTAXBgNV
BAoTEENsb3VkRmxhcmUsIEluYy4xFDASBgNVBAsTC09yaWdpbiBQdWxsMRYwFAYD
VQQHEw1TYW4gRnJhbmNpc2NvMRMwEQYDVQQIEwpDYWxpZm9ybmlhMSMwIQYDVQQD
ExpvcmlnaW4tcHVsbC5jbG91ZGZsYXJlLm5ldDCCAiIwDQYJKoZIhvcNAQEBBQAD
ggIPADCCAgoCggIBAN2y2zojYfl0bKfhp0AJBFeV+jQqbCw3sHmvEPwLmqDLqynI
42tZXR5y914ZB9ZrwbL/K5O46exd/LujJnV2b3dzcx5rtiQzso0xzljqbnbQT20e
ihx/WrF4OkZKydZzsdaJsWAPuplDH5P7J82q3re88jQdgE5hqjqFZ3clCG7lxoBw
hLaazm3NJJlUfzdk97ouRvnFGAuXd5cQVx8jYOOeU60sWqmMe4QHdOvpqB91bJoY
QSKVFjUgHeTpN8tNpKJfb9LIn3pun3bC9NKNHtRKMNX3Kl/sAPq7q/AlndvA2Kw3
Dkum2mHQUGdzVHqcOgea9BGjLK2h7SuX93zTWL02u799dr6Xkrad/WShHchfjjRn
aL35niJUDr02YJtPgxWObsrfOU63B8juLUphW/4BOjjJyAG5l9j1//aUGEi/sEe5
lqVv0P78QrxoxR+MMXiJwQab5FB8TG/ac6mRHgF9CmkX90uaRh+OC07XjTdfSKGR
PpM9hB2ZhLol/nf8qmoLdoD5HvODZuKu2+muKeVHXgw2/A6wM7OwrinxZiyBk5Hh
CvaADH7PZpU6z/zv5NU5HSvXiKtCzFuDu4/Zfi34RfHXeCUfHAb4KfNRXJwMsxUa
+4ZpSAX2G6RnGU5meuXpU5/V+DQJp/e69XyyY6RXDoMywaEFlIlXBqjRRA2pAgMB
AAGjZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgECMB0GA1Ud
DgQWBBRDWUsraYuA4REzalfNVzjann3F6zAfBgNVHSMEGDAWgBRDWUsraYuA4REz
alfNVzjann3F6zANBgkqhkiG9w0BAQ0FAAOCAgEAkQ+T9nqcSlAuW/90DeYmQOW1
QhqOor5psBEGvxbNGV2hdLJY8h6QUq48BCevcMChg/L1CkznBNI40i3/6heDn3IS
zVEwXKf34pPFCACWVMZxbQjkNRTiH8iRur9EsaNQ5oXCPJkhwg2+IFyoPAAYURoX
VcI9SCDUa45clmYHJ/XYwV1icGVI8/9b2JUqklnOTa5tugwIUi5sTfipNcJXHhgz
6BKYDl0/UP0lLKbsUETXeTGDiDpxZYIgbcFrRDDkHC6BSvdWVEiH5b9mH2BON60z
0O0j8EEKTwi9jnafVtZQXP/D8yoVowdFDjXcKkOPF/1gIh9qrFR6GdoPVgB3SkLc
5ulBqZaCHm563jsvWb/kXJnlFxW+1bsO9BDD6DweBcGdNurgmH625wBXksSdD7y/
fakk8DagjbjKShYlPEFOAqEcliwjF45eabL0t27MJV61O/jHzHL3dknXeE4BDa2j
bA+JbyJeUMtU7KMsxvx82RmhqBEJJDBCJ3scVptvhDMRrtqDBW5JShxoAOcpFQGm
iYWicn46nPDjgTU0bX1ZPpTpryXbvciVL5RkVBuyX2ntcOLDPlZWgxZCBp96x07F
AnOzKgZk4RzZPNAxCXERVxajn/FLcOhglVAKo5H0ac+AitlQ0ip55D2/mf8o72tM
fVQ6VpyjEXdiIXWUq/o=
-----END CERTIFICATE-----
```

Bạn cũng có thể tải xuống chứng chỉ trực tiếp từ tài liệu của Cloudflare.

Sao chép chứng chỉ này.

Sau đó tạo tệp `/etc/ssl/cloudflare.crt` để giữ chứng chỉ của Cloudflare:
```command
sudo nano /etc/ssl/cloudflare.crt
```

Thêm chứng chỉ vào tệp. Sau đó lưu tệp và thoát khỏi trình chỉnh sửa.

Bây giờ hãy cập nhật cấu hình Nginx của bạn để sử dụng TLS Authenticated Origin Pulls. Mở tệp cấu hình cho tên miền của bạn:
```command
sudo nano /etc/nginx/sites-available/<^>your_domain<^>
```

Thêm các chỉ thị `ssl_client_certificate` và `ssl_verify_client` như trong ví dụ sau:
```nginx
[label /etc/nginx/sites-available/your_domain]
. . .

server {

    # SSL configuration

    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    ssl_certificate         /etc/ssl/cert.pem;
    ssl_certificate_key     /etc/ssl/key.pem;
    <^>ssl_client_certificate /etc/ssl/cloudflare.crt;<^>
    <^>ssl_verify_client on;<^>

    . . .
```

Lưu tệp và thoát khỏi trình chỉnh sửa.

Tiếp theo, hãy kiểm tra Nginx để đảm bảo rằng không có lỗi cú pháp nào trong cấu hình Nginx của bạn:
```command
sudo nginx -t
```

Nếu không tìm thấy vấn đề gì, hãy khởi động lại Nginx để kích hoạt các thay đổi của bạn:
```command
sudo systemctl restart nginx
```

Cuối cùng, để bật Authenticated Pulls, hãy mở phần **SSL/TLS** trong bảng điều khiển Cloudflare, điều hướng đến tab **Origin Server** và bật tùy chọn **Authenticated Origin Pulls**.

![description image](https://media.cloudfly.vn/posts/s5sYOVs.png)

Bây giờ, hãy truy cập trang web của bạn tại `https://<^>your_domain<^>` để xác minh rằng trang web đã được thiết lập đúng cách. Như trước đây, bạn sẽ thấy trang chủ của mình được hiển thị.

Để xác minh rằng máy chủ của bạn sẽ chỉ chấp nhận các yêu cầu do CA của Cloudflare ký, hãy bật tùy chọn **Authenticated Origin Pulls** để tắt tùy chọn này rồi tải lại trang web của bạn. Bạn sẽ nhận được thông báo lỗi sau:

![description image](https://media.cloudfly.vn/posts/FwYMg6e.png)

Máy chủ gốc của bạn phát sinh lỗi nếu CA của Cloudflare không ký yêu cầu.

<$>[note]
**Lưu ý:** Hầu hết các trình duyệt sẽ lưu các yêu cầu vào bộ đệm ẩn, vì vậy, để xem sự thay đổi ở trên, bạn có thể sử dụng chế độ duyệt web Ẩn danh/Riêng tư trong trình duyệt của mình. Để ngăn Cloudflare lưu các yêu cầu vào bộ đệm trong khi bạn thiết lập trang web của mình, hãy điều hướng đến **Overview** trong bảng điều khiển Cloudflare và chuyển đổi **Development Mode**.
<$>

Bây giờ bạn đã biết nó hoạt động bình thường, hãy quay lại phần **SSL/TLS** trong bảng điều khiển Cloudflare, điều hướng đến tab **Origin Server** và chuyển đổi tùy chọn **Authenticated Origin Pulls** để bật lại.

## Kết luận

Trong hướng dẫn này, bạn đã bảo mật trang web do Nginx cung cấp bằng cách mã hóa lưu lượng giữa Cloudflare và máy chủ Nginx bằng chứng chỉ CA gốc từ Cloudflare. Sau đó, bạn thiết lập Authenticated Origin Pulls trên máy chủ Nginx để đảm bảo rằng nó chỉ chấp nhận các yêu cầu của máy chủ Cloudflare, ngăn không cho bất kỳ ai khác kết nối trực tiếp với máy chủ Nginx.

Cách lưu trữ trang web bằng Cloudflare và Nginx trên Ubuntu 20.04

## Giới thiệu

Postfix là một *Mail Transfer Agent* (MTA) nguồn mở phổ biến có thể được sử dụng để định tuyến và gửi email trên hệ thống Linux. Người ta ước tính rằng khoảng 25% máy chủ thư công cộng trên internet chạy Postfix.

Trong hướng dẫn này, bạn sẽ tìm hiểu cách cài đặt và định cấu hình Postfix trên máy chủ Ubuntu 22.04. Sau đó, bạn sẽ kiểm tra xem Postfix có thể định tuyến thư chính xác hay không bằng cách cài đặt `s-nail`, *Mail User Agent* (MUA), còn được gọi là *email client*.

Lưu ý rằng mục tiêu của hướng dẫn này là giúp bạn thiết lập và chạy Postfix nhanh chóng chỉ với một số chức năng email cơ bản. Bạn sẽ không có một máy chủ email đầy đủ tính năng khi kết thúc hướng dẫn này, nhưng bạn sẽ có một số thành phần cơ bản của một thiết lập như vậy để giúp bạn bắt đầu.

## Điều kiện tiên quyết

Việc thiết lập và duy trì máy chủ mail của riêng bạn rất phức tạp và tốn thời gian. Đối với hầu hết người dùng, việc dựa vào dịch vụ mail trả phí sẽ thực tế hơn. Nếu bạn đang cân nhắc chạy máy chủ mail của riêng mình, chúng tôi khuyên bạn nên xem lại bài viết này về lý do tại sao bạn có thể không muốn làm như vậy.

Nếu bạn chắc chắn muốn làm theo hướng dẫn này để cài đặt và định cấu hình Postfix thì trước tiên bạn phải có những thứ sau:

* Máy chủ chạy Ubuntu 22.04 để hoạt động như máy chủ mail Postfix của bạn. Máy chủ này phải có non-root user với quyền `sudo` và tường lửa được định cấu hình bằng UFW. Bạn có thể làm theo hướng dẫn thiết lập máy chủ ban đầu Ubuntu 22.04 của chúng tôi để thiết lập điều này.
* Tên miền đủ điều kiện trỏ vào máy chủ Ubuntu 22.04 của bạn. Xin lưu ý rằng nếu bạn định truy cập mail từ một vị trí bên ngoài, bạn sẽ cần đảm bảo rằng bạn cũng có một bản ghi MX trỏ đến máy chủ mail của mình.

Lưu ý rằng hướng dẫn này giả định rằng bạn đang định cấu hình máy chủ lưu trữ có FQDN là `mail.example.com`. Bất cứ khi nào cần thiết, hãy nhớ thay đổi `example.com` hoặc `mail.example.com` để phản ánh FQDN của riêng bạn.

## Bước 1 — Cài đặt Postfix

Postfix được bao gồm trong kho lưu trữ mặc định của Ubuntu, vì vậy bạn có thể cài đặt nó bằng APT.

Để bắt đầu, hãy cập nhật bộ đệm gói `apt` cục bộ của bạn:
```command
sudo apt update
```

Sau đó cài đặt gói `postfix` bằng lệnh dưới đây. Lưu ý rằng ở đây chúng tôi chuyển biến môi trường `DEBIAN_PRIORITY=low` vào lệnh cài đặt này. Điều này sẽ khiến quá trình cài đặt nhắc bạn định cấu hình một số tùy chọn bổ sung:
```command
sudo DEBIAN_PRIORITY=low apt install postfix
```

Quá trình cài đặt này sẽ mở ra một loạt lời nhắc tương tác. Đối với mục đích của hướng dẫn này, hãy sử dụng thông tin sau để điền vào lời nhắc của bạn:

* **General type of mail configuration?** (Loại cấu hình mail chung?): Đối với điều này, hãy chọn **Internet Site** vì điều này phù hợp với nhu cầu cơ sở hạ tầng của chúng tôi.
* **System mail name** (Tên mail hệ thống): Đây là miền cơ sở được sử dụng để tạo địa chỉ email hợp lệ khi chỉ cung cấp phần tài khoản của địa chỉ. Chẳng hạn, giả sử tên máy chủ của máy chủ của bạn là `mail.<^>example.com<^>`. Bạn có thể muốn đặt tên mail hệ thống thành `<^>example.com<^>` để, với tên người dùng `user1`, Postfix sẽ sử dụng địa chỉ `user1@<^>example.com<^>`.
* **Root and postmaster mail recipient** (Người nhận mail root và postmaster): Đây là tài khoản Linux sẽ được chuyển tiếp mail đến địa chỉ `root@` và `postmaster@`. Sử dụng tài khoản chính của bạn cho việc này. Trong trường hợp ví dụ này, **sammy**.
* **Other destinations to accept mail for** (Các điểm đến khác để chấp nhận mail): Điều này xác định các điểm đến mail mà phiên bản Postfix này sẽ chấp nhận. Nếu bạn cần thêm bất kỳ miền nào khác mà máy chủ này sẽ chịu trách nhiệm nhận, hãy thêm những miền đó tại đây. Nếu không, mặc định sẽ là đủ.
* **Force synchronous updates on mail queue?** (Buộc cập nhật đồng bộ trên hàng đợi mail?): Vì có khả năng bạn đang sử dụng hệ thống tệp được ghi nhật ký, hãy chấp nhận **No** ở đây.
* **Local networks** (Mạng cục bộ): Đây là danh sách các mạng mà máy chủ mail của bạn được định cấu hình để chuyển tiếp thư. Mặc định sẽ hoạt động cho hầu hết các tình huống. Tuy nhiên, nếu bạn chọn sửa đổi nó, hãy đảm bảo rất hạn chế về phạm vi mạng.
* **Mailbox size limit** (Giới hạn kích thước hộp thư): Điều này có thể được sử dụng để giới hạn kích thước của thư. Đặt nó thành `0` sẽ vô hiệu hóa mọi hạn chế về kích thước.
* **Local address extension character** (Ký tự mở rộng địa chỉ cục bộ): Đây là ký tự có thể được sử dụng để phân tách phần thông thường của địa chỉ khỏi phần mở rộng (được sử dụng để tạo bí danh động). Mặc định, `+` sẽ hoạt động cho hướng dẫn này.
* **Internet protocols to use** (Giao thức Internet sẽ sử dụng): Chọn có hạn chế phiên bản IP mà Postfix hỗ trợ. Đối với mục đích của hướng dẫn này, hãy chọn **all**.

Nói rõ hơn, đây là các cài đặt được sử dụng trong hướng dẫn này:

* **General type of mail configuration?**: **Internet Site**
* **System mail name**: `<^>example.com<^>` (không phải `<^>mail.example.com<^>`)
* **Root and postmaster mail recipient**: Tên người dùng của tài khoản Linux chính của bạn (**sammy** trong các ví dụ của chúng tôi)
* **Other destinations to accept mail for**: `$myhostname, <^>example.com<^>, <^>mail.example.com<^>, <^>localhost.example.com<^>, localhost`
* **Force synchronous updates on mail queue?**: **No**
* **Local networks**: `127.0.0.0/8 [::ffff:127.0.0.0]/104 [::1]/128`
* **Mailbox size limit**: `0`
* **Local address extension character**: `+`
* **Internet protocols to use**: **all**

<$>[note]
**Lưu ý:** Nếu bạn cần quay lại để thay đổi các cài đặt này, bạn có thể thực hiện bằng cách nhập:
```command
sudo dpkg-reconfigure postfix
```

Lời nhắc sẽ được điền sẵn các câu trả lời trước đó của bạn.
<$>

Khi bạn được nhắc khởi động lại dịch vụ, hãy chấp nhận các giá trị mặc định và chọn `OK`.

Khi quá trình cài đặt kết thúc, bạn đã sẵn sàng thực hiện một vài cập nhật cho cấu hình Postfix của mình.

## Bước 2 — Thay đổi cấu hình Postfix

Giờ đây, bạn có thể điều chỉnh một số cài đặt mà quá trình cài đặt gói không nhắc bạn. Nhiều cài đặt cấu hình của Postfix được xác định trong tệp `/etc/postfix/main.cf`. Thay vì chỉnh sửa tệp này trực tiếp, bạn có thể sử dụng lệnh `postconf` của Postfix để truy vấn hoặc đặt cài đặt cấu hình.

Để bắt đầu, hãy đặt vị trí cho hộp thư của non-root Ubuntu user của bạn. Trong hướng dẫn này, chúng tôi sẽ sử dụng định dạng *Maildir*, định dạng này sẽ phân tách thư thành các tệp riêng lẻ, sau đó được di chuyển giữa các thư mục dựa trên hành động của người dùng. Tùy chọn thay thế không được đề cập trong hướng dẫn này là định dạng *mbox*, định dạng lưu trữ tất cả thư trong một tệp.

Đặt biến `home_mailbox` thành `Maildir/`. Sau đó, bạn sẽ tạo cấu trúc thư mục dưới tên đó trong thư mục chính của người dùng. Định cấu hình `home_mailbox` bằng cách nhập:
```command
sudo postconf -e 'home_mailbox= Maildir/'
```

Tiếp theo, đặt vị trí của bảng `virtual_alias_maps`, bảng ánh xạ các tài khoản email tùy ý sang các tài khoản hệ thống Linux. Chạy lệnh sau, lệnh này ánh xạ vị trí bảng tới tệp cơ sở dữ liệu băm có tên `/etc/postfix/virtual`:
```command
sudo postconf -e 'virtual_alias_maps= hash:/etc/postfix/virtual'
```

Bây giờ bạn đã xác định vị trí của tệp bản đồ ảo trong tệp `main.cf` của mình, bạn có thể tự tạo tệp đó và bắt đầu ánh xạ tài khoản email tới tài khoản người dùng trên hệ thống Linux của mình. Tạo tệp bằng trình soạn thảo văn bản ưa thích của bạn; trong ví dụ này, chúng tôi sẽ sử dụng `nano`:
```command
sudo nano /etc/postfix/virtual
```

Liệt kê bất kỳ địa chỉ nào mà bạn muốn chấp nhận email, theo sau là khoảng trắng và người dùng Linux mà bạn muốn thư đó được gửi đến.

Ví dụ: nếu bạn muốn chấp nhận email tại `contact@<^>example.com<^>` và `admin@<^>example.com<^>` và muốn những email đó được gửi tới **sammy** Linux user, bạn có thể thiết lập tệp của mình như sau:
```nginx
[label /etc/postfix/virtual]
contact@<^>example.com<^> sammy
admin@<^>example.com<^> sammy
```

Sau khi bạn đã ánh xạ tất cả các địa chỉ tới các tài khoản máy chủ thích hợp, hãy lưu và đóng tệp. Nếu bạn đã sử dụng `nano`, hãy thực hiện việc này bằng cách nhấn `CTRL + X`, `Y`, rồi `ENTER`.

Áp dụng ánh xạ bằng cách gõ:
```command
sudo postmap /etc/postfix/virtual
```

Khởi động lại quy trình Postfix để đảm bảo rằng tất cả các thay đổi của bạn đã được áp dụng:
```command
sudo systemctl restart postfix
```

Giả sử bạn đã làm theo hướng dẫn Thiết lập Máy chủ Ban đầu tiên quyết, bạn sẽ cấu hình tường lửa với UFW. Theo mặc định, tường lửa này sẽ chặn các kết nối bên ngoài tới các dịch vụ trên máy chủ của bạn trừ khi các kết nối đó được cho phép một cách rõ ràng, do đó, bạn sẽ phải thêm một quy tắc tường lửa để cho phép một ngoại lệ cho Postfix.

Bạn có thể cho phép kết nối với dịch vụ bằng cách gõ:
```command
sudo ufw allow Postfix
```

Cùng với đó, Postfix được cấu hình và sẵn sàng chấp nhận các kết nối bên ngoài. Tuy nhiên, bạn vẫn chưa sẵn sàng để thử nghiệm nó với mail client. Trước khi bạn có thể cài đặt ứng dụng khách và sử dụng nó để tương tác với thư được gửi đến máy chủ của mình, bạn cần thực hiện một số thay đổi đối với thiết lập máy chủ Ubuntu của mình.

## Bước 3 — Cài đặt mail client và khởi tạo cấu trúc Maildir

Để tương tác với thư được gửi, bước này sẽ hướng dẫn bạn quá trình cài đặt gói `s-nail`. Đây là một biến thể giàu tính năng của BSD `xmail` client có thể xử lý chính xác định dạng Maildir.

Tuy nhiên, trước khi cài đặt ứng dụng khách, bạn nên thận trọng đảm bảo biến môi trường `MAIL` của mình được đặt chính xác. `s-nail` sẽ tìm biến này để tìm ra nơi tìm thư cho người dùng của bạn.

Để đảm bảo rằng biến `MAIL` được đặt bất kể bạn truy cập tài khoản của mình bằng cách nào — chẳng hạn như thông qua `ssh`, `su`, `su -` hoặc `sudo` — bạn sẽ cần đặt biến trong tệp `/etc/bash.bashrc` và thêm nó vào một tệp trong `/etc/profile.d` để đảm bảo rằng nó được đặt cho tất cả người dùng theo mặc định.

Để thêm biến vào các tệp này, hãy nhập:
```command
echo 'export MAIL=~/Maildir' | sudo tee -a /etc/bash.bashrc | sudo tee -a /etc/profile.d/mail.sh
```

Để đọc biến vào phiên hiện tại của bạn, hãy tìm nguồn tệp `/etc/profile.d/mail.sh`:
```command
source /etc/profile.d/mail.sh
```

Khi hoàn tất, hãy cài đặt email client `s-nail` với APT:
```command
sudo apt install s-nail
```

Trước khi chạy ứng dụng khách, bạn cần điều chỉnh một vài cài đặt. Mở tệp `/etc/s-nail.rc` trong trình chỉnh sửa của bạn:
```command
sudo nano /etc/s-nail.rc
```

Ở dưới cùng của tệp, thêm các tùy chọn sau:
```nginx
[label /etc/s-nail.rc]
. . .
set emptystart
set folder=Maildir
set record=+sent
```

Đây là những gì những dòng này làm:

* `set emptystart`: cho phép máy khách mở ngay cả khi hộp thư đến trống
* `set folder=Maildir`: đặt thư mục `Maildir` thành biến `folder` nội bộ
* `set record=+sent` tạo một tệp mbox `sent` để lưu trữ thư đã gửi trong bất kỳ thư mục nào được đặt làm biến `folder`, trong trường hợp này là `Maildir`

Lưu và đóng tệp khi bạn hoàn tất. Bây giờ bạn đã sẵn sàng khởi tạo cấu trúc Maildir của hệ thống.

Một cách nhanh chóng để tạo cấu trúc Maildir trong thư mục chính của bạn là gửi email cho chính bạn bằng lệnh `s-nail`. Vì tệp `sent` sẽ chỉ khả dụng sau khi Maildir được tạo, bạn nên tắt tính năng ghi vào tệp cho email ban đầu này. Thực hiện việc này bằng cách chuyển tùy chọn `-Snorecord`.

Gửi email bằng cách chuyển một chuỗi tới lệnh `s-nail`. Điều chỉnh lệnh để đánh dấu người dùng Linux của bạn là người nhận:
```command
echo 'init' | s-nail -s 'init' -Snorecord <^>sammy<^>
```

<$>[note]
**Lưu ý:** Bạn *có thể* nhận được phản hồi sau:
```
[secondary_label Output]
Can't canonicalize "/home/<^>sammy<^>/Maildir"
```

Điều này là bình thường và có thể chỉ xuất hiện khi gửi tin nhắn đầu tiên này.
<$>

Bạn có thể kiểm tra để đảm bảo thư mục đã được tạo bằng cách tìm thư mục `~/Maildir` của mình:
```command
ls -R ~/Maildir
```

Bạn sẽ thấy cấu trúc thư mục đã được tạo và một tệp tin nhắn mới nằm trong thư mục `~/Maildir/new`:
```
[secondary_label Output]
/home/<^>sammy<^>/Maildir/:
cur  new  tmp

/home/<^>sammy<^>/Maildir/cur:

/home/<^>sammy<^>/Maildir/new:
1650294586.Vfc01I7e11dM993645.mail.<^>example.com<^>

/home/<^>sammy<^>/Maildir/tmp:
```

Bây giờ cấu trúc thư mục đã được tạo, bạn đã sẵn sàng kiểm tra ứng dụng khách `s-nail` bằng cách xem tin nhắn `init` bạn đã gửi và gửi tin nhắn đến một địa chỉ email bên ngoài.

## Bước 4 - Kiểm tra ứng dụng khách

Để mở ứng dụng khách, hãy chạy lệnh `s-nail`:
```command
s-nail
```

Trong bảng điều khiển của mình, bạn sẽ thấy một hộp thư đến thô sơ với thông báo `init` đang chờ:
```
[secondary_label Output]
s-nail version v14.9.15.  Type `?' for help
"/home/sammy/Maildir": 1 message 1 new
>N  1 sammy@example.com     2022-04-18 15:09   14/452   init
```

Nhấn `ENTER` để hiển thị thông báo:
```
[secondary_label Output]
[-- Message  1 -- 14 lines, 452 bytes --]:
Date: Mon, 18 Apr 2022 15:09:46 +0000
To: sammy@example.com
Subject: init
Message-Id: <20220418150946.EE6897E11A@@mail.example.com>
From: sammy@example.com

init
```

Bạn có thể quay lại danh sách tin nhắn bằng cách nhập `h`, rồi `ENTER`:
```custom_prefix(?)
h
```

```
[secondary_label Output]
>R  1 sammy@example.com     2022-04-18 15:09   14/452   init
```

Lưu ý rằng tin nhắn hiện có trạng thái `R`, cho biết rằng nó đã được đọc.

Vì thông báo này không hữu ích lắm nên bạn có thể xóa nó bằng cách nhấn `d`, rồi `ENTER`:
```custom_prefix(?)
d
```

Để quay lại terminal, gõ `q` rồi `ENTER`:

```custom_prefix(?)
q
```

Là thử nghiệm cuối cùng, hãy kiểm tra xem `s-nail` có thể gửi email chính xác hay không. Để thực hiện việc này, bạn có thể đưa nội dung của tệp văn bản vào quy trình `s-nail`, giống như bạn đã làm với thông báo `init` mà bạn đã gửi ở bước trước.

Bắt đầu bằng cách viết một tin nhắn thử nghiệm trong trình soạn thảo văn bản:
```command
nano ~/test_message
```

Bên trong, nhập một số văn bản bạn muốn gửi:
```nginx
[label ~/test_message]
Hello,

This is a test.  Please confirm receipt!
```

Lưu và đóng tệp sau khi viết tin nhắn của bạn.

Sau đó, sử dụng lệnh `cat` để gửi thông báo tới quy trình `s-nail`. Bạn có thể làm như vậy với ví dụ sau, sử dụng các tùy chọn này:

* `-s`: Điều này xác định dòng chủ đề của thông báo email
* `-r`: Một thay đổi tùy chọn đối với trường “From:” của email. Theo mặc định, người dùng Linux mà bạn đã đăng nhập sẽ được sử dụng để điền vào trường này. Tùy chọn `-r` cho phép bạn ghi đè địa chỉ này bằng một địa chỉ hợp lệ, chẳng hạn như một trong những địa chỉ bạn đã xác định trong tệp `etc/postfix/virtual`. Để minh họa, lệnh sau sử dụng `contact@example.com`

Ngoài ra, hãy đảm bảo thay đổi `<^>user<^>@<^>email.com<^>` thành địa chỉ email hợp lệ mà bạn có quyền truy cập:
```command
cat ~/<^>test_message<^> | s-nail -s '<^>Test email subject line<^>' -r <^>contact@example.com<^> <^>user<^>@<^>email.com<^>
```

Sau đó, điều hướng đến hộp thư đến cho địa chỉ email mà bạn đã gửi tin nhắn. Bạn sẽ thấy tin nhắn của mình đang chờ ở đó gần như ngay lập tức.

<$>[note]
**Lưu ý:** Nếu thư không có trong hộp thư đến của bạn, thì thư đó có thể đã được chuyển đến thư mục Thư rác.
<$>

Bạn có thể xem các tin nhắn đã gửi trong ứng dụng khách `s-nail` của mình. Bắt đầu lại ứng dụng khách tương tác:
```command
s-nail
```

Từ ứng dụng email, xem thư đã gửi của bạn bằng cách nhập:
```custom_prefix(?)
file +sent
```

Bạn sẽ thấy đầu ra như thế này:
```
[secondary_label Output]
+[/home/sammy/Maildir/]sent: 1 message 1 new
▸N  1 To contact@example.com 2022-04-18 15:12   10/211   Test email subject line 
```

Bạn có thể quản lý thư đã gửi bằng các lệnh giống như bạn sử dụng cho thư đến.

## Kết luận

Bây giờ bạn đã cấu hình Postfix trên máy chủ Ubuntu 22.04 của mình. Quản lý máy chủ email có thể là một nhiệm vụ khó khăn đối với quản trị viên hệ thống mới, nhưng với cấu hình này, bạn sẽ có đủ chức năng email MTA để bắt đầu.

Cách cài đặt và định cấu hình Postfix trên Ubuntu 22.04

## Giới thiệu

SSH, hoặc vỏ bảo mật, là một giao thức được mã hóa được sử dụng để quản trị và liên lạc với các máy chủ. Khi làm việc với máy chủ Ubuntu, rất có thể bạn sẽ dành phần lớn thời gian của mình cho phiên cuối được kết nối với máy chủ của bạn thông qua SSH.

Trong hướng dẫn này, chúng tôi sẽ tập trung vào việc thiết lập các SSH key để cài đặt Ubuntu 20.04. Các SSH key cung cấp một cách an toàn để đăng nhập vào máy chủ của bạn và được khuyến nghị cho tất cả người dùng.

## Bước 1 — Tạo cặp key

Bước đầu tiên là tạo một cặp key trên máy khách (thường là máy tính của bạn):
```command
ssh-keygen
```

Theo mặc định, các phiên bản gần đây của `ssh-keygen` sẽ tạo cặp key RSA 3072 bit, đủ an toàn cho hầu hết các trường hợp sử dụng (bạn có thể tùy chọn chuyển cờ `-b 4096` để tạo key 4096 bit lớn hơn).

Sau khi nhập lệnh, bạn sẽ thấy đầu ra sau:
```
[secondary_label Output]
Generating public/private rsa key pair.
Enter file in which to save the key (/<^>your_home<^>/.ssh/id_rsa):
```

Nhấn enter để lưu cặp key vào thư mục con `.ssh/` trong thư mục chính của bạn hoặc chỉ định một đường dẫn thay thế.

Nếu trước đó bạn đã tạo một cặp SSH key, bạn có thể thấy lời nhắc sau:
```
[secondary_label Output]
/home/<^>your_home<^>/.ssh/id_rsa already exists.
Overwrite (y/n)?
```

Nếu bạn chọn ghi đè lên key trên đĩa, bạn sẽ **không** thể xác thực bằng key trước đó nữa. Hãy thật cẩn thận khi chọn có, vì đây là một quá trình phá hoại không thể đảo ngược.

Sau đó, bạn sẽ thấy lời nhắc sau:
```
[secondary_label Output]
Enter passphrase (empty for no passphrase):
```

Tại đây, bạn có thể tùy chọn nhập cụm mật khẩu an toàn, điều này rất được khuyến khích. Cụm mật khẩu thêm một lớp bảo mật bổ sung để ngăn người dùng trái phép đăng nhập. Để tìm hiểu thêm về bảo mật, hãy tham khảo hướng dẫn của chúng tôi về Cách định cấu hình xác thực dựa trên SSH key trên máy chủ Linux.

Sau đó, bạn sẽ thấy đầu ra tương tự như sau:
```
[secondary_label Output]
Your identification has been saved in /<^>your_home<^>/.ssh/id_rsa
Your public key has been saved in /<^>your_home<^>/.ssh/id_rsa.pub
The key fingerprint is:
SHA256:/hk7MJ5n5aiqdfTVUZr+2Qt+qCiS7BIm5Iv0dxrc3ks user@host
The key's randomart image is:
+---[RSA 3072]----+
|                .|
|               + |
|              +  |
| .           o . |
|o       S   . o  |
| + o. .oo. ..  .o|
|o = oooooEo+ ...o|
|.. o *o+=.*+o....|
|    =+=ooB=o.... |
+----[SHA256]-----+
```

Bây giờ bạn có public và private key mà bạn có thể sử dụng để xác thực. Bước tiếp theo là đặt public key trên máy chủ của bạn để bạn có thể sử dụng xác thực dựa trên SSH key để đăng nhập.

## Bước 2 - Sao chép public key vào máy chủ Ubuntu của bạn

Cách nhanh nhất để sao chép public key của bạn vào máy chủ Ubuntu là sử dụng tiện ích có tên `ssh-copy-id`. Do tính đơn giản của nó, phương pháp này rất được khuyến khích nếu có. Nếu bạn không có sẵn `ssh-copy-id` trên máy khách của mình, bạn có thể sử dụng một trong hai phương pháp thay thế được cung cấp trong phần này (sao chép qua SSH dựa trên mật khẩu hoặc sao chép key theo cách thủ công).

### Sao chép public key bằng `ssh-copy-id`

Công cụ `ssh-copy-id` được bao gồm theo mặc định trong nhiều hệ điều hành, vì vậy bạn có thể có sẵn công cụ này trên hệ thống cục bộ của mình. Để phương pháp này hoạt động, bạn phải có quyền truy cập SSH dựa trên mật khẩu vào máy chủ của mình.

Để sử dụng tiện ích, bạn chỉ định máy chủ từ xa mà bạn muốn kết nối và tài khoản người dùng mà bạn có quyền truy cập SSH dựa trên mật khẩu. Đây là tài khoản mà public SSH key của bạn sẽ được sao chép vào.

Cú pháp là:
```command
ssh-copy-id <^>username<^>@<^>remote_host<^>
```

Bạn có thể thấy thông báo sau:
```
[secondary_label Output]
The authenticity of host '<^>203.0.113.1<^> (<^>203.0.113.1<^>)' can't be established.
ECDSA key fingerprint is fd:fd:d4:f9:77:fe:73:84:e1:55:00:ad:d6:6d:22:fe.
Are you sure you want to continue connecting (yes/no)? <^>yes<^>
```

Điều này có nghĩa là máy tính cục bộ của bạn không nhận ra máy chủ từ xa. Điều này sẽ xảy ra trong lần đầu tiên bạn kết nối với một máy chủ mới. Nhập “yes” và nhấn `ENTER` để tiếp tục.

Tiếp theo, tiện ích sẽ quét tài khoản cục bộ của bạn để tìm `id_rsa.pub` key mà chúng tôi đã tạo trước đó. Khi tìm thấy key, nó sẽ nhắc bạn nhập mật khẩu của tài khoản người dùng từ xa:
```
[secondary_label Output]
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
<^>username<^>@<^>203.0.113.1<^>'s password:
```

Nhập mật khẩu (việc nhập của bạn sẽ không được hiển thị, vì mục đích bảo mật) và nhấn `ENTER`. Tiện ích sẽ kết nối với tài khoản trên máy chủ từ xa bằng mật khẩu bạn đã cung cấp. Sau đó, nó sẽ sao chép nội dung của `~/.ssh/id_rsa.pub` key của bạn vào một tệp trong thư mục `~/.ssh` chính của tài khoản từ xa được gọi là `authorized_keys`.

Bạn sẽ thấy đầu ra sau:
```
[secondary_label Output]
Number of key(s) added: 1

Now try logging into the machine, with:   "ssh '<^>username<^>@<^>203.0.113.1<^>'"
and check to make sure that only the key(s) you wanted were added.
```

Tại thời điểm này, khóa `id_rsa.pub` của bạn đã được tải lên tài khoản từ xa. Bạn có thể tiếp tục sang Bước 3.

### Sao chép public key bằng SSH

Nếu bạn không có sẵn `ssh-copy-id`, nhưng bạn có quyền truy cập SSH dựa trên mật khẩu vào tài khoản trên máy chủ của mình, thì bạn có thể tải các key của mình lên bằng phương pháp SSH thông thường.

Chúng ta có thể thực hiện việc này bằng cách sử dụng lệnh `cat` để đọc nội dung của public SSH key trên máy tính cục bộ của mình và chuyển nội dung đó thông qua kết nối SSH đến máy chủ từ xa.

Mặt khác, chúng tôi có thể đảm bảo rằng thư mục `~/.ssh` tồn tại và có quyền chính xác trong tài khoản chúng tôi đang sử dụng.

Sau đó, chúng tôi có thể xuất nội dung mà chúng tôi đã chuyển thành một tệp có tên `authorized_keys` trong thư mục này. Chúng tôi sẽ sử dụng biểu tượng chuyển hướng `>>` để nối thêm nội dung thay vì ghi đè lên nội dung đó. Điều này sẽ cho phép chúng tôi thêm các key mà không hủy các key đã thêm trước đó.

Lệnh đầy đủ trông như thế này:
```command
cat ~/.ssh/id_rsa.pub | ssh <^>username<^>@<^>remote_host<^> "mkdir -p ~/.ssh && touch ~/.ssh/authorized_keys && chmod -R go= ~/.ssh && cat >> ~/.ssh/authorized_keys"
```

Bạn có thể thấy thông báo sau:
```
[secondary_label Output]
The authenticity of host '<^>203.0.113.1<^> (<^>203.0.113.1<^>)' can't be established.
ECDSA key fingerprint is fd:fd:d4:f9:77:fe:73:84:e1:55:00:ad:d6:6d:22:fe.
Are you sure you want to continue connecting (yes/no)? <^>yes<^>
```

Điều này có nghĩa là máy tính cục bộ của bạn không nhận ra máy chủ từ xa. Điều này sẽ xảy ra trong lần đầu tiên bạn kết nối với một máy chủ mới. Nhập `yes` và nhấn `ENTER` để tiếp tục.

Sau đó, bạn sẽ được nhắc nhập mật khẩu tài khoản người dùng từ xa:
```
[secondary_label Output]
<^>username<^>@<^>203.0.113.1<^>'s password:
```

Sau khi nhập mật khẩu của bạn, nội dung `id_rsa.pub` key của bạn sẽ được sao chép vào cuối tệp ủy quyền của tài khoản người dùng từ xa. Tiếp tục sang Bước 3 nếu điều này thành công.

### Sao chép public key theo cách thủ công

Nếu bạn không có quyền truy cập SSH dựa trên mật khẩu vào máy chủ của mình, bạn sẽ phải hoàn tất quy trình trên theo cách thủ công.

Chúng tôi sẽ nối thủ công nội dung tệp `id_rsa.pub` của bạn vào tệp `~/.ssh/authorized_keys` trên máy từ xa của bạn.

Để hiển thị nội dung của `id_rsa.pub` key, hãy nhập nội dung này vào máy tính cục bộ của bạn:
```command
cat ~/.ssh/id_rsa.pub
```

Bạn sẽ thấy nội dung của key, nội dung này sẽ giống như thế này:
```
[secondary_label Output]
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQCqql6MzstZYh1TmWWv11q5O3pISj2ZFl9HgH1JLknLLx44+tXfJ7mIrKNxOOwxIxvcBF8PXSYvobFYEZjGIVCEAjrUzLiIxbyCoxVyle7Q+bqgZ8SeeM8wzytsY+dVGcBxF6N4JS+zVk5eMcV385gG3Y6ON3EG112n6d+SMXY0OEBIcO6x+PnUSGHrSgpBgX7Ks1r7xqFa7heJLLt2wWwkARptX7udSq05paBhcpB0pHtA1Rfz3K2B+ZVIpSDfki9UVKzT8JUmwW6NNzSgxUfQHGwnW7kj4jp4AT0VZk3ADw497M2G/12N0PPB5CnhHf7ovgy6nL1ikrygTKRFmNZISvAcywB9GVqNAVE+ZHDSCuURNsAInVzgYo9xgJDW8wUw2o8U77+xiFxgI5QSZX3Iq7YLMgeksaO4rBJEa54k8m5wEiEE1nUhLuJ0X/vh2xPff6SQ1BL/zkOhvJCACK6Vb15mDOeCSq54Cr7kvS46itMosi/uS66+PujOO+xt/2FWYepz6ZlN70bRly57Q06J+ZJoc9FfBCbCyYH7U/ASsmY095ywPsBo1XQ9PqhnN1/YOorJ068foQDNVpm146mUpILVxmq41Cj55YKHEazXGsdBIbXWhcrRf4G2fJLRcGUr9q8/lERo9oxRm5JFX6TCmj6kmiFqv+Ow9gI0x8GvaQ== demo@test
```

Truy cập máy chủ từ xa của bạn bằng bất kỳ phương pháp nào bạn có sẵn.

Khi bạn có quyền truy cập vào tài khoản của mình trên máy chủ từ xa, bạn nên đảm bảo rằng thư mục `~/.ssh` tồn tại. Lệnh này sẽ tạo thư mục nếu cần hoặc không làm gì nếu nó đã tồn tại:
```command
mkdir -p ~/.ssh
```

Bây giờ, bạn có thể tạo hoặc sửa đổi tệp `authorized_keys` trong thư mục này. Bạn có thể thêm nội dung của tệp `id_rsa.pub` vào cuối tệp `authorized_keys`, tạo tệp nếu cần bằng cách sử dụng lệnh này:
```command
echo <^>public_key_string<^> >> ~/.ssh/authorized_keys
```

Trong lệnh trên, hãy thay thế `<^>public_key_string<^>` bằng đầu ra từ lệnh `cat ~/.ssh/id_rsa.pub` mà bạn đã thực thi trên hệ thống cục bộ của mình. Nó sẽ bắt đầu với `ssh-rsa AAAA...`.

Cuối cùng, chúng tôi sẽ đảm bảo rằng thư mục `~/.ssh` và tệp `authorized_keys` có các quyền thích hợp được đặt:
```command
chmod -R go= ~/.ssh
```

Thao tác này sẽ xóa một cách đệ quy tất cả các quyền “group” và “other” đối với thư mục `~/.ssh/`.

Nếu bạn đang sử dụng tài khoản **root** để thiết lập key cho tài khoản người dùng, điều quan trọng là thư mục `~/.ssh` thuộc về người dùng chứ không phải **root**:
```command
chown -R <^>sammy<^>:<^>sammy<^> ~/.ssh
```

Trong hướng dẫn này, người dùng của chúng ta có tên là <^>sammy<^> nhưng bạn nên thay thế tên người dùng thích hợp vào lệnh trên.

Bây giờ chúng tôi có thể thử xác thực không cần mật khẩu với máy chủ Ubuntu của mình.

## Bước 3 - Xác thực với máy chủ Ubuntu của bạn bằng các SSH key

Nếu bạn đã hoàn tất thành công một trong các quy trình trên, bạn sẽ có thể đăng nhập vào máy chủ từ xa mà *không cần* cung cấp mật khẩu của tài khoản từ xa.

Quá trình cơ bản là như nhau:
```command
ssh <^>username<^>@<^>remote_host<^>
```

Nếu đây là lần đầu tiên bạn kết nối với máy chủ này (nếu bạn đã sử dụng phương pháp cuối cùng ở trên), bạn có thể thấy nội dung như sau:
```
[secondary_label Output]
The authenticity of host '<^>203.0.113.1<^> (<^>203.0.113.1<^>)' can't be established.
ECDSA key fingerprint is fd:fd:d4:f9:77:fe:73:84:e1:55:00:ad:d6:6d:22:fe.
Are you sure you want to continue connecting (yes/no)? <^>yes<^>
```

Điều này có nghĩa là máy tính cục bộ của bạn không nhận ra máy chủ từ xa. Nhập “yes” rồi nhấn `ENTER` để tiếp tục.

Nếu bạn không cung cấp cụm mật khẩu cho private key của mình, bạn sẽ đăng nhập ngay lập tức. Nếu bạn đã cung cấp cụm mật khẩu cho private key khi tạo key, bạn sẽ được nhắc nhập mật khẩu đó ngay bây giờ (lưu ý rằng tổ hợp phím của bạn sẽ không hiển thị trong phiên cuối để bảo mật). Sau khi xác thực, một phiên shell mới sẽ mở ra cho bạn với tài khoản được định cấu hình trên máy chủ Ubuntu.

Nếu xác thực dựa trên key thành công, hãy tiếp tục tìm hiểu cách tăng cường bảo mật cho hệ thống của bạn bằng cách tắt xác thực mật khẩu.

## Bước 4 — Vô hiệu hóa xác thực mật khẩu trên máy chủ của bạn

Nếu bạn có thể đăng nhập vào tài khoản của mình bằng SSH mà không cần mật khẩu, thì bạn đã định cấu hình thành công xác thực dựa trên SSH key cho tài khoản của mình. Tuy nhiên, cơ chế xác thực dựa trên mật khẩu của bạn vẫn hoạt động, có nghĩa là máy chủ của bạn vẫn có nguy cơ bị tấn công brute-force.

Trước khi hoàn thành các bước trong phần này, hãy đảm bảo rằng bạn đã định cấu hình xác thực dựa trên SSH key cho tài khoản **root** trên máy chủ này hoặc tốt hơn là bạn đã định cấu hình xác thực dựa trên SSH key cho tài khoản không phải root trên máy chủ này máy chủ có đặc quyền `sudo`. Bước này sẽ khóa thông tin đăng nhập dựa trên mật khẩu, vì vậy việc đảm bảo rằng bạn vẫn có thể có quyền truy cập quản trị là rất quan trọng.

Khi bạn đã xác nhận rằng tài khoản từ xa của mình có đặc quyền quản trị, hãy đăng nhập vào máy chủ từ xa bằng SSH key, với quyền **root** hoặc bằng tài khoản có đặc quyền `sudo`. Sau đó, mở tệp cấu hình của SSH daemon:
```command
sudo nano /etc/ssh/sshd_config
```

Bên trong tệp, tìm kiếm lệnh có tên là `PasswordAuthentication`. Dòng này có thể được nhận xét bằng dấu `#` ở đầu dòng. Bỏ ghi chú dòng bằng cách xóa `#` và đặt giá trị thành `no`. Điều này sẽ vô hiệu hóa khả năng đăng nhập của bạn qua SSH bằng mật khẩu tài khoản:
```nginx
[label /etc/ssh/sshd_config]
. . .
PasswordAuthentication no
. . .
```

Lưu và đóng tệp khi bạn hoàn tất bằng cách nhấn `CTRL+X`, sau đó nhấn `Y` để xác nhận lưu tệp và cuối cùng là `ENTER` để thoát nano. Để thực sự kích hoạt những thay đổi này, chúng ta cần khởi động lại dịch vụ `sshd`:
```command
sudo systemctl restart ssh
```

Để đề phòng, hãy mở một cửa sổ đầu cuối mới và kiểm tra xem dịch vụ SSH có hoạt động bình thường không trước khi đóng phiên hiện tại của bạn:
```command
ssh <^>username<^>@<^>remote_host<^>
```

Khi bạn đã xác minh rằng dịch vụ SSH của mình đang hoạt động bình thường, bạn có thể đóng tất cả các phiên máy chủ hiện tại một cách an toàn.

Trình nền SSH trên máy chủ Ubuntu của bạn hiện chỉ phản hồi xác thực dựa trên SSH key. Đăng nhập dựa trên mật khẩu đã bị vô hiệu hóa.

## Kết luận

Bây giờ, bạn đã định cấu hình xác thực dựa trên SSH key trên máy chủ của mình, cho phép bạn đăng nhập mà không cần cung cấp mật khẩu tài khoản.

Nếu bạn muốn tìm hiểu thêm về cách làm việc với SSH, hãy xem Hướng dẫn cơ bản về SSH của chúng tôi.

Cách thiết lập SSH key trên Ubuntu 20.04

## Giới thiệu

Khi thiết lập máy chủ web, thường có các phần của trang web mà bạn muốn hạn chế quyền truy cập. Các ứng dụng web thường cung cấp các phương thức xác thực và ủy quyền của riêng chúng, nhưng bản thân máy chủ web có thể được sử dụng để hạn chế quyền truy cập nếu những phương thức này không đầy đủ hoặc không khả dụng. Trong hướng dẫn này, bạn sẽ bảo vệ tài sản bằng mật khẩu trên máy chủ web Nginx chạy trên Ubuntu 20.04.

## Điều kiện tiên quyết

Để bắt đầu, bạn sẽ cần:

* Truy cập vào môi trường máy chủ Ubuntu 20.04 với non-**root** user có đặc quyền `sudo` để thực hiện các tác vụ quản trị. Để tìm hiểu cách tạo một người dùng như vậy, hãy làm theo hướng dẫn thiết lập máy chủ ban đầu của Ubuntu 20.04.
* Nginx được cài đặt trên hệ thống của bạn, làm theo **Bước 1 và 2** của hướng dẫn này về cách cài đặt Nginx trên Ubuntu 20.04.

## Bước 1 — Tạo tệp mật khẩu

Để bắt đầu, bạn cần tạo một tệp chứa tổ hợp tên người dùng và mật khẩu của mình. Bạn có thể làm điều này bằng cách sử dụng các tiện ích OpenSSL có thể đã có sẵn trên máy chủ của bạn. Ngoài ra, bạn có thể sử dụng tiện ích `htpasswd` chuyên dụng có trong gói `apache2-utils` (các tệp mật khẩu Nginx sử dụng cùng định dạng với Apache). Chọn phương pháp dưới đây mà bạn thích nhất.

### Tùy chọn 1 — Tạo tệp mật khẩu bằng tiện ích OpenSSL

Nếu bạn đã cài đặt OpenSSL trên máy chủ của mình, bạn có thể tạo tệp mật khẩu mà không cần gói bổ sung. Bạn sẽ tạo một tệp ẩn có tên `.htpasswd` trong thư mục cấu hình `/etc/nginx` để lưu trữ kết hợp tên người dùng và mật khẩu của bạn.

Bạn có thể thêm tên người dùng vào tệp bằng lệnh này. `sammy` được sử dụng ở đây làm tên người dùng, nhưng bạn có thể sử dụng bất kỳ tên nào bạn muốn:
```command
sudo sh -c "echo -n '<^>sammy<^>:' >> /etc/nginx/.htpasswd"
```

Tiếp theo, thêm mục nhập mật khẩu được mã hóa cho tên người dùng bằng cách nhập:
```command
sudo sh -c "openssl passwd -apr1 >> /etc/nginx/.htpasswd"
```

Bạn có thể lặp lại quy trình này để có thêm tên người dùng. Bạn có thể xem cách tên người dùng và mật khẩu được mã hóa được lưu trữ trong tệp bằng cách nhập:
```command
cat /etc/nginx/.htpasswd
```

```
[secondary_label Output]
sammy:$apr1$wI1/T0nB$jEKuTJHkTOOWkopnXqC1d1
```

## Tùy chọn 2 — Tạo tệp mật khẩu bằng tiện ích Apache

Mặc dù OpenSSL có thể mã hóa mật khẩu để xác thực Nginx, nhiều người dùng thấy việc sử dụng tiện ích được xây dựng có mục đích dễ dàng hơn. Tiện ích `htpasswd`, được tìm thấy trong gói `apache2-utils`, phục vụ tốt chức năng này.

Cài đặt gói `apache2-utils` trên máy chủ của bạn bằng cách gõ:
```command
sudo apt update
sudo apt install apache2-utils
```

Bây giờ, bạn có quyền truy cập vào lệnh `htpasswd`. Bạn có thể sử dụng điều này để tạo một tệp mật khẩu mà Nginx có thể sử dụng để xác thực người dùng. Tạo một tệp ẩn cho mục đích này có tên là `.htpasswd` trong thư mục cấu hình `/etc/nginx` của bạn.

Lần đầu tiên sử dụng tiện ích này, bạn cần thêm tùy chọn `-c` để tạo tệp được chỉ định. Chỉ định tên người dùng (`sammy` trong ví dụ này) ở cuối lệnh để tạo một mục mới trong tệp:
```command
sudo htpasswd -c /etc/nginx/.htpasswd <^>sammy<^>
```

Bạn sẽ được yêu cầu cung cấp và xác nhận mật khẩu cho người dùng.

Bỏ qua đối số `-c` cho bất kỳ người dùng bổ sung nào bạn muốn thêm:
```command
sudo htpasswd /etc/nginx/.htpasswd <^>another_user<^>
```

Nếu bạn xem nội dung của tệp, bạn có thể thấy tên người dùng và mật khẩu được mã hóa cho từng bản ghi:
```command
cat /etc/nginx/.htpasswd
```

```
[secondary_label Output]
sammy:$apr1$lzxsIfXG$tmCvCfb49vpPFwKGVsuYz.
another_user:$apr1$p1E9MeAf$kiAhneUwr.MhAE2kKGYHK.
```

## Bước 2 - Định cấu hình xác thực mật khẩu Nginx

Bây giờ bạn có một tệp chứa người dùng và mật khẩu ở định dạng mà Nginx có thể đọc, bạn cần định cấu hình Nginx để kiểm tra tệp này trước khi cung cấp nội dung được bảo vệ của bạn.

Bắt đầu bằng cách mở tệp cấu hình khối máy chủ mà bạn muốn thêm hạn chế vào. Ví dụ của bạn, bạn sẽ sử dụng tệp khối máy chủ `default` được cài đặt thông qua gói Nginx của Ubuntu:
```command
sudo nano /etc/nginx/sites-enabled/<^>default<^>
```

Để thiết lập xác thực, bạn cần quyết định bối cảnh cần hạn chế. Trong số các lựa chọn khác, Nginx cho phép bạn đặt các hạn chế ở cấp độ máy chủ hoặc bên trong một vị trí cụ thể.

Ví dụ này sẽ dành cho giới hạn ở cấp độ máy chủ. Lệnh `auth_basic` bật xác thực và tên miền sẽ được hiển thị cho người dùng khi nhắc nhập thông tin đăng nhập. Bạn sẽ sử dụng chỉ thị `auth_basic_user_file` để trỏ Nginx đến tệp mật khẩu bạn đã tạo:
```nginx
[label /etc/nginx/sites-enabled/default]
server {
    listen 80 default_server;

     . . .
   
    <^>auth_basic "Restricted Content";<^>
    <^>auth_basic_user_file /etc/nginx/.htpasswd;<^>
}
```

<$>[note]
**Lưu ý:** Tùy thuộc vào khối mà bạn đặt các hạn chế, bạn có thể kiểm soát mức độ chi tiết của những phần nào trên trang web của bạn yêu cầu mật khẩu. Ví dụ thay thế này chỉ hạn chế thư mục gốc có khối vị trí và thậm chí bạn có thể sửa đổi danh sách này để chỉ nhắm mục tiêu một thư mục cụ thể trong không gian web:
```nginx
[label /etc/nginx/sites-enabled/default]
server {
    listen 80 default_server;

     . . .
   
    location / {
    try_files $uri $uri/ =404;
    <^>auth_basic "Restricted Content";<^>
    <^>auth_basic_user_file /etc/nginx/.htpasswd;<^>
    }
}
```
<$>

Lưu và đóng tệp khi bạn hoàn tất. Khởi động lại Nginx để thực hiện chính sách mật khẩu của bạn:
```command
sudo systemctl restart nginx
```

Thư mục bạn đã chỉ định bây giờ sẽ được bảo vệ bằng mật khẩu.

## Bước 3 — Xác nhận Xác thực Mật khẩu

Để xác nhận rằng nội dung của bạn được bảo vệ, hãy thử truy cập nội dung bị hạn chế của bạn trong trình duyệt web:
```custom_prefix()
http://server_domain_or_IP
```

Bạn sẽ được cung cấp lời nhắc tên người dùng và mật khẩu:

![description image](https://media.cloudfly.vn/posts/password_prompt.png)

Nếu bạn nhập đúng thông tin đăng nhập, bạn sẽ được phép truy cập nội dung. Nếu bạn nhập sai thông tin đăng nhập hoặc nhấn “Cancel”, bạn sẽ thấy trang lỗi “Authorization Required”:

![description image](https://media.cloudfly.vn/posts/unauthorized_error.png)

## Kết luận

Bây giờ bạn đã có mọi thứ cần thiết để thiết lập xác thực cơ bản cho trang web của mình. Hãy nhớ rằng bảo vệ bằng mật khẩu nên được kết hợp với mã hóa TLS để thông tin đăng nhập của bạn không được gửi đến máy chủ ở dạng văn bản thuần túy. Hãy xem hướng dẫn này về cách bảo mật Nginx với Let's Encrypt trên Ubuntu 20.04

Cách thiết lập xác thực mật khẩu với Nginx trên Ubuntu 20.04

## Giới thiệu

Khi quyết định sử dụng kiến trúc máy chủ nào cho môi trường của bạn, có nhiều yếu tố cần xem xét, chẳng hạn như hiệu suất, khả năng mở rộng, tính khả dụng, độ tin cậy, chi phí và quản lý.

Trong hướng dẫn này, bạn sẽ tìm hiểu về các thiết lập máy chủ thường được sử dụng, với một mô tả ngắn về từng thiết lập, bao gồm ưu và nhược điểm. Hãy nhớ rằng tất cả các khái niệm được đề cập ở đây có thể được sử dụng theo nhiều cách kết hợp với nhau và mọi môi trường đều có các yêu cầu khác nhau, vì vậy không có cấu hình chính xác duy nhất.

## Thiết lập mọi thứ trên một máy chủ

Thiết lập một máy chủ là khi toàn bộ môi trường nằm trên một máy chủ. Đối với một ứng dụng web điển hình, điều này bao gồm máy chủ web, máy chủ ứng dụng và máy chủ cơ sở dữ liệu. Một biến thể phổ biến của thiết lập này là LAMP stack, viết tắt của **L**inux, **A**pache, **M**ySQL và **P**HP, trên một máy chủ. Một trường hợp sử dụng ví dụ cho điều này là khi bạn muốn thiết lập một ứng dụng nhanh chóng. Một thiết lập cơ bản như thế này có thể được sử dụng để thử nghiệm một ý tưởng hoặc thiết lập và chạy một trang web đơn giản.

Thật không may, điều này cung cấp rất ít khả năng mở rộng và cách ly thành phần. Ngoài ra, ứng dụng và cơ sở dữ liệu tranh giành các tài nguyên máy chủ giống nhau như CPU, Bộ nhớ, I/O, v.v. Do đó, điều này có thể gây ra hiệu suất kém và gây khó khăn cho việc xác định nguyên nhân gốc rễ. Sử dụng một máy chủ cũng không dễ dàng mở rộng theo chiều ngang. Bạn có thể tìm hiểu thêm về chia tỷ lệ theo chiều ngang trong hướng dẫn của chúng tôi về Hiểu cơ sở dữ liệu Sharding. Tìm hiểu thêm về LAMP stack cũng như trong hướng dẫn của chúng tôi về Cách cài đặt LAMP trên Ubuntu 22.04. Sau đây là một đại diện trực quan của việc sử dụng một máy chủ duy nhất:

![description image](https://media.cloudfly.vn/posts/u-single_server.png)

## Thiết lập một máy chủ cơ sở dữ liệu riêng biệt

Hệ thống quản lý cơ sở dữ liệu (DBMS) có thể được tách biệt khỏi phần còn lại của môi trường để loại bỏ sự tranh chấp tài nguyên giữa ứng dụng và cơ sở dữ liệu, đồng thời để tăng cường bảo mật bằng cách xóa cơ sở dữ liệu khỏi DMZ hoặc internet công cộng.

Một trường hợp sử dụng ví dụ là điều này có thể giúp ứng dụng của bạn được thiết lập nhanh chóng và ngăn không cho ứng dụng và cơ sở dữ liệu tranh giành cùng một tài nguyên hệ thống. Bạn cũng có thể chia tỷ lệ theo chiều dọc cho từng tầng ứng dụng và cơ sở dữ liệu riêng biệt. Điều này có thể thực hiện được bằng cách thêm nhiều tài nguyên hơn vào bất kỳ máy chủ nào cần tăng dung lượng. Tùy thuộc vào thiết lập của bạn, điều này cũng có thể tăng cường bảo mật bằng cách xóa cơ sở dữ liệu của bạn khỏi DMZ.

Thiết lập này phức tạp hơn một chút so với một máy chủ. Các vấn đề về hiệu suất, chẳng hạn như độ trễ cao, có thể phát sinh nếu kết nối mạng giữa hai máy chủ cách xa nhau về mặt địa lý. Cũng có thể có vấn đề về hiệu suất nếu băng thông quá thấp so với lượng dữ liệu được truyền. Bạn có thể đọc thêm về Cách thiết lập cơ sở dữ liệu từ xa để tối ưu hóa hiệu suất trang web với MySQL. Sau đây là một minh họa trực quan về việc sử dụng một máy chủ cơ sở dữ liệu riêng biệt:

![description image](https://media.cloudfly.vn/posts/u-separate_database.png)

## Thiết lập cân bằng tải (Proxy ngược)

Bộ cân bằng tải (Load balancers) có thể được thêm vào môi trường máy chủ để cải thiện hiệu suất và độ tin cậy bằng cách phân phối khối lượng công việc trên nhiều máy chủ. Nếu một trong các máy chủ cân bằng tải bị lỗi, các máy chủ khác sẽ xử lý lưu lượng truy cập đến cho đến khi máy chủ bị lỗi hoạt động bình thường trở lại. Nó cũng có thể được sử dụng để phục vụ nhiều ứng dụng thông qua cùng một miền và cổng, bằng cách sử dụng proxy ngược lớp ứng dụng lớp 7. Một số loại phần mềm có khả năng cân bằng tải proxy ngược là HAProxy, Nginx và Varnish.

Một trường hợp sử dụng ví dụ là trong một môi trường yêu cầu mở rộng quy mô bằng cách thêm nhiều máy chủ hơn, còn được gọi là thay đổi quy mô theo chiều ngang (*horizontal scaling*). Khi bạn thiết lập bộ cân bằng tải, bộ cân bằng tải sẽ cho phép dung lượng môi trường có thể được điều chỉnh theo quy mô bằng cách thêm nhiều máy chủ hơn vào dung lượng đó. Nó cũng có thể bảo vệ chống lại các cuộc tấn công DDOS bằng cách giới hạn các kết nối máy khách ở một số lượng và tần suất hợp lý.

Việc thiết lập bộ cân bằng tải có thể gây ra tắc nghẽn hiệu suất nếu bộ cân bằng tải không có đủ tài nguyên hoặc nếu bộ cân bằng tải được định cấu hình kém. Nó cũng có thể đưa ra những vấn đề phức tạp cần xem xét thêm, chẳng hạn như nơi thực hiện chấm dứt SSL và cách xử lý các ứng dụng yêu cầu các phiên cố định. Ngoài ra, bộ cân bằng tải là một điểm lỗi duy nhất, điều này có nghĩa là nếu nó gặp sự cố, toàn bộ dịch vụ của bạn có thể ngừng hoạt động. Thiết lập tính sẵn sàng cao (*high availability* - HA) là cơ sở hạ tầng không có một điểm lỗi nào. Để tìm hiểu cách triển khai thiết lập HA, bạn có thể đọc tài liệu của chúng tôi về Reserved IPs. Bạn cũng có thể đọc thêm trong hướng dẫn của chúng tôi về Giới thiệu về HAProxy và Cân bằng tải. Sau đây là phần trình bày trực quan về cách thiết lập bộ cân bằng tải:

![description image](https://media.cloudfly.vn/posts/u-load_balancer.png)

## Thiết lập Trình tăng tốc HTTP (Proxy đảo ngược bộ đệm)

Có thể sử dụng trình tăng tốc HTTP hoặc proxy ngược HTTP lưu vào bộ đệm ẩn để giảm thời gian cần thiết để cung cấp nội dung cho người dùng thông qua nhiều kỹ thuật khác nhau. Kỹ thuật chính được sử dụng với trình tăng tốc HTTP là lưu các phản hồi từ máy chủ web hoặc ứng dụng vào bộ nhớ đệm, vì vậy các yêu cầu trong tương lai cho cùng một nội dung có thể được phục vụ nhanh chóng, với ít tương tác không cần thiết hơn với máy chủ web hoặc ứng dụng. Một vài ví dụ về phần mềm có khả năng tăng tốc HTTP là Varnish, Squid, Nginx. Một trường hợp sử dụng ví dụ là trong môi trường có các ứng dụng web động chứa nhiều nội dung hoặc nhiều tệp thường được truy cập.

Tăng tốc HTTP có thể tăng hiệu suất trang web bằng cách giảm tải CPU trên máy chủ web, thông qua bộ nhớ đệm và nén, do đó tăng dung lượng người dùng. Nó cũng có thể được sử dụng làm cân bằng tải proxy ngược và một số phần mềm bộ nhớ đệm thậm chí có thể bảo vệ chống lại các cuộc tấn công DDOS. Thật không may, nó có thể làm giảm hiệu suất nếu tỷ lệ truy cập vào bộ nhớ cache thấp và yêu cầu điều chỉnh để đạt được hiệu suất tốt nhất từ nó. Sau đây là phần trình bày trực quan về việc thiết lập Trình tăng tốc HTTP:

![description image](https://media.cloudfly.vn/posts/u-http_accelerator.png)

## Thiết lập sao chép cơ sở dữ liệu bản sao chính

Một cách để cải thiện hiệu suất cho hệ thống cơ sở dữ liệu thực hiện nhiều lần đọc so với ghi, chẳng hạn như CMS, là sử dụng sao chép cơ sở dữ liệu bản sao chính. Bản sao yêu cầu một node chính và một hoặc nhiều node bản sao. Trong thiết lập này, tất cả các bản cập nhật được gửi đến node chính và các lần đọc có thể được phân phối trên tất cả các node. Một trường hợp sử dụng ví dụ là tăng hiệu suất đọc của tầng cơ sở dữ liệu của một ứng dụng. Việc thiết lập bản sao cơ sở dữ liệu bản sao chính giúp cải thiện hiệu suất đọc cơ sở dữ liệu bằng cách phân bổ số lần đọc trên các bản sao và cải thiện hiệu suất ghi bằng cách sử dụng riêng cho các bản cập nhật mà không mất thời gian cho việc phục vụ các yêu cầu đọc.

Một số nhược điểm đối với sao chép cơ sở dữ liệu bản sao chính là ứng dụng truy cập cơ sở dữ liệu phải có cơ chế xác định node cơ sở dữ liệu nào sẽ gửi yêu cầu cập nhật và đọc tới. Ngoài ra, nếu lỗi chính, không thể thực hiện cập nhật trên cơ sở dữ liệu cho đến khi sự cố được khắc phục. Nó cũng không có tính năng chuyển đổi dự phòng tích hợp trong trường hợp node chính bị lỗi. Sau đây là phần trình bày trực quan về thiết lập sao chép bản sao chính, với một node bản sao duy nhất:

![description image](https://media.cloudfly.vn/posts/u-primary_replica_database_replication.png)

## Kết hợp các khái niệm

Có thể cân bằng tải cho các máy chủ bộ nhớ đệm, ngoài các máy chủ ứng dụng và sử dụng sao chép cơ sở dữ liệu trong một môi trường duy nhất. Mục đích của việc kết hợp các kỹ thuật này là để gặt hái những lợi ích của từng kỹ thuật mà không gây ra quá nhiều vấn đề hoặc sự phức tạp. Dưới đây là một sơ đồ ví dụ về loại môi trường máy chủ được thiết lập:

![description image](https://media.cloudfly.vn/posts/u-combined.png)

Ví dụ: hãy tưởng tượng một kịch bản trong đó bộ cân bằng tải được định cấu hình để nhận dạng các yêu cầu tĩnh (như hình ảnh, CSS, JavaScript, v.v.) và gửi các yêu cầu đó trực tiếp đến máy chủ bộ nhớ đệm, đồng thời gửi các yêu cầu khác đến máy chủ ứng dụng.

Dưới đây là bảng phân tích quy trình khi người dùng gửi yêu cầu về nội dung động:

1. Người dùng yêu cầu nội dung động từ **http://<^>example.com<^>/** (bộ cân bằng tải)
2. Bộ cân bằng tải gửi yêu cầu đến phụ trợ ứng dụng
3. Ứng dụng phụ trợ đọc từ cơ sở dữ liệu và trả lại nội dung được yêu cầu cho bộ cân bằng tải
4. Bộ cân bằng tải trả về dữ liệu được yêu cầu cho người dùng

Khi người dùng yêu cầu nội dung tĩnh, quy trình sau sẽ được áp dụng:

1. Bộ cân bằng tải kiểm tra cache-backend để xác nhận xem nội dung được yêu cầu có được lưu vào bộ đệm (cache-hit) hay không (cache-miss)
2. Nếu nội dung bị truy cập vào bộ đệm, điều này có nghĩa là nó sẽ trả lại nội dung được yêu cầu cho bộ cân bằng tải và chuyển đến bước cuối cùng trong quy trình và trả lại dữ liệu cho người dùng. Nếu nội dung bị lỗi bộ đệm, máy chủ bộ đệm sẽ chuyển tiếp yêu cầu đến phụ trợ ứng dụng thông qua bộ cân bằng tải
3. Bộ cân bằng tải chuyển tiếp yêu cầu đến phụ trợ ứng dụng
4. Ứng dụng phụ trợ đọc từ cơ sở dữ liệu và trả lại nội dung được yêu cầu cho bộ cân bằng tải
5. Bộ cân bằng tải chuyển tiếp phản hồi tới cache-backend
6. Cache-backend lưu trữ nội dung và trả về bộ cân bằng tải
7. Bộ cân bằng tải trả về dữ liệu được yêu cầu cho người dùng

Môi trường này vẫn có hai điểm lỗi duy nhất, bộ cân bằng tải và máy chủ cơ sở dữ liệu chính, nhưng nó cung cấp tất cả các lợi ích về hiệu suất và độ tin cậy khác đã được mô tả trong các phần trước.

## Kết luận

Bây giờ bạn đã quen thuộc với một số thiết lập máy chủ cơ bản, bạn nên biết rõ về loại thiết lập nào bạn sẽ sử dụng cho (các) ứng dụng của riêng mình. Nếu bạn đang làm việc để cải thiện môi trường của chính mình, hãy nhớ rằng một quy trình lặp đi lặp lại là tốt nhất để tránh đưa ra quá nhiều điều phức tạp một cách quá nhanh chóng.

5 thiết lập máy chủ phổ biến cho ứng dụng web của bạn

Cách thiết lập cơ sở dữ liệu từ xa để tối ưu hóa hiệu suất trang web với MySQL trên Ubuntu 20.04

Category

Category

Cách cài đặt và định cấu hình Ansible trên Ubuntu 20.04

Cách sử dụng Ansible để tự động thiết lập máy chủ ban đầu trên Ubuntu 20.04

Cách thiết lập Django với Postgres, Nginx và Gunicorn trên Ubuntu 20.04

Cách bảo vệ máy chủ Nginx với Fail2Ban trên Ubuntu 14.04

Cách bảo mật Apache với Let's Encrypt trên Ubuntu 20.04

Cách cài đặt máy chủ web Apache trên Ubuntu 20.04

Cách lưu trữ trang web bằng Cloudflare và Nginx trên Ubuntu 20.04

Cách cài đặt và định cấu hình Postfix trên Ubuntu 22.04

Cách thiết lập SSH key trên Ubuntu 20.04

Cách thiết lập xác thực mật khẩu với Nginx trên Ubuntu 20.04

5 thiết lập máy chủ phổ biến cho ứng dụng web của bạn

Cách thiết lập cơ sở dữ liệu từ xa để tối ưu hóa hiệu suất trang web với MySQL trên Ubuntu 20.04

Cloud Server

Load Balancer

Dedicated Server

Colocation Server

Block Storage

Object Storage

Category

Category

Technical Articles

Cách cài đặt và định cấu hình Ansible trên Ubuntu 20.04

Cách sử dụng Ansible để tự động thiết lập máy chủ ban đầu trên Ubuntu 20.04

Cách thiết lập Django với Postgres, Nginx và Gunicorn trên Ubuntu 20.04

Cách bảo vệ máy chủ Nginx với Fail2Ban trên Ubuntu 14.04

Cách bảo mật Apache với Let's Encrypt trên Ubuntu 20.04

Cách cài đặt máy chủ web Apache trên Ubuntu 20.04

Cách lưu trữ trang web bằng Cloudflare và Nginx trên Ubuntu 20.04

Cách cài đặt và định cấu hình Postfix trên Ubuntu 22.04

Cách thiết lập SSH key trên Ubuntu 20.04

Cách thiết lập xác thực mật khẩu với Nginx trên Ubuntu 20.04

5 thiết lập máy chủ phổ biến cho ứng dụng web của bạn

Cách thiết lập cơ sở dữ liệu từ xa để tối ưu hóa hiệu suất trang web với MySQL trên Ubuntu 20.04

Cloud Server

Load Balancer

Dedicated Server

Colocation Server

Block Storage

Object Storage