## Giới thiệu
Docker đơn giản hóa quá trình quản lý các quy trình ứng dụng trong vùng chứa. Các vùng chứa giống với máy ảo trong một số điểm, chúng nhẹ hơn và thân thiện với tài nguyên hơn. Điều này cho phép các nhà phát triển chia nhỏ môi trường ứng dụng thành nhiều dịch vụ riêng biệt.

Đối với các ứng dụng phụ thuộc vào một số dịch vụ, việc sắp xếp tất cả các vùng chứa để khởi động, giao tiếp và tắt cùng nhau có thể trở nên khó sử dụng. Docker Compose là một công cụ cho phép bạn chạy các môi trường ứng dụng multi-container (nhiều vùng chứa) dựa trên các định nghĩa được đặt trong tệp YAML. Nó sử dụng các định nghĩa dịch vụ để xây dựng các môi trường hoàn toàn có thể tùy chỉnh với nhiều vùng chứa, có thể chia sẻ mạng và data volumes.

Trong hướng dẫn này, bạn sẽ được hướng dẫn cách cài đặt Docker Compose trên máy chủ Ubuntu 20.04 và cách bắt đầu sử dụng công cụ này.

## Điều kiện 
Để thực hiện theo bài viết này, bạn sẽ cần:

* Truy cập vào máy cục bộ hoặc máy chủ phát triển Ubuntu 20.04 với tư cách là non-root user có các đặc quyền sudo. Nếu bạn đang sử dụng máy chủ từ xa, bạn nên cài đặt tường lửa đang hoạt động. Để thiết lập những điều này, vui lòng tham khảo Hướng dẫn cài đặt máy chủ ban đầu cho Ubuntu 20.04 của chúng tôi.
* Docker được cài đặt trên máy chủ hoặc máy cục bộ của bạn, làm theo **Bước 1 và 2** của Cách cài đặt và sử dụng Docker trên Ubuntu 20.04.

<$>[note]
**Lưu ý:** Bài viết này sẽ hướng dẫn bạn cài đặt Docker Compose v1, sử dụng `docker-compose`. Với Docker Compose v2, Docker đã chuyển sang sử dụng lệnh `compose` CLI plugin như được ghi lại trong phiên bản Ubuntu 22.04 mới nhất của hướng dẫn này và khác với bản gốc `docker-compose`. Mặc dù cách cài đặt khác nhau, nhưng nhìn chung, việc sử dụng thực tế liên quan đến việc bỏ dấu gạch nối từ cách gọi `docker-compose` trở thành `docker compose`. Để biết đầy đủ chi tiết về khả năng tương thích, hãy kiểm tra tài liệu Docker chính thức về khả năng tương thích của lệnh giữa `compose` mới và `docker-compose` cũ.
<$>

## Bước 1: Cài đặt Docker Compose
Để đảm bảo có được phiên bản Docker Compose ổn định nhất được cập nhật, bạn sẽ tải xuống phần mềm này từ kho lưu trữ Github chính thức của nó.

Trước tiên, hãy xác nhận phiên bản mới nhất hiện có trong trang phát hành của họ. Tại thời điểm viết bài này, phiên bản ổn định nhất hiện tại là `1.29.2`.

Lệnh dưới đây sẽ tải xuống bản phát hành `1.29.2` và lưu tệp thực thi tại `/usr/local/bin/docker-comp`, điều này sẽ làm cho phần mềm có thể truy cập toàn cầu dưới dạng `docker-compose`:
```command
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
```
Tiếp theo, hãy đặt các quyền chính xác để lệnh `docker-compose` có thể thực thi được:
```command
sudo chmod +x /usr/local/bin/docker-compose
```
Để xác minh rằng cài đặt thành công, bạn có thể chạy:
```command
docker-compose --version
```
Bạn sẽ thấy đầu ra tương tự như sau:
```
[secondary_label Output]
docker-compose version <^>1.29.2<^>, build 5becea4c
```
Docker Compose hiện đã được cài đặt thành công trên hệ thống của bạn. Trong phần tiếp theo, bạn sẽ thấy cách thiết lập tệp `docker-compose.yml`, thiết lập một môi trường chứa và chạy với công cụ này.

## Bước 2: Thiết lập tệp `docker-compose.yml`
Để trình bày cách thiết lập tệp `docker-compose.yml` và làm việc với Docker Compose, bạn sẽ tạo môi trường máy chủ web bằng cách sử dụng hình ảnh Nginx chính thức từ Docker Hub, cơ quan đăng ký Docker công khai. Môi trường được chứa này sẽ phân phát một tệp HTML tĩnh duy nhất.

Bắt đầu bằng cách tạo một thư mục mới trong thư mục chính của bạn, sau đó chuyển nó vào:
```command
mkdir <^>~/compose-demo<^>
cd <^>~/compose-demo<^>
```
Trong thư mục này, hãy thiết lập một thư mục ứng dụng để làm tài liệu gốc cho môi trường Nginx của bạn:
```command
mkdir <^>app<^>
```
Sử dụng trình soạn thảo văn bản ưa thích của bạn, tạo tệp `index.html` mới trong thư mục `app`:
```command
nano app/index.html
```
Đặt nội dung dưới đây vào tệp này:

```nginx
[label ~/compose-demo/app/index.html]
<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Docker Compose Demo</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kognise/water.css@latest/dist/dark.min.css">
</head>
<body>

    <h1>This is a Docker Compose Demo Page.</h1>
    <p>This content is being served by an Nginx container.</p>

</body>
</html>3
```

Lưu và đóng tệp khi bạn hoàn tất. Nếu bạn đang sử dụng `nano`, bạn có thể làm điều đó bằng cách gõ `CTRL + X`, sau đó là `Y` và `ENTER` để xác nhận.

Tiếp theo, tạo tệp `docker-compose.yml`:
```command
nano docker-compose.yml
```
Chèn nội dung sau vào tệp `docker-compose.yml` của bạn:

```nginx
[label docker-compose.yml]
version: '3.7'
services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html
```

Tệp `docker-compose.yml` thường bắt đầu bằng `version`. Thao tác này sẽ cho Docker Compose biết bạn đang sử dụng phiên bản cấu hình nào.

Sau đó, bạn có khối `services`, nơi bạn thiết lập các dịch vụ là một phần của môi trường này. Trong trường hợp của bạn, bạn có một dịch vụ duy nhất được gọi là `web`. Dịch vụ này sử dụng hình ảnh `nginx:alpine` và thiết lập chuyển hướng cổng với chỉ thị `ports`. Tất cả các yêu cầu trên cổng `8000` của máy chủ (hệ thống từ nơi bạn đang chạy Docker Compose) sẽ được chuyển hướng đến vùng chứa `web` trên cổng `80`, nơi Nginx sẽ chạy.

Chỉ thị `volumes` sẽ tạo một shared volume giữa máy chủ và bộ chứa. Thao tác này sẽ chia sẻ thư mục cục bộ `app` với vùng chứa, và volume sẽ được đặt tại `/usr/share/nginx/html` bên trong vùng chứa, sau đó sẽ ghi đè lên tài liệu gốc mặc định cho Nginx.

Lưu và đóng tập tin.

Bạn đã thiết lập một trang demo và một tệp `docker-compose.yml` để tạo một môi trường máy chủ web được chứa đựng để phục vụ nó. Trong bước tiếp theo, bạn sẽ xây dựng môi trường này với Docker Compose.

## Bước 3: Chạy Docker Compose
Với tệp `docker-compose.yml`, bây giờ bạn có thể thực hiện Docker Compose để đưa môi trường của bạn lên. Lệnh dưới đây sẽ tải xuống các hình ảnh Docker cần thiết, tạo vùng chứa cho dịch vụ `web` và chạy môi trường được chứa trong chế độ nền:
```command
docker-compose up -d
```
Docker Compose trước tiên sẽ tìm kiếm hình ảnh đã xác định trên hệ thống cục bộ của bạn và nếu nó không thể tìm thấy hình ảnh, nó sẽ tải xuống từ Docker Hub. Bạn sẽ thấy đầu ra như thế này:
```
[secondary_label Output]
Creating network "<^>compose-demo_default<^>" with the default driver
Pulling web (nginx:alpine)...
alpine: Pulling from library/nginx
cbdbe7a5bc2a: Pull complete
10c113fb0c77: Pull complete
9ba64393807b: Pull complete
c829a9c40ab2: Pull complete
61d685417b2f: Pull complete
Digest: sha256:57254039c6313fe8c53f1acbf15657ec9616a813397b74b063e32443427c5502
Status: Downloaded newer image for nginx:alpine
Creating <^>compose-demo_web_1<^> ... done
```

<$>[note]
**Lưu ý:** Nếu bạn gặp lỗi quyền liên quan đến Docker socket, điều này có nghĩa là bạn đã bỏ qua Bước 2 của Cách cài đặt và sử dụng Docker trên Ubuntu 20.04. Quay lại và hoàn thành bước đó để cho phép quyền chạy các lệnh của docker mà không cần `sudo`.
<$>

Môi trường của bạn hiện đang hoạt động trong nền. Để xác minh rằng vùng chứa đang hoạt động, bạn có thể chạy:
```command
docker-compose ps
```
Lệnh này sẽ hiển thị cho bạn thông tin về các vùng chứa đang chạy và trạng thái của chúng, cũng như bất kỳ chuyển hướng cổng nào hiện đang diễn ra:
```
[secondary_label Output]
       Name                     Command               State          Ports        
----------------------------------------------------------------------------------
<^>compose-demo_web_1<^>   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:8000->80/tcp
```
Giờ đây, bạn có thể truy cập ứng dụng demo bằng cách trỏ trình duyệt của mình tới `localhost: 8000` nếu bạn đang chạy bản demo này trên máy cục bộ của mình hoặc `<^>your_server_domain_or_IP<^>: 8000` nếu bạn đang chạy bản demo này trên máy chủ từ xa.

Bạn sẽ thấy một trang như thế này:
![description image](https://media.cloudfly.vn/posts/cach-cai-dat-va-su-dung-Docker-Compose-tren-Ubuntu-20.04_2.png)

Shared volume mà bạn đã thiết lập trong tệp `docker-compose.yml` giữ các tệp thư mục ứng dụng của bạn đồng bộ hóa với tệp gốc tài liệu của vùng chứa. Nếu bạn thực hiện bất kỳ thay đổi nào đối với tệp `index.html`, chúng sẽ được vùng chứa tự động chọn và do đó được phản ánh trên trình duyệt của bạn khi bạn tải lại trang.

Trong bước tiếp theo, bạn sẽ thấy cách quản lý môi trường được chứa bằng các lệnh Docker Compose.
## Bước 4: Làm quen với các lệnh Docker Compose 
Bạn đã biết cách thiết lập tệp `docker-compose.yml` và thiết lập môi trường của bạn với `docker-compose up`. Bây giờ, bạn sẽ thấy cách sử dụng lệnh Docker Compose để quản lý và tương tác với môi trường được chứa trong vùng chứa của bạn.

Để kiểm tra nhật ký được tạo bởi vùng chứa Nginx của bạn, bạn có thể sử dụng lệnh `logs`:
```command
docker-compose logs
```
Bạn sẽ thấy đầu ra tương tự như sau:
```
[secondary_label Output]
Attaching to <^>compose-demo_web_1<^>
web_1  | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
web_1  | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
web_1  | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf
web_1  | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
web_1  | /docker-entrypoint.sh: Configuration complete; ready for start up
web_1  | 172.22.0.1 - - [02/Jun/2020:10:47:13 +0000] "GET / HTTP/1.1" 200 353 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" "-"
```
Nếu bạn muốn tạm dừng thực hiện môi trường mà không thay đổi trạng thái hiện tại của vùng chứa, bạn có thể sử dụng:
```command
docker-compose pause
```
```
[secondary_label Output]
Pausing <^>compose-demo_web_1<^> ... done
```
Để tiếp tục thực hiện sau khi tạm dừng:
```command
docker-compose unpause
```
```
[secondary_label Output]
Unpausing <^>compose-demo_web_1<^> ... done
```
Lệnh `stop` sẽ chấm dứt việc thực thi vùng chứa, nhưng nó sẽ không phá hủy bất kỳ dữ liệu nào được liên kết với vùng chứa của bạn
```command
docker-compose stop
```
```
[secondary_label Output]
Stopping <^>compose-demo_web_1<^> ... done
```
Nếu bạn muốn xóa các vùng chứa, mạng và ổ đĩa được liên kết với môi trường được chứa trong vùng chứa này, hãy sử dụng lệnh `down`:
```command
docker-compose down
```
```
[secondary_label Output]
Removing <^>compose-demo_web_1<^> ... done
Removing network <^>compose-demo_default<^>
```
Lưu ý rằng điều này sẽ không xóa hình ảnh cơ sở được Docker Compose sử dụng để tạo ra môi trường của bạn (trong trường hợp của bạn là `nginx:alpine`). Bằng cách này, bất cứ khi nào bạn làm cho môi trường của mình hoạt động trở lại với `docker-compose up`, quá trình này sẽ nhanh hơn nhiều vì hình ảnh đã có trên hệ thống của bạn.

Trong trường hợp bạn cũng muốn xóa hình ảnh cơ sở khỏi hệ thống của mình, bạn có thể sử dụng:
```command
docker image rm nginx:alpine
```
```
[secondary_label Output]
Untagged: nginx:alpine
Untagged: nginx@sha256:b89a6ccbda39576ad23fd079978c967cecc6b170db6e7ff8a769bf2259a71912
Deleted: sha256:7d0cdcc60a96a5124763fddf5d534d058ad7d0d8d4c3b8be2aefedf4267d0270
Deleted: sha256:05a0eaca15d731e0029a7604ef54f0dda3b736d4e987e6ac87b91ac7aac03ab1
Deleted: sha256:c6bbc4bdac396583641cb44cd35126b2c195be8fe1ac5e6c577c14752bbe9157
Deleted: sha256:35789b1e1a362b0da8392ca7d5759ef08b9a6b7141cc1521570f984dc7905eb6
Deleted: sha256:a3efaa65ec344c882fe5d543a392a54c4ceacd1efd91662d06964211b1be4c08
Deleted: sha256:3e207b409db364b595ba862cdc12be96dcdad8e36c59a03b7b3b61c946a5741a
```

<$>[note]
**Lưu ý:** Vui lòng tham khảo hướng dẫn của chúng tôi về Cách cài đặt và sử dụng Docker để biết chi tiết hơn về các lệnh Docker.
<$>

## Kết luận
Trong hướng dẫn này, bạn đã thấy cách cài đặt Docker Compose và thiết lập môi trường được chứa trong vùng chứa dựa trên hình ảnh máy chủ web Nginx. Bạn cũng đã thấy cách quản lý môi trường này bằng cách sử dụng lệnh Compose.

Để có tài liệu tham khảo đầy đủ về tất cả các lệnh `docker-compose` có sẵn, hãy kiểm tra tài liệu chính thức (official documentation).

Nếu bạn quan tâm đến các cách sử dụng khác của Docker Compose, hãy xem Cách cài đặt WordPress với Docker Compose và cả Cách bảo mật ứng dụng Node.js được chứa bằng Nginx, Let’s Encrypt và Docker Compose.

Cách cài đặt và sử dụng Docker Compose trên Ubuntu 20.04

Cách cài đặt Gitea trên Ubuntu bằng Docker

## Giới thiệu
Trên Ubuntu, máy chủ web Apache phục vụ các tài liệu được lưu trữ mặc định trong thư mục `var / www / html`. Thư mục này được gọi là **thư mục gốc** (DocumentRoot) của tài liệu. Khi quản trị viên hoặc người dùng đưa ra yêu cầu đối với máy chủ, máy chủ sẽ phản hồi với các tệp thích hợp từ tài liệu gốc này.
Thư mục này thường nằm trên hệ thống tệp gốc cùng với phần còn lại của hệ điều hành. Tuy nhiên, đôi khi, sẽ thật hữu ích nếu bạn di chuyển tài gốc liệu sang một vị trí khác, chẳng hạn như hệ thống tệp được gắn kết một cách riêng biệt. Ví dụ: nếu bạn phân phối nhiều trang web từ cùng một phiên bản Apache, việc đặt các tài liệu liệu của mỗi trang web trên khối lượng riêng của nó cho phép bạn mở rộng quy mô để đáp ứng nhu cầu của một trang web hoặc khách hàng cụ thể. 
Trong hướng dẫn này, bạn sẽ di chuyển gốc tài liệu Apache từ vị trí mặc định của nó là `var / www / html` sang một vị trí mới.
## Điều kiện
* Máy chủ Ubuntu 20.04 và người dùng không phải **root** có đặc quyền sudo.
* Cài đặt sẵn Apache trên máy chủ của bạn. 
* SSL được định cấu hình cho tên miền của bạn. 
* Một vị trí mới cho tài liệu gốc của bạn. Trong bài hướng dẫn này, `/ mnt / volume_nyc3_01` được sử dụng làm thư mục cho vị trí mới này. Mặc dù các hướng dẫn trong bài này sử dụng ví dụ về thiết bị lưu trữ khối được gắn kết, bạn có thể sử dụng bất kỳ vị trí thư mục nào trên hệ thống của mình làm nơi lưu trữ thư mục gốc mới để phục vụ nội dung web của bạn.

<$>[info]
Vị trí lưu trữ tài liệu gốc mới của bạn có thể được định cấu hình dựa trên nhu cầu của bạn. Nếu bạn đang di chuyển thư mục gốc của mình sang một thiết bị lưu trữ khác, bạn sẽ muốn chọn một vị trí bên dưới điểm gắn kết của thiết bị.
<$>

## Bước 1: Sao chép tệp sang một vị trí mới
Nếu bạn đã làm theo các hướng dẫn tiên quyết, bạn sẽ tạo được một tài liệu gốc mới tại `/ var / www / <^>your_domain<^>`. Bạn cũng có thể có một thư mục gốc bổ sung tại `VirtualHost` tương ứng. Điều quan trọng là phải thiết lập vị trí của thư mục gốc hiện tại của bạn trước khi bạn sao chép các tệp có liên quan sang vị trí mới của chúng.

Tìm kiếm vị trí thư mục gốc của bạn bằng cách sử dụng lệnh `grep` để tìm kiếm trong thư mục `/ etc / apache2 / sites-enable`. Điều này giới hạn sự tập trung vào các trang đang hoạt động. `-R` đảm bảo rằng `gre`p sẽ in cả `DocumentRoot `và tên tệp đầy đủ trong đầu ra:
```custom_prefix($)
grep -R "DocumentRoot" /etc/apache2/sites-enabled
```

Kết quả sau cho biết vị trí của `DocumentRoot` hiện tại của bạn:
```
[secondary_label Output]
/etc/apache2/sites-enabled/<^>your_domain<^>-le-ssl.conf:  DocumentRoot /var/www/<^>your_domain<^>
/etc/apache2/sites-enabled/<^>your_domain<^>.conf:         DocumentRoot /var/www/<^>your_domain<^>
```

Nếu bạn đã thiết lập sẵn, kết quả của bạn có thể khác với những gì được hiển thị ở đây. Trong cả hai trường hợp, bạn có thể sử dụng đầu ra từ `grep` để đảm bảo rằng bạn đang di chuyển các tệp mong muốn và cập nhật các tệp cấu hình thích hợp.
Bây giờ bạn đã xác nhận vị trí của gốc tài liệu của mình, hãy sao chép các tệp vào vị trí mới của chúng bằng `rsync`:

<$>[note]
**Chú ý:** Khi sử dụng lệnh `rsync`, hãy lưu ý 2 điều sau:

* Lưu ý rằng **có** một dấu gạch chéo sau `<^>your_domain<^>`. Nếu bạn không bao gồm dấu gạch chéo ở đây, bạn đang sao chép thư mục này sang thư mục gốc tài liệu mới dưới dạng thư mục con. Ví dụ: thư mục gốc mới của bạn sẽ có cấu trúc sau: `/ var / www / mnt / volume_nyc3_01 / your_domain`. Điều này sẽ gây ra sự cố khi cố gắng cung cấp tệp `index.html` của bạn từ gốc tài liệu mới của bạn.
* Thứ hai, **không có** dấu gạch chéo trên thư mục gốc của tài liệu mới `<^>/ mnt / volume_nyc3_01<^>`.
<$>
```custom_prefix($)
sudo rsync -av /var/www/<^>your_domain/<^> <^>/mnt/volume_nyc3_01<^>
```

`-a` bảo toàn quyền và các thuộc tính thư mục khác, trong khi `-v` cung cấp đầu ra dài dòng để bạn có thể theo dõi tiến trình đồng bộ hóa.
Đầu ra của bạn nên bao gồm những điều sau:
```
[secondary_label Output]
sending incremental file list
./
index.html

sent 265 bytes  received 38 bytes  606.00 bytes/sec
total size is 134  speedup is 0.44
```


Với các tệp của bạn tại chỗ, bạn có thể chuyển sang sửa đổi cấu hình Apache của mình để phản ánh những thay đổi này.
## Bước 2: Cập nhật tệp cấu hình
Sau khi định vị và sao chép tệp vào thư mục gốc mới, bạn có thể định cấu hình tệp máy chủ ảo để trỏ đến vị trí mới này.
Bắt đầu bằng cách mở `/etc/apache2/sites-enabled/<^>your_domain.conf<^>` bằng trình soạn thảo ưa thích của bạn. Ví dụ này sử dụng `nano`:

```custom_prefix($)
sudo nano /etc/apache2/sites-enabled/your_domain.conf
```

Tìm dòng bắt đầu bằng `DocumentRoot`và thay thế bằng vị trí mới. Trong ví dụ này, vị trí mới là `/ mnt / <^>volume_nyc3_01<^>`:
```nginx
[label /etc/apache2/sites-enabled/your_domain.conf]
<VirtualHost *:80>
    ServerAdmin sammy@your_domain
    ServerName your_domain
    ServerAlias www.your_domain
    DocumentRoot /<^>mnt/volume_nyc3_01<^>
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
RewriteEngine on
RewriteCond %{SERVER_NAME} =www.your_domain [OR]
RewriteCond %{SERVER_NAME} =your_domain
RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
</VirtualHost>
```

Sau chỉ thị `<VirtualHost>` này, hãy thêm các dòng được đánh dấu này để đảm bảo rằng máy chủ sẽ tuân theo các liên kết tượng trưng trong thư mục:
```nginx
[label /etc/apache2/sites-enabled/your_domain.conf]
. . .
</VirtualHost>

<^><Directory /mnt/volume_nyc3_01><^>
   <^> Options FollowSymLinks<^>
   <^> AllowOverride None<^>
   <^> Require all granted<^>
<^></Directory><^>
```
Nhìn chung, `/etc/apache2/sites-enabled/<^>your_domain<^>.conffile` của bạn phải bao gồm tất cả các dòng sau dành riêng cho vị trí `DocumentRoot` mới:
```nginx
[label /etc/apache2/sites-enabled/your_domain.conf]
<VirtualHost *:80>
    ServerAdmin sammy@your_domain
    ServerName your_domain
    ServerAlias www.your_domain
    DocumentRoot /<^>mnt/volume_nyc3_01<^>
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
RewriteEngine on
RewriteCond %{SERVER_NAME} =www.your_domain [OR]
RewriteCond %{SERVER_NAME} =your_domain
RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
</VirtualHost>

<Directory /<^>mnt/volume_nyc3_01<^>>
    Options FollowSymLinks
    AllowOverride None
    Require all granted
</Directory>
```
Lưu và thoát khỏi trình chỉnh sửa của bạn. Bạn có thể thoát ra khỏi `nano` bằng cách nhấn `CTRL + X`, sau đó nhấn `Y`, rồi `ENTER`.
Sau khi thực hiện những thay đổi này, bạn có thể chuyển sự chú ý của mình sang cấu hình SSL. Mở tệp `/etc/apache2/sites-enabled/your_domain-le-ssl.conf`:
```content super_user
sudo nano /etc/apache2/sites-enabled/<^>your_domain<^>-le-ssl.conf
```
Lưu và đóng tệp này.
Bây giờ bạn đã thực hiện các thay đổi cấu hình cần thiết để phản ánh vị trí mới thư mục gốc của bạn.
## Bước 3: Khởi động lại Apache
Sau khi thực hiện xong các thay đổi, bạn có thể khởi động lại Apache và kiểm tra kết quả.
Trước tiên, hãy đảm bảo rằng cú pháp của các cấu hình mới của bạn là đúng với `configtest`:
```custom_prefix($)
sudo apachectl configtest
```

Nếu cú pháp của bạn đúng, đầu ra của bạn sẽ hiển thị như sau:
```
[secondary_label Output]
AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1. Set the 'ServerName' directive globally to suppress this message
<^>Syntax OK<^>
```
<$>[note]
**Lưu ý:** Nếu bạn muốn loại bỏ dòng trên cùng trong đầu ra này, hãy thêm lệnh `ServerName` vào tệp cấu hình Apache chung của bạn tại `/etc/apache2/apache2.conf`. `ServerName` có thể là miền hoặc địa chỉ IP của máy chủ của bạn.
Mở tệp bằng trình chỉnh sửa của bạn:
```custom_prefix($)
sudo nano /etc/apache2/apache2.conf
```

Đặt lệnh `ServerName` ở cuối tệp cấu hình với `<^>your_domain<^>` hoặc địa chỉ IP máy chủ của bạn:
```nginx
[label /etc/apache2/apache2.conf]
# This is the main Apache server configuration file.  It contains the
# configuration directives that give the server its instructions.
# See http://httpd.apache.org/docs/2.4/ for detailed information about
# the directives and /usr/share/doc/apache2/README.Debian about Debian specific
# hints.
...

ServerName your_domain
```
Lưu và thoát khỏi trình chỉnh sửa của bạn.

Tuy nhiên, đây chỉ là một thông báo và không ảnh hưởng đến chức năng của trang web của bạn. Miễn là đầu ra chứa `Syntax OK`, bạn đã sẵn sàng để tiếp tục.
<$>
Sử dụng lệnh sau để khởi động lại Apache:
```custom_prefix($)
sudo systemctl reload apache2
```

Khi máy chủ đã khởi động lại, hãy truy cập các trang web bị ảnh hưởng của bạn để đảm bảo rằng chúng đang hoạt động như mong đợi. Khi bạn cảm thấy thoải mái vì mọi thứ đều theo thứ tự, đừng quên xóa các bản sao gốc của dữ liệu:
```custom_prefix($)
sudo rm -Rf /var/www/your_domain
```

Bây giờ bạn đã chuyển thành công thư mục gốc Apache của mình sang một vị trí mới.
## Kết luận
Trong hướng dẫn này, bạn đã học cách thay đổi thư mục gốc (document root) Apache sang một vị trí mới. Điều này có thể giúp bạn quản trị máy chủ web cơ bản như lưu trữ hiệu quả nhiều trang web trên một máy chủ duy nhất. Nó cũng cho phép bạn tận dụng các thiết bị lưu trữ thay thế như lưu trữ khối mạng, điều này có thể hữu ích trong việc mở rộng quy mô một trang web khi nhu cầu của nó thay đổi.

Cách cấu hình thay đổi Web Root trong máy chủ Web Apache trên Ubuntu 20.04

## Giới thiệu
Với tư cách là quản trị viên web, bạn có thể thấy việc hạn chế một số phần của trang web khỏi khách truy cập, cho dù tạm thời hay lâu dài đều rất hữu ích. Mặc dù các ứng dụng web có thể cung cấp các phương pháp xác thực và ủy quyền của riêng chúng, nhưng bạn cũng có thể dựa vào chính máy chủ web để hạn chế quyền truy cập nếu các phương thức này không đủ hoặc không khả dụng.

Bài viết này sẽ hướng dẫn bạn các nội dung bảo vệ bằng mật khẩu trên máy chủ web Apache chạy trên Ubuntu 20.04. Nó sẽ cung cấp cho máy chủ của bạn một lớp bảo mật bổ sung.
## Điều kiện 
Để thực hiện 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 với non-**root** user có đặc quyền `sudo` và tường lửa được bật. Bạn có thể thực hiện việc này bằng cách làm theo Hướng dẫn thiết lập máy chủ ban đầu Ubuntu 20.04.
* Máy chủ web Apache được cài đặt trên máy chủ Ubuntu của bạn. Nếu bạn chưa cài đặt, bạn có thể tham khảo hướng dẫn Cách cài đặt máy chủ web Apache trên Ubuntu 20.04. Đảm bảo hoàn thành **Bước 5** và có một tệp máy chủ ảo cho tên miền của bạn. Hướng dẫn này sẽ đề cập đến **your_domain** làm ví dụ xuyên suốt và sử dụng` /etc/apache2/sites-available/<^>your_domain.conf<^>` cho tệp máy chủ ảo.
* Máy chủ ảo của bạn được bảo mật bằng SSL. Việc thiết lập này phụ thuộc vào việc bạn có tên miền cho trang web của mình hay không.

1. Nếu bạn có tên miền, bạn có thể bảo mật trang web của mình bằng Let’s Encrypt, đây là công cụ cung cấp các chứng chỉ miễn phí đáng tin cậy. Làm theo Hướng dẫn Let’s Encrypt cho Apache để cài đặt nó.
1. Nếu bạn không có miền và bạn đang sử dụng cấu hình này để thử nghiệm hoặc sử dụng cho mục đích cá nhân, bạn có thể sử dụng chứng chỉ tự ký (self-signed certificate) để thay thế. Nó cung cấp cùng một loại mã hóa, nhưng không có xác thực tên miền. Hãy làm theo Hướng dẫn SSL tự ký (self-signed SSL) cho Apache để cài đặt.

* Nếu bạn muốn thiết lập một tên miền (tùy chọn), bạn có thể mua một tên miền trên Namecheap, nhận một tên miền miễn phí trên Freenom hoặc sử dụng công ty đăng ký tên miền mà bạn chọn. Ngoài ra, bạn sẽ cần cả hai bản ghi DNS sau để thiết lập cho máy chủ của mình. Làm theo bài Giới thiệu về CloudFly DNS để biết chi tiết về cách thêm chúng.

1. Một bản ghi với `<^>your_domain<^>` trỏ đến địa chỉ IP chung của máy chủ của bạn.
1. Một bản ghi có `www.<^>your_domain<^>` trỏ đến địa chỉ IP chung của máy chủ của bạn.

Khi bạn đã hoàn thành các điều kiện này, hãy đăng nhập vào máy chủ của bạn với tư cách là `sudo` user và tiếp tục với bước đầu tiên.

## Bước 1: Cài đặt Gói tiện ích Apache
Hãy bắt đầu bằng cách cập nhật máy chủ và cài đặt một gói mà chúng ta sẽ cần. Để hoàn thành theo hướng dẫn này, chúng ta sẽ sử dụng tiện ích có tên `htpasswd`, một phần của gói `apache2-utils`, để tạo tệp và quản lý tên người dùng và mật khẩu cần thiết và truy cập nội dung bị hạn chế.

Trước tiên, hãy cập nhật gói mục lục của máy chủ bạn:
```command
sudo apt update
```
Sau đó cài đặt gói tiện ích Apache:
```command
sudo apt install apache2-utils
```
Với cài đặt này, bây giờ bạn có quyền truy cập vào lệnh `htpasswd`.

## Bước 2: Tạo tệp mật khẩu
Lệnh `htpasswd` cho phép bạn tạo một tệp mật khẩu mà Apache có thể sử dụng để xác thực người dùng. Bạn sẽ tạo một tệp ẩn cho mục đích này gọi là `.htpasswd` trong thư mục cấu hình`/etc/apache2` 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 `.htpasswd` được chỉ định. Ở đây, chúng ta chỉ định tên người dùng (`sammy` trong ví dụ này) ở cuối lệnh để tạo mục nhập mới trong tệp:
```command
sudo htpasswd -c /etc/apache2/.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 như trong ví dụ sau để bạn không ghi đè lên tệp:
```command
sudo htpasswd /etc/apache2/.htpasswd <^>another_user<^>
```
Nếu bạn kiểm tra nội dung của tệp, nó sẽ chứa tên người dùng và mật khẩu được mã hóa cho mỗi bản ghi:
```command
cat /etc/apache2/.htpasswd
```
```
[secondary_label Output]
sammy:$apr1$eponJaBR$9uyVIRpDpbHoseI.hS1cq/
another_user:$apr1$dDXiQxte$RGn3CVfFLQOPf5lSJgNvV1
```
Bây giờ bạn có tên người dùng và mật khẩu của mình ở định dạng mà Apache có thể đọc được.

## Bước 3: Thiết lập cấu hình xác thực mật khẩu Apache
Trong bước này, bạn cần thiết lập cấu hình Apache để kiểm tra tệp `.htpasswd` trước khi cung cấp nội dung được bảo vệ của bạn. Bạn có thể thực hiện việc này theo một trong hai cách: làm trực tiếp trong tệp máy chủ ảo của trang web, hoặc bằng cách đặt tệp `.htaccess` vào các thư mục cần hạn chế. Nói chung, tốt nhất là sử dụng tệp máy chủ ảo, nhưng nếu bạn cần cho phép non-**root** users quản lý các hạn chế truy cập riêng, hãy tham khảo lựa chọn thứ hai để kiểm tra các hạn chế trong kiểm soát phiên bản cùng với trang web, hoặc có một ứng dụng web sử dụng các tệp `.htaccess` cho những mục đích khác.

<$>[note]
**Lưu ý:** Bạn có thể thực hiện các tùy chọn sau cho bất kỳ máy chủ ảo nào đang hoạt động. Nếu bạn đang sử dụng máy chủ ảo của riêng mình, hãy đảm bảo thay đổi bất kỳ các lệnh và giá trị nào để phản ánh cấu hình của bạn.
<$>

Hãy chọn tùy chọn phù hợp nhất với nhu cầu của bạn.

### Tùy chọn 1: Thiết lập cấu hình Kiểm soát truy cập trong Định nghĩa Máy chủ Ảo (Ưu tiên)
Tùy chọn đầu tiên là chỉnh sửa cấu hình Apache và thêm mật khẩu bảo vệ vào tệp máy chủ ảo. Điều này sẽ mang lại hiệu suất tốt hơn vì nó tránh được chi phí đọc các tệp cấu hình (configuration files) phân tán. Tùy chọn này yêu cầu quyền truy cập vào cấu hình, không phải lúc nào cũng có sẵn, nhưng khi bạn có quyền truy cập, bạn nên sử dụng nó.
Bắt đầu bằng cách mở tệp máy chủ ảo mà bạn muốn thêm hạn chế vào. Đối với ví dụ của chúng tôi, chúng tôi sẽ sử dụng tệp`/etc/apache2/sites-available/<^>your_domain.conf<^>` chứa máy chủ ảo. Mở tệp bằng trình soạn thảo văn bản dòng lệnh như là `nano`:
```content super_user
sudo nano /etc/apache2/sites-available/<^>your_domain<^>.conf
```
Ở bên trong, với các nhận xét bị loại bỏ, tệp sẽ trông giống như sau:

```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>
```

Xác thực được thực hiện trên cơ sở từng thư mục. Để thiết lập xác thực, bạn sẽ cần nhắm mục tiêu vào thư mục mà bạn muốn hạn chế bằng khối `<Directory ___>`. Trong ví dụ của chúng tôi, chúng tôi sẽ hạn chế toàn bộ tài liệu gốc, nhưng bạn có thể sửa đổi danh sách này để nhắm mục tiêu vào một thư mục cụ thể trong không gian web:

```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

<^><Directory "/var/www/your_domain"><^>
   <^></Directory><^>
</VirtualHost>
```

Trong khối thư mục này, hãy xác định rằng bạn đang cài đặt xác thực `Basic`. Đối với `AuthName`, hãy chọn tên vùng sẽ được hiển thị cho người dùng khi nhắc nhở nhập thông tin đăng nhập. Sử dụng chỉ thị `AuthUserFile` để trỏ Apache tới tệp mật khẩu bạn đã tạo. Cuối cùng, tạo ra một yêu cầu rằng chỉ `valid-user` (người dùng hợp lệ) mới có thể truy cập tài nguyên này, có nghĩa là bất kỳ ai có thể xác minh danh tính của họ bằng mật khẩu sẽ được phép truy cập vào:

```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

<^><Directory "/var/www/your_domain"><^>
     <^> AuthType Basic<^>
      <^>AuthName "Restricted Content"<^>
      <^>AuthUserFile /etc/apache2/.htpasswd<^>
      <^>Require valid-user<^>
  <^></Directory><^>
</VirtualHost>n3
```

Lưu và đóng tệp khi bạn hoàn tất. Nếu bạn đang sử dụng `nano`, bạn có thể làm như vậy bằng cách nhấn `CTRL + X`, sau đó nhấn `Y` rồi `ENTER`.

Trước khi khởi động lại máy chủ web, bạn có thể kiểm tra cấu hình bằng lệnh sau:
```command
sudo apache2ctl configtest
```
Nếu mọi thứ được kiểm tra và bạn nhận được `Syntax OK` ở đầu ra, bạn có thể khởi động lại máy chủ để triển khai chính sách mật khẩu của mình:
```command
sudo systemctl restart apache2
```
Khi `systemctl` không hiển thị kết quả của tất cả các lệnh quản lý dịch vụ, hãy sử dụng lệnh `status` để đảm bảo máy chủ đang chạy:
```command
sudo systemctl status apache2
```
```
[secondary_label Output]
● apache2.service - The Apache HTTP Server
     Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor prese>
     Active: active (running) since Fri 2022-04-29 17:12:24 UTC; 4s ago
       Docs: https://httpd.apache.org/docs/2.4/
    Process: 4493 ExecStart=/usr/sbin/apachectl start (code=exited, status=0/SU>
   Main PID: 4514 (apache2)
      Tasks: 55 (limit: 9508)
     Memory: 5.8M
     CGroup: /system.slice/apache2.service
             ├─4514 /usr/sbin/apache2 -k start
             ├─4516 /usr/sbin/apache2 -k start
             └─4517 /usr/sbin/apache2 -k start
```
Bây giờ, thư mục bạn chỉ định sẽ được bảo vệ bằng mật khẩu.

### Tùy chọn 2: Thiết lập cấu hình Kiểm soát truy cập bằng tệp .htaccess
Apache có thể sử dụng các tệp` .htaccess` để cho phép các mục cấu hình nhất định được đặt trong một thư mục nội dung. Vì Apache phải đọc lại các tệp này theo mọi yêu cầu liên quan đến thư mục, nó có thể ảnh hưởng tiêu cực đến hiệu suất, nên Tùy chọn 1 được ưu tiên hơn, nhưng nếu bạn đang sử dụng tệp `.htaccess` hoặc cần cho phép non-**root** users quản lý các hạn chế, các tệp `.htaccess` sẽ giúp bạn thực hiện đơn giản hơn.

Để cho phép tính năng bảo vệ mật khẩu sử dụng tệp `.htaccess`, hãy mở tệp cấu hình Apache chính bằng trình soạn thảo văn bản dòng lệnh như `nano`:
```command
sudo nano /etc/apache2/apache2.conf
```
Tìm khối `<Directory>` cho thư mục `/var/www/` chứa tài liệu gốc. Cập nhật dòng này để phản ánh tài liệu gốc của bạn. Tiếp theo, bật xử lý `.htaccess` bằng cách thay đổi chỉ thị `AllowOverride` trong khối đó từ `None` thành `All`. Nội dung của khối `<Directory>` này bây giờ sẽ đọc như sau:

```nginx
[label /etc/apache2/apache2.conf]
. . .

<Directory /var/www/<^>your_domain<^>>
  Options Indexes FollowSymLinks
  AllowOverride <^>All<^>
  Require all granted
</Directory>

. . .
```

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

Tiếp theo, thêm tệp `.htaccess` vào thư mục bạn muốn hạn chế. Trong phần trình bày này, chúng tôi sẽ hạn chế toàn bộ tài liệu gốc (toàn bộ trang web) có tại `/var/www/<^>your_domain<^>`, nhưng bạn có thể đặt tệp này trong bất kỳ thư mục nào mà bạn muốn hạn chế quyền truy cập:
```content super_user
sudo nano /var/www/<^>your_domain<^>/.htaccess
```
Trong tệp này, xác định rằng bạn muốn cài đặt xác thực `Basic`. Đối với `AuthName`, hãy chọn tên vùng sẽ được hiển thị cho người dùng khi nhắc nhở nhập thông tin đăng nhập. Sử dụng chỉ thị `AuthUserFile` để trỏ Apache tới tệp mật khẩu mà chúng tôi đã tạo. Cuối cùng, bạn sẽ yêu cầu `valid-user` (người dùng hợp lệ) truy cập tài nguyên này, có nghĩa là bất kỳ ai có thể xác minh danh tính của họ bằng mật khẩu sẽ được phép vào:

```nginx
[label /var/www/your_domain/.htaccess]
AuthType Basic
AuthName "Restricted Content"
AuthUserFile /etc/apache2/.htpasswd
Require valid-user
```

Lưu và đóng tập tin. Khởi động lại máy chủ web để bảo vệ bằng mật khẩu tất cả nội dung trong hoặc dưới thư mục có tệp `.htaccess`:
```command
sudo systemctl restart apache2
```
Sau đó chạy `systemctl status` để xác minh khởi động lại thành công:
```command
sudo systemctl status apache2
```
```
[secondary_label Output]
● apache2.service - The Apache HTTP Server
     Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor prese>
     Active: active (running) since Fri 2022-04-29 17:18:17 UTC; 3s ago
       Docs: https://httpd.apache.org/docs/2.4/
    Process: 4721 ExecStart=/usr/sbin/apachectl start (code=exited, status=0/SU>
   Main PID: 4744 (apache2)
      Tasks: 55 (limit: 9508)
     Memory: 5.9M
     CGroup: /system.slice/apache2.service
             ├─4744 /usr/sbin/apache2 -k start
             ├─4745 /usr/sbin/apache2 -k start
             └─4746 /usr/sbin/apache2 -k start
```
Thư mục bạn đã chỉ định bây giờ đã được bảo vệ bằng mật khẩu.

## Bước 4: 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 cố gắng truy cập nội dung bị hạn chế của bạn trong trình duyệt web bằng cách điều hướng đến `https://<^>your_domain_or_server_IP<^>`.

Bạn sẽ được hiển thị lời nhắc tên người dùng và mật khẩu như sau:
![description image](https://media.cloudfly.vn/posts/cach-cai-dat-xac-thuc-mat-khau-voi-Apache-tren-Ubuntu-20.04.png)

Nếu bạn nhập thông tin đăng nhập chính xác, bạn sẽ được phép truy cập vào nội dung. Nếu bạn nhập sai thông tin đăng nhập hoặc nhấn "Cancel" (Hủy), bạn sẽ nhận được trang lỗi "Unauthorized" (Không được phép):
![description image](https://media.cloudfly.vn/posts/cach-cai-dat-xac-thuc-mat-khau-voi-Apache-tren-Ubuntu-20.04_2.png)

## Kết luận
Bây giờ bạn đã thiết lập xác thực cơ bản cho trang web của mình.

Bạn có thể làm nhiều hơn thế nữa với cấu hình Apache và `.htaccess`. Để tìm hiểu thêm về tính linh hoạt và sức mạnh có sẵn trong cấu hình Apache, hãy thử một trong các hướng dẫn dưới đây:
* Để hiểu rõ hơn về tệp cấu hình chính, hãy đọc phần Làm quen với các tệp và thư mục Apache quan trọng trong hướng dẫn cài đặt Apache của chúng tôi.
* Tìm hiểu thêm về Cách thiết lập tệp máy chủ ảo trong Apache
* Tìm hiểu về cách viết lại URL, tùy chỉnh các trang lỗi như thông báo “Unauthorized" (Không được phép) trước đó hoặc bao gồm các yếu tố phổ biến trên tất cả các trang của bạn với Server Side Includes trong hướng dẫn Cách Sử dụng Tệp .htaccess của chúng tôi.

Cách cài đặt xác thực mật khẩu với Apache trên Ubuntu 20.04

## Giới thiệu
A reverse-proxy là một loại máy chủ ủy quyền, chuyên nhận các yêu cầu HTTP (S) và phân phối chúng đến một hoặc nhiều máy chủ hỗ trợ khác một cách minh bạch. Các reverse-proxy này rất hữu ích vì dược sử dụng bởi nhiều ứng dụng web hiện đại khác nhau. Chúng chuyên xử lý các yêu cầu HTTP đến bằng cách sử dụng các máy chủ ứng hỗ trợ khác. Những máy chủ này không phải để người dùng truy cập trực tiếp mà thường được sử dụng để hỗ trợ các tính năng HTTP cơ bản.
Bạn có thể sử dụng reverse-proxy để ngăn các máy chủ ứng dụng cơ bản này bị truy cập trực tiếp từ bên ngoài. Chúng cũng có thể được sử dụng để phân phối tải từ các yêu cầu đến đến một số máy chủ, tăng hiệu suất trên quy mô lớn và cung cấp độ bảo mật nếu như có sự cố. Chúng có thể lấp đầy khoảng trống bằng các tính năng mà máy chủ ứng dụng không cung cấp, chẳng hạn như bộ nhớ đệm, nén hoặc mã hóa SSL.
Trong hướng dẫn này, bạn sẽ tiến hành thiết lập Apache làm reverse-proxy một cách cơ bản bằng cách sử dụng tiện ích mở rộng `mod_proxy` để chuyển hướng các kết nối đến đến một/ một số máy chủ Backend chạy trên cùng một mạng. Hướng dẫn này sử dụng chương trình Backend được viết bằng Web Framework Flask, nhưng bạn có thể sử dụng bất kỳ máy chủ Backend nào bạn thích.
## Điều kiện
Để làm theo hướng dẫn này, bạn sẽ phải cần có:
* Một máy chủ Ubuntu 20.04 được thiết lập sẵn, bao gồm một người dùng không phải root `sudo` và chắc chắn không thể thiếu tường lửa.
* Apache 2 đã được cài đặt sẵn trên máy chủ của bạn.
# Bước 1: Kích hoạt các Module Apache cần thiết
Apache có nhiều mô-đun đi kèm, đôi lúc nó có sẵn nhưng không được kích hoạt trong bản cài đặt mới nhất. Do đó, trước tiên, bạn cần bật những cái bạn sẽ sử dụng trong hướng dẫn này.
Các mô-đun bạn cần là chính là `mod_proxy` và một số mô-đun bổ trợ của nó, cái mà sẽ giúp mở rộng chức năng để hỗ trợ các giao thức mạng khác nhau. Cụ thể, những mô-đun bạn sẽ sử dụng bao gồm:
* `mod_proxy`: mô-đun proxy chính để chuyển hướng kết nối. Nó cho phép Apache hoạt động như một cổng vào dành cho các máy chủ ứng dụng bên dưới.
* `mod_proxy_http`: thêm hỗ trợ cho các kết nối HTTP ủy quyền.
* `mod_proxy_balancer` và `mod_lbmethod_byrequests`: chúng bổ sung các tính năng cân bằng tải cho nhiều máy chủ Backend.
Để bật 4 mô-đun này, hãy thực hiện lệnh sau:
```custom_prefix($)
sudo a2enmod proxy proxy_http proxy_balancer lbmethod_byrequests
```
Để những thay đổi này có hiệu lực, hãy khởi động lại Apache:
```custom_prefix($)
sudo systemctl restart apache2
```

Apache hiện đã sẵn sàng hoạt động như một reverse-proxy cho các yêu cầu HTTP. Trong bước tùy chọn tiếp theo, bạn sẽ phải tạo 2 máy chủ Backend cơ bản. Những điều này sẽ giúp xác minh xem cấu hình có hoạt động bình thường hay không, nhưng nếu bạn đã có ứng dụng Backend của riêng mình, bạn có thể chuyển sang Bước 3.
## Bước 2: Tạo Máy chủ backend để Test
Khởi chạy một số máy chủ Backend có thể giúp kiểm tra xem cấu hình Apache của bạn có hoạt động bình thường hay không. Tại đây, bạn sẽ tạo 2 máy chủ thử nghiệm phản hồi các yêu cầu HTTP bằng cách in một dòng văn bản. Một máy chủ sẽ nói “**hello world**” và máy còn lại sẽ hiển thị “**Howdy world**” Điều này sẽ cho phép bạn kiểm tra cân bằng tải giữa nhiều dịch vụ cùng lúc. 

<$>[note]
**Lưu ý:** Trong thiết lập thế giới thực, các máy chủ Backend thường trả về cùng một loại nội dung. Tuy nhiên, với mục đích của bài viết này, việc 2 máy chủ trả về các thông báo khác nhau cho phép bạn kiểm tra xem cơ chế cân bằng tải có sử dụng cả 2 hay không
<$>
Flask là một microframework Python được dùng để xây dựng các ứng dụng web. Bước này phác thảo cơ bản cách sử dụng Flask để tạo các máy chủ thử nghiệm vì một ứng dụng tối thiểu chỉ yêu cầu một vài dòng code.
Đâu tiên, hãy cập nhạt danh sách các gói mục lục bằng cách sử dụng `apt`:

```custom_prefix($)
sudo apt update
```

Sau đó, tiến hành cài đặt `pip`, trình kiến nghị việc quản lý các gói Python: 
```custom_prefix($)
sudo apt install python3-pip
```
Tiếp theo, sử dụng `pip` để cài đặt Flask:
```custom_prefix($)
sudo pip3 install Flask
```
Bây giờ, tất cả các thành phần bắt buộc đều đã được cài đặt đầy đủ. Hãy tạo một tệp mới chứa code cho máy chủ Backend đầu tiên trong thư mục chính hiện tại. Bạn có thể thực hiện việc này bằng trình soạn thảo văn bản ưa thích của mình, ở đây chúng tôi sẽ sử dụng `nano` trong bài viết này:
```custom_prefix($)
nano ~/backend1.py
```
Chèn đoạn code sau vào tệp:
```nginx
[label ~/backend1.py]
from flask import Flask
app = Flask(__name__)

@app.route('/')
def home():
    return 'Hello world!'
```
Hai dòng code đầu tiên khởi tạo khung Flask. Có một hàm, `home ()`, trả về một dòng văn bản `(Xin chào thế giới)`. Dòng `@ app.route ('/')` phía trên định nghĩa hàm `home ()` yêu cầu Flask sử dụng giá trị trả về của `home ()` làm phản hồi cho các yêu cầu HTTP được hướng đến URL `/` root của ứng dụng.
Sau khi hoàn tất, hãy lưu và thoát khỏi tệp. Nếu đang sử dụng `nano`, bạn có thể thực hiện việc này bằng cách nhấn `CTRL + X`, sau đó nhấn `Y` và `ENTER`.
Máy chủ Backend thứ hai hoàn toàn giống với máy chủ đầu tiên, ngoại trừ việc trả về một dòng văn bản khác. Do đó, hãy chạy `cp` để sao chép nội dung từ tệp đầu tiên, từ tệp `backend1.py` vào tệp `backend2.py`:

```custom_prefix($)
cp ~/backend1.py ~/backend2.py
```
Bây giờ, hãy mở tệp mới được sao chép bằng trình soạn thảo văn bản ưa thích của bạn:
```custom_prefix($)
nano ~/backend2.py
```
Cập nhật thông báo trả về là tin nhắn **hello world** thay vì đọc **Howdy world**:

```nginx
[label ~/backend2.py]
from flask import Flask
app = Flask(__name__)

@app.route('/')
def home():
    return 'Howdy world!'
```

Sau khi bạn cập nhật xong, hãy lưu và đóng tệp lại.
Tiếp theo, sử dụng dòng lệnh dưới đây để khởi động máy chủ nền đầu tiên trên cổng `8080`. Thao tác này cũng làm chuyển hướng đầu ra của `Flask` đến `/ dev / null` vì nó sẽ làm ảnh hưởng đến đầu ra của bảng điều khiển trên:
```custom_prefix($)
FLASK_APP=~/backend1.py flask run --port=8080 >/dev/null 2>&1 &
```
Ở đây, bạn đang đặt trước lệnh `flask` bằng cách cài đặt biến môi trường `FLASK_APP` trên cùng một dòng. Các biến môi trường là một cách thuận tiện để truyền thông tin vào các quy trình được sinh ra từ phía ngoài. 
Trong trường hợp này, việc sử dụng một biến môi trường sẽ đảm bảo cài đặt này chỉ áp dụng cho các lệnh đang được chạy và sẽ không có sẵn sau đó. Điều này là cần thiết để tránh nhầm lẫn vì bạn sẽ chuyển một tên tệp khác theo cách tương tự để yêu cầu lệnh `flask` khởi động máy chủ thứ hai.
Tương tự, bạn muốn chạy lệnh sau để khởi động máy chủ thứ hai trên cổng `8081`. Lưu ý giá trị khác nhau cho biến môi trường `FLASK_APP`:
```custom_prefix($)
FLASK_APP=~/backend2.py flask run --port=8081 >/dev/null 2>&1 &
```
Bây giờ bạn có thể kiểm tra xem hai máy chủ có đang chạy hay không bằng cách sử dụng lệnh `curl`. Bắt đầu bằng cách thử nghiệm máy chủ đầu tiên. Lệnh này sử dụng `curl` để kết nối với `127.0.0.1`, một địa chỉ IP đặc biệt đại diện cho localhost. Điều này có nghĩa là lệnh sau yêu cầu máy chủ của bạn kết nối với chính nó và in phản hồi của chính nó:
```custom_prefix($)
curl http://127.0.0.1:8080/
```
Thao tác này sẽ in phản hồi sau từ máy chủ:
```
[secondary_label Output]
Hello world!
```
Tiếp theo, kiểm tra máy chủ thứ hai:
```custom_prefix($)
curl http://127.0.0.1:8081/
```
Tương tự như trước đó, điều này sẽ in phản hồi mong đợi từ máy chủ:
```
[secondary_label Output]
Howdy world!
```
Trong bước tiếp theo, bạn sẽ sửa đổi tệp cấu hình của Apache để cho phép sử dụng tệp này làm reverse proxy.
## Bước 3: Sửa đổi cấu hình mặc định để kích hoạt Reverse Proxy
Trong phần này, bạn sẽ thiết lập máy chủ ảo Apache mặc định để phục vụ như một reverse proxy cho một máy chủ Backend duy nhất hoặc một loạt các máy chủ Backend để đám ứng nhu cầu chạy cân bằng tải.

<$>[note]
**Lưu ý:** Trong hướng dẫn này, các bạn đang áp dụng cấu hình ở cấp máy chủ ảo. Trên cài đặt mặc định của Apache, chỉ có một máy chủ ảo mặc định duy nhất được kích hoạt. Tuy nhiên, bạn cũng có thể sử dụng tất cả các đoạn cấu hình đó trong các máy chủ ảo khác.
<$>

Nếu máy chủ Apache của bạn hoạt động như một máy chủ HTTP và HTTPS, thì cấu hình reverse proxy của bạn phải được đặt trong cả máy chủ ảo HTTP và HTTPS. 

Mở tệp cấu hình Apache mặc định bằng trình soạn thảo văn bản ưa thích của bạn:
```custom_prefix($)
sudo nano /etc/apache2/sites-available/000-default.conf
```

Bên trong tệp đó, bạn sẽ tìm thấy khối `<VirtualHost *: 80>` ngay trên dòng đầu tiên. Ví dụ đầu tiên sau đây sẽ giải thích cách định cấu hình khối này để thiết lập reverse proxy cho một máy chủ Backend duy nhất và ví dụ thứ hai thiết lập reverse proxy cân bằng tải cho nhiều máy chủ Backend.
### Ví dụ 1: Thiết lập reverse proxy với duy nhất một máy chủ Backend
Đầu tiên, thay thế tất cả nội dung trong khối `VirtualHost` để tệp cấu hình của bạn đọc như sau. Nếu bạn đã làm theo các máy chủ mẫu ở Bước 2, hãy sử dụng `127.0.0.1:8080`. Nếu bạn có máy chủ ứng dụng của riêng mình, hãy sử dụng địa chỉ của chúng để thay thế:
```nginx
[label /etc/apache2/sites-available/000-default.conf]
<VirtualHost *:80>
    <^>ProxyPreserveHost On<^>

    <^>ProxyPass / http://127.0.0.1:8080/ <^>
    <^>ProxyPassReverse / http://127.0.0.1:8080/ <^>
</VirtualHost>
```

Có ba nội dung được trình bày, dưới đây là tổng quan ngắn gọn về những gì chúng  đang thực hiện: 
* `ProxyPreserveHost`: làm cho Apache chuyển tiêu đề` Host` ban đầu đến máy chủ Backend. Điều này rất hữu ích, vì nó làm cho máy chủ Backend nhận biết được địa chỉ nào đang được sử dụng để truy cập ứng dụng.
* `ProxyPass`: chỉ thị cấu hình proxy chính. Trong trường hợp này, nó chỉ định rằng mọi thứ dưới dạng URL gốc `(/)` phải được chuyển tới máy chủ Backend tại địa chỉ đã cho. Ví dụ: nếu Apache nhận được một yêu cầu cho `/ example`, nó sẽ kết nối với `http: //  <^>your_backend_server <^> / example` và trả lại phản hồi cho máy khách ban đầu.
* `ProxyPassReverse`: nên có cùng cấu hình với `ProxyPass`. Nó yêu cầu Apache sửa đổi các tiêu đề phản hồi từ máy chủ Backend. Điều này đảm bảo rằng nếu máy chủ Backend trả về tiêu đề chuyển hướng vị trí, trình duyệt của khách hàng sẽ được chuyển hướng đến địa chỉ proxy chứ không phải địa chỉ máy chủ Backend, điều này sẽ không hoạt động như dự kiến.

Sau khi bạn thêm xong nội dung này, hãy lưu và thoát khỏi tệp.
Để những thay đổi này có hiệu lực, hãy khởi động lại Apache:
```custom_prefix($)
sudo systemctl restart apache2
```

Bây giờ, nếu bạn truy cập http: `// <^>your_server_ip<^>` trong trình duyệt web, bạn sẽ thấy phản hồi của máy chủ Backend của mình thay vì trang chào mừng Apache tiêu chuẩn. Nếu bạn đã làm theo Bước 2, điều này có nghĩa là bạn sẽ thấy **Hello world!** trong trình duyệt.
### Ví dụ 2:  Cân bằng tải qua nhiều máy chủ Backend
Nếu bạn có nhiều máy chủ Backend, một cách tốt để phân phối lưu lượng truy cập khi ủy quyền là sử dụng các tính năng cân bằng tải của `mod_proxy`.
Trước tiên, hãy mở tệp cấu hình Apache mặc định bằng trình soạn thảo văn bản ưa thích của bạn:
```custom_prefix($)
sudo nano /etc/apache2/sites-available/000-default.conf
```
Bây giờ thay thế tất cả nội dung trong `VirtualHost` để tệp cấu hình của bạn đọc như sau. Nếu bạn đã làm theo các máy chủ mẫu ở Bước 2, hãy sử dụng `127.0.0.1:8080` và `127.0.0.1:8081` cho các lệnh `BalancerMember`. Nếu bạn có máy chủ ứng dụng của riêng mình, hãy sử dụng địa chỉ của chúng để thay thế:
```nginx
[label /etc/apache2/sites-available/000-default.conf]
<VirtualHost *:80>
<^><Proxy balancer://mycluster><^>
    <^>BalancerMember http://127.0.0.1:8080<^>
   <^> BalancerMember http://127.0.0.1:8081<^>
<^></Proxy><^>

    <^>ProxyPreserveHost On<^>

    <^>ProxyPass / balancer://mycluster/<^>
    <^>ProxyPassReverse / balancer://mycluster/<^>
</VirtualHost>
```

Cấu hình tương tự như cấu hình trước đó, nhưng thay vì chỉ định trực tiếp một máy chủ Backend duy nhất, các lệnh này thực hiện như sau:
* `Proxy`: khối `Proxy` bổ sung này được sử dụng để xác định nhiều máy chủ. Khối được đặt tên là `balancer: // <^>mycluster<^>` (tên có thể được thay đổi tùy ý) và bao gồm một hoặc nhiều `BalancerMembers`, khối này chỉ định địa chỉ máy chủ Backend cơ bản.
* `ProxyPass` và `ProxyPassReverse: các chỉ thị này sử dụng nhóm cân bằng tải` có tên mycluster thay vì một máy chủ cụ thể.

Nếu bạn đã làm theo các máy chủ mẫu trong Bước 2, hãy sử dụng `127.0.0.1:8080` và `127.0.0.1:8081` cho các lệnh `BalancerMember`, như được viết trong khối ở trên. Nếu bạn có máy chủ ứng dụng của riêng mình, hãy sử dụng địa chỉ của chúng để thay thế.

Sau khi bạn thêm xong nội dung này, hãy lưu và thoát khỏi tệp.

Để những thay đổi này có hiệu lực, hãy khởi động lại Apache:

```custom_prefix($)
sudo systemctl restart apache2
```
Nếu bạn truy cập `http: // <^>your_server_ip<^>` trong trình duyệt web, bạn sẽ thấy phản hồi của máy chủ Backend của mình thay vì trang Apache tiêu chuẩn. Nếu bạn đã làm theo Bước 2, thì việc làm mới trang nhiều lần sẽ hiển thị Hello world! và Howdy world !, nghĩa là reverse proxy đã hoạt động và đang cân bằng tải giữa cả hai máy chủ.

<$>[note]
**Lưu ý:** Để đóng cả 2 máy chủ thử nghiệm sau khi bạn không còn cần đến chúng nữa, như khi bạn hoàn thành hướng dẫn này, bạn có thể thực hiện lệnh `killall flask`
<$>
## Kết luận
Bây giờ bạn đã biết cách thiết lập Apache làm reverse proxy cho một hoặc nhiều máy chủ ứng dụng cơ bản. `mod_proxy` có thể được sử dụng hiệu quả để định cấu hình reverse proxy cho các máy chủ ứng dụng được viết bằng nhiều ngôn ngữ và công nghệ, chẳng hạn như Python và Django, hoặc Ruby và Ruby on Rails. Nó cũng có thể được sử dụng để cân bằng lưu lượng truy cập giữa nhiều máy chủ Backend cho các trang web có nhiều lưu lượng truy cập, để cung cấp tính khả dụng cao thông qua nhiều máy chủ hoặc cung cấp hỗ trợ SSL an toàn cho các máy chủ Backend không hỗ trợ SSL nguyên bản.
Trong khi `mod_proxy` với `mod_proxy_http` có lẽ là sự kết hợp phổ biến nhất của các mô-đun, có một số mô-đun khác hỗ trợ các giao thức mạng khác nhau. Bạn đã không sử dụng chúng trong hướng dẫn này, nhưng một số mô-đun phổ biến khác bao gồm:
* `mod_proxy_ftp cho FTP`
* `mod_proxy_connect`
* `mod_proxy_ajp` cho AJP (Apache JServ Protocol)
* `mod_proxy_wstunnel`

Cách sử dụng Apache làm Reverse-Proxy với mod_proxy trên Ubuntu 20.04

## Giới thiệu
SSH là phương pháp kết nối trên thực tế với máy chủ đám mây. Nó bền và có thể mở rộng, khi các tiêu chuẩn mã hóa mới được phát triển, chúng có thể được sử dụng để tạo các SSH key mới, đảm bảo rằng giao thức cốt lõi vẫn an toàn. Tuy nhiên, không có giao thức hoặc phần mềm stack nào an toàn tuyệt đối, và SSH được triển khai rộng rãi trên internet có nghĩa là nó đại diện cho một sự tấn công bề mặt (attack surface) hoặc tấn công vector (attack vector), mà thông qua đó mọi người có thể truy cập.

Bất kỳ dịch vụ nào tiếp xúc với mạng Internet đều là mục tiêu tiềm năng của việc này. Nếu bạn xem lại nhật ký SSH service của mình chạy trên bất kỳ máy chủ nào, bạn sẽ thấy các nỗ lực đăng nhập có hệ thống, lặp đi lặp lại thể hiện các cuộc tấn công bạo lực của người dùng và bot là như nhau. Mặc dù bạn có thể thực hiện một số tối ưu hóa cho SSH service để giảm khả năng thành công của các cuộc tấn công này xuống gần 0, chẳng hạn như vô hiệu hóa xác thực mật khẩu có lợi cho các SSH key, chúng vẫn có thể đặt ra một trách nhiệm nhỏ.

Việc triển khai sản xuất quy mô lớn mà trách nhiệm này không được chấp nhận, thường sẽ thực hiện VPN như WireGuard trước SSH service của họ, do đó không thể kết nối trực tiếp với cổng SSH 22 mặc định từ internet bên ngoài mà không có phần mềm bổ sung hoặc các gateway. Các giải pháp VPN này được mọi người tin cậy, nhưng sẽ phức tạp và có thể phá vỡ một số quá trình tự động hóa hoặc các software hook nhỏ khác.

Trước hay ngoài việc cam kết thiết lập VPN đầy đủ, bạn có thể triển khai một công cụ có tên là **Fail2ban**. Fail2ban có thể giảm thiểu đáng kể các cuộc tấn công brute force bằng cách tạo các quy tắc tự động thay đổi cấu hình tường lửa của bạn, để cấm các IP cụ thể sau một số lần đăng nhập không thành công. Điều này sẽ cho phép máy chủ của bạn tự bảo vệ trước những nỗ lực truy cập này mà không cần sự can thiệp của bạn.

Trong hướng dẫn này, bạn sẽ thấy cách cài đặt và sử dụng Fail2ban trên máy chủ Ubuntu 20.04.
## Điều kiện
Để thực hiện theo hướng dẫn này, bạn sẽ cần có:
* Một máy chủ Ubuntu 20.04 và non-root user có đặc quyền sudo. Bạn có thể tìm hiểu thêm về cách thiết lập một user có các đặc quyền này trong hướng dẫn Thiết lập máy chủ ban đầu với Ubuntu 20.04 của chúng tôi.
* Ngoài ra, máy chủ thứ hai mà bạn có thể kết nối với máy chủ đầu tiên của mình để sử dụng kiểm tra việc bị cấm.

## Bước 1: Cài đặt Fail2ban
Fail2ban có sẵn trong kho phần mềm của Ubuntu. Bắt đầu bằng cách chạy các lệnh dưới đây với tư cách non-root user để cập nhật danh sách gói của bạn và cài đặt Fail2ban:
```command
sudo apt update
sudo apt install fail2ban
```
Fail2ban sẽ tự động thiết lập một background service sau khi được cài đặt. Tuy nhiên, nó bị tắt theo mặc định, vì một số cài đặt mặc định của nó có thể gây ra các hiệu ứng không mong muốn. Bạn có thể xác minh điều này bằng cách sử dụng lệnh `systemctl`:
```command
systemctl status fail2ban.service
```
```
[secondary_label Output]
○ fail2ban.service - Fail2Ban Service
     Loaded: loaded (/lib/systemd/system/fail2ban.service; disabled; vendor preset: enabled
     Active: inactive (dead)
       Docs: man:fail2ban(1)
```
Bạn có thể bật Fail2ban ngay lập tức, nhưng trước tiên, bạn hãy xem xét một số tính năng của nó.
## Bước 2: Cấu hình Fail2ban
Fail2ban service giữ các tệp cấu hình của nó trong thư mục` / etc / fail2ban`. Có một tệp với các giá trị mặc định được gọi là `jail.conf`. Hãy đi tới thư mục đó và in 20 dòng đầu tiên của tệp đó bằng `head -20`:
```command
cd /etc/fail2ban
head -20 jail.conf
```
```
[secondary_label Output]
#
# WARNING: heavily refactored in 0.9.0 release.  Please review and
#          customize settings for your setup.
#
# Changes:  in most of the cases you should not modify this
#           file, but provide customizations in jail.local file,
#           or separate .conf files under jail.d/ directory, e.g.:
#
# HOW TO ACTIVATE JAILS:
#
# YOU SHOULD NOT MODIFY THIS FILE.
#
# It will probably be overwritten or improved in a distribution update.
#
# Provide customizations in a jail.local file or a jail.d/customisation.local.
# For example to change the default bantime for all jails and to enable the
# ssh-iptables jail the following (uncommented) would appear in the .local file.
# See man 5 jail.conf for details.
#
# [DEFAULT]
```
Như bạn thấy, một số dòng đầu tiên của tệp này được **commented out** (ghi chú) - chúng bắt đầu bằng ký tự `#`  cho biết rằng chúng sẽ được đọc dưới dạng tài liệu thay vì dưới dạng cài đặt. Và bạn có thể thấy, những ghi chú này hướng dẫn bạn không được trực tiếp sửa đổi tệp. Thay vào đó, bạn có hai lựa chọn: tạo hồ sơ riêng lẻ cho Fail2ban trong nhiều tệp ở thư mục `jail.d /`, hoặc tạo và thu thập tất cả cài đặt cục bộ của bạn trong tệp `jail.local`. Tệp `jail.conf` sẽ được cập nhật định kỳ khi Fail2ban được cập nhật và sẽ được sử dụng làm nguồn cài đặt mặc định mà bạn chưa tạo bất kỳ overrides (ghi đè) nào.

Trong hướng dẫn này, bạn sẽ tạo `jail.local`. Bạn có thể làm điều đó bằng cách sao chép `jail.conf`:
```command
sudo cp jail.conf jail.local
```
Bây giờ bạn có thể bắt đầu thực hiện các thay đổi cấu hình. Mở tệp bằng `nano` hoặc trình soạn thảo văn bản yêu thích của bạn:
```command
sudo nano jail.local
```
Trong khi bạn đang chuyển qua tệp, hướng dẫn này sẽ xem xét một số tùy chọn mà bạn có thể muốn cập nhật. Các cài đặt nằm trong phần `[DEFAULT]` gần đầu tệp sẽ được áp dụng cho tất cả các dịch vụ được Fail2ban hỗ trợ. Ở những nơi khác trong tệp, có các tiêu đề cho `[sshd]` và các dịch vụ khác, chứa các cài đặt dành riêng cho dịch vụ sẽ áp dụng thay thế các cài đặt mặc định.
```nginx
[label /etc/fail2ban/jail.local]
[DEFAULT]
. . .
bantime = 10m
. . .
```

Tham số `bantime` đặt khoảng thời gian mà khách hàng sẽ bị cấm khi họ không xác thực chính xác. Tham số này được đo bằng giây. Theo mặc định, thời gian sẽ được đặt thành 10 phút.

```nginx
[label /etc/fail2ban/jail.local]
[DEFAULT]
. . .
findtime = 10m
maxretry = 5
. . .
```

Hai tham số tiếp theo là `findtime` và `maxretry`. Chúng làm việc cùng nhau để thiết lập các điều kiện, khi khách hàng bị phát hiện là người dùng bất hợp pháp thì sẽ bị cấm.

Biến `maxretry` sẽ đặt số lần thử mà khách hàng phải xác thực trong khoảng thời gian được xác định bởi `findtime`, trước khi bị cấm. Với cài đặt mặc định, dịch vụ Fail2ban sẽ cấm khách hàng trong vòng 10 phút khi đăng nhập không thành công 5 lần.
```nginx
[label /etc/fail2ban/jail.local]
[DEFAULT]
. . .
destemail = root@localhost
sender = root@<fq-hostname>
mta = sendmail
. . .
```

Nếu bạn cần nhận thông báo qua email khi Fail2ban thực hiện hành động, bạn nên xem xét cài đặt `destemail`, `sendername` và `mta`. Tham số `destemail` đặt địa chỉ email nhận thư bị cấm. `Sendername` đặt giá trị của vùng "From" trong email. Tham số `mta` thiết lập cấu hình mail service sẽ được sử dụng để gửi thư. Theo mặc định, đây là `sendmail`, nhưng bạn có thể sử dụng Postfix hoặc một giải pháp gửi mail khác.
```nginx
[label /etc/fail2ban/jail.local]
[DEFAULT]
. . .
action = $(action_)s
. . .
```

Tham số này thiết lập cấu hình hành động mà Fail2ban thực hiện khi nó muốn thực hiện lệnh cấm. Giá trị `action_` được xác định trong tệp ngay trước tham số này. Hành động mặc định là cập nhật cấu hình tường lửa của bạn để từ chối lưu lượng truy cập từ máy chủ vi phạm cho đến khi hết thời gian cấm.

Có các tập lệnh` action_` khác được cung cấp theo mặc định mà bạn có thể thay thế `$ (action_)` ở trên:
```nginx
[label /etc/fail2ban/jail.local]
…
# ban & send an e-mail with whois report to the destemail.
action_mw = %(action_)s
            %(mta)s-whois[sender="%(sender)s", dest="%(destemail)s", protocol="%(protocol)s", chain="%(chain)s"]

# ban & send an e-mail with whois report and relevant log lines
# to the destemail.
action_mwl = %(action_)s
             %(mta)s-whois-lines[sender="%(sender)s", dest="%(destemail)s", logpath="%(logpath)s", chain="%(chain)s"]

# See the IMPORTANT note in action.d/xarf-login-attack for when to use this action
#
# ban & send a xarf e-mail to abuse contact of IP address and include relevant log lines
# to the destemail.
action_xarf = %(action_)s
             xarf-login-attack[service=%(__name__)s, sender="%(sender)s", logpath="%(logpath)s", port="%(port)s"]

# ban IP on CloudFlare & send an e-mail with whois report and relevant log lines
# to the destemail.
action_cf_mwl = cloudflare[cfuser="%(cfemail)s", cftoken="%(cfapikey)s"]
                %(mta)s-whois-lines[sender="%(sender)s", dest="%(destemail)s", logpath="%(logpath)s", chain="%(chain)s"]
…
```
Ví dụ: `action_mw` thực hiện hành động và gửi email, `action_mwl` thực hiện hành động, gửi email và bao gồm ghi nhật ký, `action_cf_mwl` thực hiện tất cả những điều trên cộng thêm việc gửi bản cập nhật cho Cloudflare API được liên kết với tài khoản của bạn để cấm người vi phạm ở đó.

### Cài đặt Individual  Jail cho dich vụ cần theo dõi
Tiếp theo là phần của tệp cấu hình liên quan đến các dịch vụ riêng lẻ. Chúng được chỉ định bởi các tiêu đề phân đoạn như là `[sshd]`.

Mỗi phần trong số này cần được kích hoạt riêng bằng cách thêm một dòng `enabled = true` dưới tiêu đề, cùng với các cài đặt khác của chúng.
```nginx
[label /etc/fail2ban/jail.local]
[<^>jail_to_enable<^>]
. . .
enabled = <^>true<^>
. . .
```
Theo mặc định, dịch vụ SSH được bật và tất cả các dịch vụ khác đều bị tắt. Một số cài đặt khác được đặt ở đây là `filter` sẽ được sử dụng để quyết định xem một dòng trong nhật ký có chỉ ra một xác thực không thành công hay không, và `logpath` cho Fail2ban biết vị trí của các nhật ký cho dịch vụ cụ thể đó.

Giá trị `filter` thực ra là một tham chiếu đến một tệp nằm trong thư mục `/etc/fail2ban/filter.d`, với phần mở rộng `.conf` của nó đã bị xóa. Các tệp này chứa regular expressions (biểu thức chính quy) (một cách viết tắt phổ biến để phân tích cú pháp văn bản) để xác định xem một dòng trong nhật ký có phải là một lần xác thực không thành công hay không. Chúng tôi sẽ không trình bày sâu về các tệp này trong bài hướng dẫn ở đây, vì chúng khá phức tạp và các cài đặt được xác định trước rất khớp với các dòng riêng biệt.

Tuy nhiên, bạn có thể xem loại filter nào có sẵn bằng cách xem xét thư mục đó:
```command
ls /etc/fail2ban/filter.d
```
Nếu bạn thấy một tệp có vẻ liên quan đến dịch vụ bạn đang sử dụng, bạn nên mở tệp đó bằng trình soạn thảo văn bản. Hầu hết các tệp đều được giải thích khá tốt và ít nhất bạn sẽ có thể biết được loại tình trạng mà script (ngôn ngữ kịch bản) được thiết kế để bảo vệ không bị tổn hại. Hầu hết các filter này đều có các phần riêng biệt (bị vô hiệu hóa) trong tệp `jail.conf`, mà chúng ta có thể bật trong tệp `jail.local` nếu muốn.

Ví dụ: hãy tưởng tượng rằng bạn đang phục vụ một trang web bằng Nginx, và nhận ra rằng một phần được bảo vệ bằng mật khẩu trang web của bạn đang bị đóng khi đăng nhập. Bạn có thể yêu cầu Fail2ban sử dụng tệp `nginx-http-auth.conf` để kiểm tra tình trạng này trong tệp `/var/log/nginx/error.log`.

Điều này đã được thiết lập trong một phần có tên `[nginx-http-auth]` trong tệp `/etc/fail2ban/jail.conf` của bạn. Bạn chỉ cần thêm thông số `enabled`:
```nginx
[label /etc/fail2ban/jail.local]
. . .
[nginx-http-auth]

enabled = <^>true<^>
. . .
```
Khi bạn hoàn tất chỉnh sửa, hãy lưu và đóng tệp. Tại thời điểm này, bạn có thể kích hoạt dịch vụ Fail2ban của mình để nó tự động chạy từ bây giờ. Đầu tiên, chạy `systemctl enable`:
```command
sudo systemctl enable fail2ban
```
Sau đó, khởi động thủ công lần đầu tiên với `systemctl start`:
```command
sudo systemctl start fail2ban
```
Bạn có thể xác minh nó đang chạy với `systemctl status`:
```command
sudo systemctl status fail2ban
```
```
[secondary_label Output]
● fail2ban.service - Fail2Ban Service
     Loaded: loaded (/lib/systemd/system/fail2ban.service; enabled; vendor preset: enab>
     Active: active (running) since Tue 2022-06-28 19:29:15 UTC; 3s ago
       Docs: man:fail2ban(1)
   Main PID: 39396 (fail2ban-server)
      Tasks: 5 (limit: 1119)
     Memory: 12.9M
        CPU: 278ms
     CGroup: /system.slice/fail2ban.service
             └─39396 /usr/bin/python3 /usr/bin/fail2ban-server -xf start

Jun 28 19:29:15 fail2ban20 systemd[1]: Started Fail2Ban Service.
Jun 28 19:29:15 fail2ban20 fail2ban-server[39396]: Server ready
```
Trong bước tiếp theo, bạn sẽ chứng minh Fail2ban đang hoạt động.

## Bước 3: Kiểm tra Chính sách Cấm (Tùy chọn)
Từ máy chủ khác, trong tương lai một máy chủ sẽ không cần đăng nhập vào Fail2ban server của bạn, bạn có thể kiểm tra các quy tắc bằng cách cấm máy chủ thứ hai đó. Sau khi đăng nhập vào máy chủ thứ hai của bạn, hãy thử SSH vào máy chủ Fail2ban. Bạn có thể thử kết nối bằng một nonexistent name:
```command
ssh blah@<^>your_server<^>
```
Nhập các ký tự ngẫu nhiên vào lời nhắc mật khẩu. Lặp lại điều này một vài lần. Tại một số điểm, lỗi bạn nhận được sẽ thay đổi từ `Permission denied` thành `Connection refused`. Điều này báo hiệu rằng máy chủ thứ hai của bạn đã bị cấm khỏi máy chủ Fail2ban.

Trên máy chủ Fail2ban, bạn có thể xem quy tắc mới bằng cách kiểm tra đầu ra `iptables` của mình. `iptables` là lệnh tương tác với các quy tắc tường lửa và cổng cấp thấp trên máy chủ của bạn. Nếu bạn đã làm theo hướng dẫn của CloudFly để thiết lập máy chủ ban đầu, bạn sẽ được sử dụng `ufw` để quản lý các quy tắc tường lửa ở cấp cao hơn. Chạy `iptables -S` sẽ hiển thị cho bạn tất cả các quy tắc tường lửa mà `ufw` đã tạo:
```command
sudo iptables -S
```
```
[secondary_label Output]
-P INPUT DROP
-P FORWARD DROP
-P OUTPUT ACCEPT
-N f2b-sshd
-N ufw-after-forward
-N ufw-after-input
-N ufw-after-logging-forward
-N ufw-after-logging-input
-N ufw-after-logging-output
-N ufw-after-output
-N ufw-before-forward
-N ufw-before-input
-N ufw-before-logging-forward
-N ufw-before-logging-input
-N ufw-before-logging-output
…
```
Nếu bạn chuyển đầu ra của `iptables -S` thành `grep` để tìm kiếm trong các quy tắc đó cho chuỗi `f2b`, bạn có thể thấy các quy tắc đã được thêm vào bởi Fail2ban:
```command
sudo iptables -S | grep f2b
```
```
[secondary_label Output]
-N f2b-sshd
-A INPUT -p tcp -m multiport --dports 22 -j f2b-sshd
-A f2b-sshd -s <^>134.209.165.184<^>/32 -j REJECT --reject-with icmp-port-unreachable
-A f2b-sshd -j RETURN
```
Dòng chứa `REJECT --reject-with icmp-port-unreachable` sẽ được Fail2ban thêm vào và phản ánh địa chỉ IP của máy chủ thứ hai của bạn.

## Kết luận
Bây giờ bạn có thể thiết lập cấu hình một số chính sách cấm cho các dịch vụ của mình. Fail2ban là một cách hữu ích để bảo vệ bất kỳ loại dịch vụ nào sử dụng xác thực. Nếu bạn muốn tìm hiểu thêm về cách Fail2ban hoạt động, bạn có thể xem hướng dẫn của chúng tôi về Cách hoạt động của các quy tắc và tệp Fail2ban.

Để biết thêm thông tin về cách sử dụng Fail2ban để bảo vệ các dịch vụ khác, bạn có thể đọc Cách bảo vệ máy chủ Nginx bằng Fail2Ban trên Ubuntu 14.04 và Cách bảo vệ máy chủ Apache bằng Fail2Ban trên Ubuntu 14.04.

Cách bảo vệ SSH bằng Fail2Ban trên Ubuntu 20.04

![description image](https://media.cloudfly.vn/posts/Cách_Cài_Đặt_MySQL_Trên_Ubuntu_20.04.png)
## Giới thiệu
MySQL là một hệ quản trị cơ sở dữ liệu mã nguồn mở, thường được cài đặt như một phần của LAMP (Linux, Apache, MySQL, PHP/Python/Perl) stack phổ biến.  Nó triển khai mô hình quan hệ và sử dụng ngôn ngữ truy vấn có cấu trúc (hay còn gọi là SQL - Structured Query Language) để quản lý dữ liệu. 
Hướng dẫn này sẽ giới thiệu cho các bạn cách cài đặt MySQL phiên bản 8.0 trên máy chủ Ubuntu 20.04. Sau khi hoàn thành, bạn sẽ có một cơ sở dữ liệu quan hệ đang hoạt động, có thể sử dụng để xây dựng trang web hoặc ứng dụng tiếp theo của mình.
## Yêu cầu
* Một máy chủ Ubuntu 20.04 với user quản trị không phải root và tường lửa được định cấu hình bằng UFW.
### Bước 1: Cài đặt MySQL
Trên Ubuntu 20.04, bạn có thể cài đặt MySQL bằng cách sử dụng kho lưu trữ gói APT. Tại thời điểm này, phiên bản MySQL có sẵn trong kho lưu trữ Ubuntu mặc định là phiên bản 8.0.27.
Để cài đặt, hãy cập nhật chỉ mục gói trên server của bạn nếu gần đây bạn chưa làm như vậy:
```content super_user
sudo apt update
```
Sau đó, cài đặt gói `mysql-server`:
```content super_user
sudo apt install mysql-server
```
Đảm bảo rằng server đang chạy bằng cách sử dụng lệnh `systemctl start`:
```content super_user
sudo systemctl start mysql.service
```
Các lệnh này sẽ cài đặt và khởi động MySQL, nhưng sẽ không nhắc bạn đặt mật khẩu hoặc thực hiện bất kỳ thay đổi cấu hình nào khác. Vì điều này khiến quá trình cài đặt MySQL của bạn không an toàn, tiếp theo chúng tôi sẽ giải quyết vấn đề này.
### Bước 2: Cấu hình MySQL
Đối với các bản cài đặt mới của MySQL, bạn sẽ muốn chạy tập lệnh bảo mật đi kèm của DBMS. Tập lệnh này thay đổi một số tùy chọn mặc định kém an toàn hơn cho những thứ như thông tin đăng nhập mặc định từ xa và người dùng mẫu.
```warning
**Warning:** Kể từ tháng 7 năm 2022, lỗi sẽ xảy ra khi bạn chạy tập lệnh `mysql_secure_installation` mà không có một số cấu hình khác. Lý do là tập lệnh này cố gắng đặt mật khẩu cho tài khoản MySQL gốc của cài đặt nhưng theo mặc định trên cài đặt Ubuntu, tài khoản này không được định cấu hình để kết nối bằng mật khẩu. 
Trước tháng 7 năm 2022, tập lệnh này không thành công sau khi cố gắng đặt mật khẩu tài khoản gốc và tiếp tục với phần còn lại của lời nhắc. Tuy nhiên, khi viết script này, script sẽ trả về lỗi sau khi bạn nhập và xác nhận mật khẩu.
```
Chạy tập lệnh bảo mật với `sudo`:
```content super_user
sudo mysql_secure_installation
```
Sau khi chạy tập lệnh sẽ đưa bạn qua một loạt lời nhắc, tại đây bạn có thể thực hiện một số thay đổi đối với các tùy chọn bảo mật của cài đặt MySQL của mình. Lời nhắc đầu tiên sẽ hỏi bạn có muốn thiết lập Validate Password Plugin, có thể được sử dụng để kiểm tra độ mạnh mật khẩu của người dùng MySQL mới trước khi cho là hợp lệ hay không. 
Nếu bạn chọn thiết lập Validate Password Plugin, bất kỳ người dùng MySQL nào mà bạn tạo xác thực bằng mật khẩu sẽ được yêu cầu có mật khẩu đáp ứng policy bạn chọn. Cấp policy mạnh nhất – mà bạn có thể chọn bằng cách nhập 2 – sẽ yêu cầu mật khẩu phải dài ít nhất 8 ký tự và bao gồm kết hợp các ký tự viết hoa, viết thường, số và ký tự đặc biệt:
```output
Securing the MySQL server deployment.

Connecting to MySQL using a blank password.

VALIDATE PASSWORD COMPONENT can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD component?

Press y|Y for Yes, any other key for No: Y

There are three levels of password validation policy:

LOW    Length >= 8
MEDIUM Length >= 8, numeric, mixed case, and special characters
STRONG Length >= 8, numeric, mixed case, special characters and dictionary                  file

Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG:
 2
```
Bất kể bạn chọn thiết lập Validate Password Plugin hay không, lời nhắc tiếp theo sẽ là đặt mật khẩu cho người dùng MySQL root. Nhập và sau đó xác nhận một mật khẩu bảo mật mà bạn chọn:
```output
Please set the password for root here.


New password:

Re-enter new password:
```
Lưu ý rằng mặc dù bạn đã đặt mật khẩu cho người dùng MySQL root, người dùng này hiện không được cấu hình để xác thực bằng mật khẩu khi kết nối với MySQL shell.
Nếu bạn sử dụng Validate Password Plugin, bạn sẽ nhận được phản hồi về độ mạnh của mật khẩu mới của mình. Sau đó, script sẽ hỏi bạn có muốn tiếp tục với mật khẩu vừa nhập hay muốn nhập mật khẩu mới. Giả sử bạn hài lòng với độ mạnh của mật khẩu bạn vừa nhập, hãy nhập `Y` để tiếp tục script:
```output
Estimated strength of the password: 100
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : Y
```
Từ đó bạn có thể nhấn `Y` và sau đó nhấn ENTER để chấp nhận giá trị mặc định cho tất cả các câu hỏi tiếp theo. Thao tác này sẽ xóa một số người dùng ẩn danh và cơ sở dữ liệu thử nghiệm, vô hiệu hóa đăng nhập root từ xa và load các quy tắc mới này để MySQL ngay lập tức tuân theo những thay đổi bạn đã thực hiện.
Khi script hoàn tất, cài đặt MySQL sẽ được bảo mật. Bây giờ, bạn có thể chuyển sang tạo người dùng cơ sở dữ liệu chuyên dụng với MySQL client.
### Bước 3: Tạo người dùng MySQL chuyên dụng và cấp các đặc quyền
Sau khi cài đặt, MySQL tạo một tài khoản người dùng root mà bạn có thể sử dụng để quản lý cơ sở dữ liệu của mình. User này có toàn quyền đối với server MySQL, có nghĩa là nó có toàn quyền kiểm soát mọi cơ sở dữ liệu, bảng, người dùng, v.v. Do đó, tốt nhất bạn nên tránh sử dụng tài khoản này bên ngoài các chức năng quản trị. Bước này phác thảo cách sử dụng người dùng MySQL gốc để tạo tài khoản người dùng mới và cấp đặc quyền cho tài khoản đó.
Trong hệ thống Ubuntu chạy MySQL 5.7 (và các version mới hơn). Người dùng MySQL root được đặt để xác thực bằng cách sử dụng plugin `auth_socket` theo mặc định chứ không phải bằng mật khẩu. 
Plugin này yêu cầu tên của user hệ điều hành gọi MySQL client phải khớp với tên của người dùng MySQL được chỉ định trong lệnh, vì vậy bạn phải gọi `mysql` với đặc quyền `sudo` để có quyền truy cập vào user MySQL root:
```content super_user
sudo mysql
```
```note
**Note:** Nếu bạn đã cài đặt MySQL bằng một hướng dẫn khác và bật xác thực mật khẩu cho root bạn sẽ cần sử dụng một lệnh khác để truy cập MySQL shell. Lệnh sau sẽ chạy MySQL client của bạn với các đặc quyền người dùng thông thường và bạn sẽ chỉ có được các đặc quyền của admin trong cơ sở dữ liệu bằng cách xác thực:

mysql -u root -p
```
Khi có quyền truy cập vào lời nhắc MySQL, bạn có thể tạo người dùng mới bằng câu lệnh `CREATE USER`. Chúng tuân theo cú pháp chung sau:
```content super_user
CREATE USER 'username'@'host' IDENTIFIED WITH authentication_plugin BY 'password';
```
Sau `CREATE USER`, bạn chỉ định tên người dùng. Ngay sau đó là dấu @ và tiếp đến là tên server mà user này sẽ kết nối. Nếu bạn chỉ định truy cập cục bộ người dùng này từ máy chủ Ubuntu của mình, bạn có thể chỉ định `localhost`. Việc gói cả tên người dùng và server trong một dấu ngoặc kép không phải lúc nào cũng cần thiết, nhưng làm như vậy có thể giúp tránh lỗi.
Bạn có một số tùy chọn khi chọn plugin xác thực người dùng của mình. Plugin `auth_socket` được đề cập trước đây có thể tiện lợi vì nó cung cấp bảo mật mạnh mẽ mà không yêu cầu người dùng hợp lệ nhập mật khẩu để truy cập cơ sở dữ liệu. Nhưng nó cũng ngăn chặn các kết nối từ xa, điều này có thể làm phức tạp mọi thứ khi các chương trình bên ngoài cần tương tác với MySQL.

Thay vào đó, bạn có thể loại bỏ hoàn toàn phần `WITH verify_plugin` của cú pháp để người dùng xác thực bằng plugin mặc định của MySQL,`caching_sha2_password`. Tài liệu MySQL đề xuất plugin này cho người dùng muốn đăng nhập bằng mật khẩu do tính năng bảo mật mạnh mẽ của nó.
Chạy lệnh sau để tạo người dùng xác thực với `caching_sha2_password`. Đảm bảo thay đổi `sammy` thành tên người dùng và password thành một mật khẩu mạnh mà bạn chọn: 

```content super_user
mysql> CREATE USER 'sammy'@'localhost' IDENTIFIED BY 'password';
```
```note
**Note:** Một số phiên bản PHP gây ra sự cố với `caching_sha2_password`. Nếu bạn định sử dụng cơ sở dữ liệu này với một ứng dụng PHP – ví dụ: phpMyAdmin – bạn có thể muốn tạo một người dùng sẽ xác thực với plugin `mysql_native_password` cũ hơn, nhưng vẫn bảo mật, thay vào đó:
```
```content super_user
mysql> CREATE USER 'sammy'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
```
```note
Nếu không chắc chắn, bạn luôn có thể tạo người dùng xác thực bằng `caching_sha2_plugin` và thay đổi nó thành `ALTER` bằng câu lệnh sau:
```
```content super_user
mysql> ALTER USER 'sammy'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
```
Sau khi tạo user mới, bạn có thể cấp cho họ các đặc quyền thích hợp. Cú pháp chung để cấp đặc quyền người dùng như sau:
```content super_user
mysql> GRANT PRIVILEGE ON database.table TO 'username'@'host';
```
Giá trị `PRIVILEGE` trong cú pháp ví dụ này xác định những hành động mà người dùng được phép thực hiện trên `database` và `table` được chỉ định. Bạn có thể cấp nhiều đặc quyền cho cùng một người dùng trong một lệnh bằng cách phân tách từng đặc quyền bằng dấu phẩy. Bạn cũng có thể cấp đặc quyền người dùng bằng cách nhập dấu hoa thị (`*`) vào vị trí của cơ sở dữ liệu và tên bảng. Trong SQL, dấu hoa thị là các ký tự đặc biệt được sử dụng để đại diện cho “tất cả” cơ sở dữ liệu hoặc bảng.
Để minh họa, lệnh sau đây cấp cho người dùng đặc quyền để `CREATE`, `ALTER` và `DROP` cơ sở dữ liệu, bảng và người dùng, cũng như quyền `INSERT`, `UPDATE` và `DELETE` dữ liệu từ bất kỳ bảng nào trên máy chủ. Nó cũng cấp cho người dùng khả năng truy vấn dữ liệu với `SELECT`, tạo khóa ngoại Foreign Key với từ khóa `REFERENCES` và thực hiện các hoạt động `FLUSH` với đặc quyền `RELOAD`. Tuy nhiên, bạn chỉ nên cấp cho người dùng các quyền mà họ cần, vì vậy, hãy thoải mái điều chỉnh các đặc quyền của người dùng nếu cần.
Bạn có thể tìm thấy danh sách đầy đủ các đặc quyền có sẵn trong tài liệu MySQL chính thức.
Chạy lệnh `GRANT`  thay thế `sammy` bằng tên người dùng MySQL của riêng bạn, để cấp các đặc quyền này cho người dùng của bạn:
```content super_user
mysql> GRANT CREATE, ALTER, DROP, INSERT, UPDATE, DELETE, SELECT, REFERENCES, RELOAD on *.* TO 'sammy'@'localhost' WITH GRANT OPTION;
```
Lưu ý rằng lệnh này cũng bao gồm `WITH GRANT OPTION`. Điều này sẽ cho phép người dùng MySQL của bạn cấp bất kỳ quyền nào mà nó có cho những người dùng khác trên hệ thống.
```warning
**Warning: Một số người dùng có thể muốn cấp cho người dùng MySQL của họ đặc quyền `ALL PRIVILEGES`, đặc quyền này sẽ cung cấp cho họ các đặc quyền siêu người dùng rộng rãi tương tự như đặc quyền của người dùng root, như sau:
```
```content super_user
mysql> GRANT ALL PRIVILEGES ON *.* TO 'sammy'@'localhost' WITH GRANT OPTION;
```
```warning
Không nên coi nhẹ việc cấp các đặc quyền rộng rãi như vậy, vì bất kỳ ai có quyền truy cập vào user MySQL này sẽ có toàn quyền kiểm soát mọi cơ sở dữ liệu trên máy chủ.
```
Sau đây, bạn nên chạy lệnh `FLUSH PRIVILEGES`. Điều này sẽ giải phóng bất kỳ bộ nhớ nào mà máy chủ đã lưu vào bộ nhớ cache do kết quả của các câu lệnh `CREATE USER` và `GRANT` trước đó:
```content super_user
mysql> FLUSH PRIVILEGES;
```
Sau đó, bạn có thể thoát khỏi máy khách MySQL:
```content super_user
mysql> exit
```
Trong tương lai, để đăng nhập với tư cách là người dùng MySQL mới của bạn, bạn sẽ sử dụng một lệnh như sau:
```content super_user
mysql -u sammy -p
```
Flag `-p` sẽ khiến MySQL client nhắc bạn nhập mật khẩu của người dùng MySQL để xác thực.
Cuối cùng, hãy kiểm tra cài đặt MySQL.
### Bước 4: Kiểm tra MySQL
Bất kể bạn đã cài đặt nó như thế nào, MySQL phải bắt đầu chạy tự động. Để thử nghiệm, hãy kiểm tra trạng thái của nó.
```content super_user
systemctl status mysql.service
```
Bạn sẽ thấy đầu ra tương tự như sau:
```output
● mysql.service - MySQL Community Server
     Loaded: loaded (/lib/systemd/system/mysql.service; enabled; vendor preset: enabled)
     Active: active (running) since Tue 2020-04-21 12:56:48 UTC; 6min ago
   Main PID: 10382 (mysqld)
     Status: "Server is operational"
      Tasks: 39 (limit: 1137)
     Memory: 370.0M
     CGroup: /system.slice/mysql.service
             └─10382 /usr/sbin/mysqld
```
Nếu MySQL không chạy, bạn có thể bắt đầu bằng `sudo systemctl start mysql`
Để kiểm tra thêm, bạn có thể thử kết nối với cơ sở dữ liệu bằng cách sử dụng tool `mysqladmin` là một ứng dụng khách cho phép bạn chạy các lệnh quản trị. Ví dụ: lệnh này cho biết kết nối với tư cách là người dùng MySQL có tên là sammy  (`-u sammy`), nhắc nhập mật khẩu (`-p`) và trả về version. Đảm bảo thay đổi `sammy` thành tên của người dùng MySQL chuyên dụng của bạn và nhập mật khẩu của người dùng đó khi được nhắc: 
```content super_user
sudo mysqladmin -p -u sammy version
```
Bạn sẽ thấy đầu ra tương tự như sau:
```output
mysqladmin  Ver 8.0.19-0ubuntu5 for Linux on x86_64 ((Ubuntu))
Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Server version        8.0.19-0ubuntu5
Protocol version    10
Connection        Localhost via UNIX socket
UNIX socket        /var/run/mysqld/mysqld.sock
Uptime:            10 min 44 sec

Threads: 2  Questions: 25  Slow queries: 0  Opens: 149  Flush tables: 3  Open tables: 69  Queries per second avg: 0.038
```
Điều này có nghĩa là MySQL đang hoạt động.
Trên đây chúng tôi đã hướng dẫn chi tiết 4 bước cài đặt MySQL trên Ubuntu 20.04 rất đơn giản dễ làm. Chúc bạn thực hiện thành công nhé!

MySQL là một hệ quản trị cơ sở dữ liệu mã nguồn mở, thường được cài đặt như một phần của LAMP (Linux, Apache, MySQL, PHP/Python/Perl) stack phổ biến

Cách Cài Đặt MySQL Trên Ubuntu 20.04

## Giới thiệu
Cơ sở dữ liệu phát triển theo thời gian và đôi khi nó lớn hơn dung lượng trên hệ thống file gốc. Khi chúng nằm trên cùng một phân vùng với phần còn lại của hệ điều hành, có thể sẽ dẫn đến tranh chấp I / O.
RAID, Network Block Storage và các thiết bị khác có thể cung cấp khả năng dự phòng và cải thiện khả năng mở rộng cùng với các tính năng khác. Cho dù bạn thêm dung lượng, đánh giá các cách để tối ưu hóa hiệu suất hay đang tìm cách tận dụng các tính năng lưu trữ khác, hướng dẫn này sẽ giúp bạn cách di chuyển lại thư mục dữ liệu của PostgreSQL.
## Điều kiện
Để hoàn thành theo hướng dẫn này, bạn cần có những điều sau:
* Một máy chủ Ubuntu 20.04 với non-**root** user có đặc quyền `sudo`. Bạn có thể tìm hiểu thêm về cách thiết lập người dùng có các đặc quyền này trong hướng dẫn Thiết lập máy chủ ban đầu với Ubuntu 20.04.
* PostgreSQL được cài đặt trên máy chủ của bạn. Nếu bạn chưa thiết lập, hướng dẫn Cách cài đặt và sử dụng PostgreSQL trên Ubuntu 20.04 có thể giúp bạn.

Các ví dụ trong hướng dẫn này sẽ liên quan đến việc di chuyển dữ liệu sang thiết bị Block Storage được gắn tại `/ mnt / volume_nyc1_01`. Nếu bạn đang sử dụng Block Storage trên CloudFly, hãy đọc tài liệu về Cách tạo và thiết lập Volumes để sử dụng máy chủ ảo, để được hướng dẫn cách gắn Volumes của mình trước khi tiếp tục với bài viết này.
Tuy nhiên, bất kể bộ nhớ cơ bản bạn sử dụng là gì, các bước dưới đây có thể giúp bạn di chuyển thư mục dữ liệu đến một vị trí mới.
## Bước 1: Di chuyển Thư mục dữ liệu PostgreSQL
Trước khi chúng ta bắt đầu với việc di chuyển thư mục dữ liệu của PostgreSQL, hãy xác minh vị trí hiện tại bằng cách bắt đầu một phiên PostgreSQL tương tác. Trong lệnh dưới đây, `psql` là lệnh để vào màn hình tương tác và `-u postgres` yêu cầu `sudo` thực thi `psql` với tư cách là người dùng **postgres** của hệ thống:
```command
sudo -u postgres psql
```
Khi bạn đã mở ra PostgreSQL, hãy sử dụng lệnh sau để hiển thị thư mục dữ liệu hiện tại:

```custom_prefix(postgres=#)
SHOW data_directory;
```

```
[secondary_label Output]
       data_directory
-----------------------------
<^>/var/lib/postgresql/12/main<^>
(1 row)
```
Kết quả này xác nhận rằng PostgreSQL đã được cấu hình để sử dụng thư mục dữ liệu mặc định, `/ var / lib / postgresql / 12 / main`, vì vậy đó là thư mục bạn cần di chuyển. Khi bạn đã xác nhận thư mục trên hệ thống của mình, bạn có thể đóng `psql` ngay tức thì bằng cách chạy `\ q` meta-command:
```custom_prefix(postgres=#)
\q
```
Để đảm bảo tính toàn vẹn của dữ liệu, hãy dừng PostgreSQL trước khi bạn thực hiện các thay đổi đối với thư mục dữ liệu:
```command
sudo systemctl stop postgresql
```
`systemctl` không hiển thị kết quả của tất cả các lệnh quản lý dịch vụ. Để xác minh rằng bạn đã dừng dịch vụ thành công, hãy sử dụng lệnh sau:
```command
sudo systemctl status postgresql
```
Output này sẽ cho bạn biết rằng PostgreSQL `inactive (dead)`, có nghĩa là nó đã bị dừng:
```
[secondary_label Output]
● postgresql.service - PostgreSQL RDBMS
Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; vendor pr>
Active: <^>inactive (dead) since Thu 2022-06-30 16:55:53 UTC; 12s ago<^>
Process: 13058 ExecStart=/bin/true (code=exited, status=0/SUCCESS)
Main PID: 13058 (code=exited, status=0/SUCCESS)
```
Bây giờ máy chủ PostgreSQL không còn chạy nữa, hãy sao chép thư mục cơ sở dữ liệu hiện có vào vị trí mới bằng `rsync`. Sử dụng lệnh `-a` để giữ nguyên các quyền và các thuộc tính thư mục khác, và lệnh `-v` cung cấp đầu ra giúp bạn theo dõi tiến trình. Bạn sẽ bắt đầu `rsync` từ thư mục `postgresql` để làm theo cấu trúc thư mục gốc ở vị trí mới. Bằng cách tạo thư mục `postgresql` đó trong thư mục mount-point và giữ quyền sở hữu bởi người dùng PostgreSQL, bạn có thể tránh các vấn đề về quyền cho các bản nâng cấp trong tương lai.

<$>[note]
**Lưu ý:** Hãy chắc chắn rằng không có dấu gạch chéo trên thư mục, nhưng bạn có thể thêm vào nếu sử dụng `TAB` hoàn thành. Nếu bạn làm bao gồm dấu gạch chéo, `rsync` sẽ loại bỏ nội dung của thư mục vào điểm gắn kết thay vì sao chép qua chính thư mục đó.
<$>

Thư mục phiên bản `12` không hoàn toàn cần thiết vì bạn đã xác định vị trí một cách rõ ràng trong tệp `postgresql.conf`, nhưng việc tuân theo quy ước dự án chắc chắn sẽ không ảnh hưởng gì, đặc biệt nếu trong tương lai có nhu cầu chạy nhiều phiên bản của PostgreSQL:
```command
sudo rsync -av /var/lib/postgresql <^>/mnt/volume_nyc1_01<^>
```
Khi quá trình sao chép hoàn tất, hãy đổi tên thư mục hiện tại bằng phần mở rộng `.bak` và giữ nó cho đến khi bạn xác nhận rằng quá trình di chuyển thành công. Điều này sẽ giúp tránh phát sinh nhầm lẫn khi có các thư mục có tên giống nhau ở cả vị trí mới và vị trí cũ:
```command
sudo mv /var/lib/postgresql/12/main /var/lib/postgresql/12/main.bak
```
Bây giờ bạn đã sẵn sàng định cấu hình PostgreSQL để truy cập vào thư mục dữ liệu ở vị trí mới của nó.
## Bước 2: Cấu hình PostgreSQL trên server mới
Theo mặc định, cấu hình chỉ thị `data_directory` được đặt thành `/var/lib/postgresql/12/main` trong tệp `/etc/postgresql/12/main/postgresql.conf`. Chỉnh sửa tệp này để phản ánh thư mục dữ liệu mới:
```command
sudo nano /etc/postgresql/12/main/postgresql.conf
```
Tìm dòng bắt đầu bằng `data_directory` và thay đổi đường dẫn dưới đây để phản ánh vị trí mới. Trong ngữ cảnh của hướng dẫn này, chỉ thị cập nhật sẽ được viết là:
```nginx
[label /etc/postgresql/12/main/postgresql.conf]
. . .
data_directory = '<^>/mnt/volume_nyc1_01/postgresql/12/main<^>'
. . .
```
Lưu và đóng tệp bằng cách nhấn `CTRL + X`, `Y`, sau đó `ENTER`. Đây là tất cả những gì bạn cần làm để cấu hình PostgreSQL sử dụng vị trí thư mục dữ liệu mới. Tại thời điểm này, tất cả những gì còn lại là khởi động lại dịch vụ PostgreSQL và kiểm tra xem nó có thực sự trỏ đến đúng thư mục dữ liệu hay không.
## Bước 3: Khởi động lại PostgreSQL
Sau khi thay đổi chỉ thị `data-directory` trong tệp `postgresql.conf`, hãy tiếp tục và khởi động máy chủ PostgreSQL bằng `systemctl`:
```command
sudo systemctl start postgresql
```
Để xác nhận rằng máy chủ PostgreSQL đã khởi động thành công, hãy kiểm tra lại trạng thái của nó bằng cách sử dụng `systemctl`:
```command
sudo systemctl status postgresql
```
Nếu service khởi động chính xác, dòng `Active` sẽ cho biết `active (exited)` trong output của lệnh:
```
[secondary_label Output]
● postgresql.service - PostgreSQL RDBMS
     Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; vendor pr>
     Active: <^>active (exited) since Thu 2022-06-30 16:58:17 UTC; 2s ago<^>
    Process: 13143 ExecStart=/bin/true (code=exited, status=0/SUCCESS)
   Main PID: 13143 (code=exited, status=0/SUCCESS)
```
Cuối cùng, để đảm bảo rằng thư mục dữ liệu mới đang thực sự được sử dụng, hãy mở yêu cầu PostgreSQL ngay:
```command
sudo -u postgres psql
```
Kiểm tra lại giá trị cho thư mục dữ liệu:
```custom_prefix(postgres=#)
SHOW data_directory;
```
```
[secondary_label Output]
            data_directory
-----------------------------------------
<^>/mnt/volume_nyc1_01/postgresql/12/main<^>
(1 row)
```
Điều này xác nhận rằng PostgreSQL đang sử dụng vị trí thư mục dữ liệu mới. Sau đó, hãy dành một chút thời gian để đảm bảo rằng bạn có thể truy cập cơ sở dữ liệu của mình cũng như tương tác với dữ liệu bên trong. Sau khi đã xác minh toàn bộ mọi dữ liệu hiện có, bạn có thể xóa thư mục dữ liệu sao lưu:
```command
sudo rm -Rf /var/lib/postgresql/12/main.bak
```
Như vậy, bạn đã di chuyển thành công thư mục dữ liệu PostgreSQL của mình sang một vị trí mới.
## Kết luận
Nếu bạn đã theo dõi, cơ sở dữ liệu của bạn sẽ chạy cùng với thư mục dữ liệu của nó ở vị trí mới và bạn đã hoàn thành một bước quan trọng để có thể mở rộng bộ nhớ của mình. Bạn cũng có thể tham khảo 5 Thiết lập Máy chủ Chung cho Ứng dụng Web của Bạn để có thêm ý tưởng về cách tạo cơ sở hạ tầng máy chủ giúp bạn mở rộng quy mô và tối ưu hóa các ứng dụng web.

Cách chuyển toàn bộ dữ liệu của PostgreSQL đến máy chủ mới trên Ubuntu 20.04

Cấu Hình BIND Như Một Cho Máy Chủ DNS Nội Bộ Trên Ubuntu 20.04

![description image](https://media.cloudfly.vn/posts/cach-di-chuyen-thu-muc-du-lieu-PostgreSQL-trenUbuntu20.04.jpeg)
## Giới thiệu 
Khi thiết lập một server, thường có các phần của trang web 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, nhưng  chính server web có thể được sử dụng để hạn chế quyền truy cập nếu các phương thức này không đủ hoặc không khả dụng. Tuy nhiên, việc xác thực server web cũng đại diện cho sự tấn công bề mặt (attack surface) hoặc tấn công vector, thông qua những gì mà mọi người có thể cố gắng truy cập lại.
Bất kỳ service nào tiếp xúc với Internet đều là mục tiêu tiềm năng của việc tấn công này. Nếu bạn xem lại nhật kí lưu lượng truy cập của web server, bạn sẽ thấy sự lặp lại thường xuyên, việc nỗ lực đăng nhập vào hệ thống đại diện cho các cuộc tấn công của user và bots là như nhau. 
Trước khi thiết lập VPN, bạn có thể triển khai một công cụ được gọi là Fail2ban. Fail2ban có thể giảm thiểu đáng kể các cuộc tấn công brute force bằng cách tạo các quy tắc tự động thay đổi cấu hình tường lửa của bạn để cấm các IP cụ thể sau một số lần đăng nhập không thành công. Điều này sẽ cho phép server của bạn tự chống lại trước những nỗ lực truy cập này mà không cần sự can thiệp của bạn.
Qua bài hướng dẫn này chúng tôi sẽ chỉ cho bạn cách cài đặt `fail2ban` trên Ubuntu 20.04 và 
cấu hình chúng để giám sát log Nginx của bạn tìm các nỗ lực xâm nhập. 
Yêu cầu
* Môi trường máy chủ Ubuntu 20.04 và một user non-root với quyền `sudo` 
* Cài đặt Nginx vào hệ thống của bạn 
### Bước 1: Cài đặt và cấu hình Fail2ban
Fail2ban có sẵn trong kho phần mềm của Ubuntu. Bắt đầu chạy lệnh với user không phải root để cập nhật danh sách các gói và cài đặt Fail2ban:
```content super_user
sudo apt update
sudo apt install fail2ban
```
Fail2ban sẽ tự động thiết lập background service sau khi được cài đặt. Tuy nhiên nó sẽ tắt theo mặc định, vì một số cài đặt mặc định của nó có thể gây ra các hiệu ứng không mong muốn. Bạn có thể kiểm chứng bằng cách sử dụng lệnh `systemctl`:
```content super_user
systemctl status fail2ban.service
```
```output
 fail2ban.service - Fail2Ban Service
     Loaded: loaded (/lib/systemd/system/fail2ban.service; disabled; vendor preset: enabled
     Active: inactive (dead)
       Docs: man:fail2ban(1)
```
Bạn có thể bật Fail2ban ngay bây giờ, nhưng đầu tiên, bạn sẽ xem xét một số tính năng của nó.
Fail2ban giữ các tệp cấu hình của nó trong thư mục `/ etc / fail2ban`. Đây là file mặc định được gọi là `jail.conf`. Đi đến thư mục đó và in 20 dòng đầu tiên của file đó bằng cách sử dụng `head -20`:
```content super_user
cd /etc/fail2ban
head -20 jail.conf
```
```output
#
# WARNING: heavily refactored in 0.9.0 release.  Please review and
#          customize settings for your setup.
#
# Changes:  in most of the cases you should not modify this
#           file, but provide customizations in jail.local file,
#           or separate .conf files under jail.d/ directory, e.g.:
#
# HOW TO ACTIVATE JAILS:
#
# YOU SHOULD NOT MODIFY THIS FILE.
#
# It will probably be overwritten or improved in a distribution update.
#
# Provide customizations in a jail.local file or a jail.d/customisation.local.
# For example to change the default bantime for all jails and to enable the
# ssh-iptables jail the following (uncommented) would appear in the .local file.
# See man 5 jail.conf for details.
#
# [DEFAULT]
```
Chúng ta thấy, một số dòng đầu tiên của file này là **commented out** - Chúng bắt đầu với các kí tự `#` chỉ ra rằng chúng sẽ được đọc dưới dạng tài liệu thay vì dưới dạng cài đặt. Bạn cũng thấy rằng những nhận xét này đang hướng dẫn bạn không được trực tiếp sửa đổi file này. Thay vào đó có hai tuỳ chọn: tạo các cấu hình riêng lẻ cho Fail2ban trong nhiều file trong thư mục `jail.d /` hoặc tạo và thu thập tất cả các cài đặt local của bạn trong một file `jail.local`. File `jail.conf` sẽ được cập nhật định kỳ vì chính Fail2ban được cập nhật và sẽ được sử dụng làm nguồn cài đặt mặc định mà bạn chưa tạo bất kỳ overrides nào. Trong hướng dẫn này, bạn sẽ tạo `jail.local`. Bạn có thể copy `jail.conf`:
```content super_user
sudo cp jail.conf jail.local
```
Bây giờ bạn có thể bắt đầu thực hiện các thay đổi cấu hình. Mở file trong `nano` hoặc trình soạn thảo văn bản mà bạn thích:
```content super_user
sudo nano jail.local
```
**Thay đổi mặc định**
Bạn sẽ bắt đầu bằng cách đánh giá các giá trị mặc định trong tệp. Bạn sẽ tìm thấy `[DEFAULT]` trong file. Các mục này được đặt chính sách chung và có thể được overrides trên mỗi ứng dụng cơ bản. Nếu bạn sử dụng `nano`, bạn có thể tìm kiếm trong file bằng cách nhấn `Ctrl + W`, nhập tìm kiếm, sau đó nhấn `enter`.
Một trong những mục đầu tiên bạn cần xem xét là danh sách khách hàng không theo chính sách Fail2ban. Được cài đặt bởi `ignoreip`. Đôi khi bạn nên thêm địa chỉ IP hoặc mạng vào danh sách các trường hợp ngoại lệ để tránh tự khóa mình. Điều này sẽ xảy ra ít vấn đề hơn SSH khi đăng nhập với web server. Vì nếu bạn có thể duy trì quyền truy cập shell, bạn có thể đảo ngược lệnh cấm. Bạn có thể bỏ ghi chú dòng này và thêm các địa chỉ IP hoặc mạng bổ sung được phân cách bằng dấu cách, vào danh sách hiện có:
```command /etc/fail2ban/jail.local
[DEFAULT]

. . .
#ignoreip = 127.0.0.1/8 your_home_IP
```
Ngoài ra có một mục có thể bạn muốn điều chỉnh `bantime`. Bởi nó sẽ kiểm soát có sau bao nhiêu giây có một thành viên vi phạm. Thiết lập tốt nhất là cài đặt một khoảng thời gian đủ dài để làm để làm gián đoạn các nổ lực tự động đồng thời đủ ngắn để user có thể sửa lỗi. Bạn có thể tăng hoặc giảm giá trị này:
```command /etc/fail2ban/jail.local
[DEFAULT]

. . .
bantime = 10m
```
Hai mục tiếp theo sẽ xác định phạm vi dòng nhật kí sử dụng nhằm xác định client vi phạm. `findtime` chỉ định một lượng thời gian tính bằng giây và `maxretry` cho biết số lần thử được chấp nhận trong thời gian đó. Nếu client cố gắng thực hiện nhiều hơn `maxretry` trong khoảng thời gian được thiết lập bởi `findtime`, họ sẽ bị chặn:
```command /etc/fail2ban/jail.local
[DEFAULT]

. . .
findtime = 10m
maxretry = 5
```
Thiết lập thông báo mail ( không bắt buộc)
Bạn có thể tùy chọn bật thông báo qua email để nhận thư bất cứ khi nào có lệnh cấm. Trước tiên, bạn sẽ phải thiết lập MTA trên server của mình để nó có thể gửi email. Để tìm hiểu cách sử dụng Postfix cho tác vụ này tham khảo cách cài đặt và cấu hình Postfix trên ubuntu 22.04.
Sau khi bạn đã thiết lập MTA của mình, bạn phải điều chỉnh một số cài đặt bổ sung trong phần `[DEFAULT]` của file `/etc/fail2ban/jail.local. Bắt đầu bằng cách thiết lập chỉ thị `mta`. Nếu bạn thiết lập Postfix, giống như hướng dẫn ở trên, hãy thay đổi giá trị này thành “mail”:
```command /etc/fail2ban/jail.local
[DEFAULT]

. . .
mta = mail
```
Cung cấp địa chỉ email sẽ nhận thư trong trường `destemail`. `sender` tùy chọn cấu hình địa chỉ mà mail sẽ được gửi, cần phải tương thích với cấu hình Postfix của bạn:
```command /etc/fail2ban/jail.local
[DEFAULT]

. . .
destemail = youraccount@email.com
sendername = root@<fq-hostname>
```
`action` tham số cấu hình hành động mà Fail2ban thực hiện khi nó muốn thực hiện lệnh cấm. Giá trị `action_` được xác định trong file ngay trước tham số này. Hành động mặc định là cập nhật cấu hình tường lửa của bạn để từ chối lưu lượng truy cập từ host vi phạm cho đến khi hết thời gian cấm.
```command /etc/fail2ban/jail.local
[DEFAULT]
. . .
action = $(action_)s
. . .
```
Có các tập lệnh `action_` khác được cung cấp theo mặc định bạn có thể thay thế bằng `$ (action_)` ở trên:
```command /etc/fail2ban/jail.local
…
# ban & send an e-mail with whois report to the destemail.
action_mw = %(action_)s
            %(mta)s-whois[sender="%(sender)s", dest="%(destemail)s", protocol="%(protocol)s", chain="%(chain)s"]

# ban & send an e-mail with whois report and relevant log lines
# to the destemail.
action_mwl = %(action_)s
             %(mta)s-whois-lines[sender="%(sender)s", dest="%(destemail)s", logpath="%(logpath)s", chain="%(chain)s"]
…
```
Cả hai `action_mw` và `action_mwl` sẽ xử lý việc gửi email bằng cấu hình bạn đã cung cấp. Bước tiếp theo, bạn sẽ chuyển sang cấu hình dành riêng cho Nginx
## Bước 2: Cấu hình Fail2Ban để theo dõi nhật ký Nginx
Bây giờ bạn đã có một số cài đặt Fail2ban chung, bạn có thể kích hoạt Nginx-specific theo dõi nhật ký server web của bạn để biết các mẫu cụ thể. 
Mỗi 
Mỗi jail trong file cấu hình được đánh dấu bằng tiêu đề chứa tên jail trong dấu ngoặc vuông, nhưng `[DEFAULT]` phần cho biết cấu hình của một jail cụ thể. Theo mặc định, chỉ có `[ssh]` jail được kích hoạt. 
Để bật theo dõi nhật ký cho các lần đăng nhập Nginx, kích hoạt jail `[nginx-http-auth`. Thêm `enabled = true` chỉ thị trong phần này:
```command /etc/fail2ban/jail.local
…
[nginx-http-auth]

enabled  = true
port     = http,https
logpath = %(nginx_error_log)s
. . .
```
Khi bạn hoàn thành việc sửa đổi, lưu và đóng file. Nếu bạn sử dụng `nano` nhấn `Ctrl+X` sau khi được nhắc nhấn `y` và ENTER. Tiếp theo, bạn sẽ xem xét cấu hình bộ lọc cho `nginx-http-auth`.
### Bước 3: Xem lại bộ lọc cho Nginx Jails
Bạn có thể nhận thấy rằng khối `[nginx-http-auth]` trong `jail.local` không chứa bất kỳ quy tắc nào dành riêng cho Nginx. Các quy tắc này không tự động được mã hóa cứng bên trong Fail2ban, trên thực tế tiêu đề `[nginx-http-auth]` tương ứng trực tiếp với tên file bên trong Fail2ban’s, `filter.d`bộ lọc đóng gói sẵn của Fail2ban’s filter. Nếu bạn liệt kê nội dung của thư mục này, bạn có thể thấy các bộ lọc đóng gói có sẵn, nếu bạn cần sử dụng chúng:
```content super_user
ls /etc/fail2ban/filter.d
```
```output
3proxy.conf                freeswitch.conf         proftpd.conf
apache-auth.conf           froxlor-auth.conf       pure-ftpd.conf
apache-badbots.conf        gitlab.conf             qmail.conf
apache-botsearch.conf      grafana.conf            recidive.conf
apache-common.conf         groupoffice.conf        roundcube-auth.conf
apache-fakegooglebot.conf  gssftpd.conf            scanlogd.conf
apache-modsecurity.conf    guacamole.conf          screensharingd.conf
apache-nohome.conf         haproxy-http-auth.conf  selinux-common.conf
apache-noscript.conf       horde.conf              selinux-ssh.conf
apache-overflows.conf      ignorecommands          sendmail-auth.conf
apache-pass.conf           kerio.conf              sendmail-reject.conf
apache-shellshock.conf     lighttpd-auth.conf      sieve.conf
assp.conf                  mongodb-auth.conf       slapd.conf
asterisk.conf              monit.conf              softethervpn.conf
bitwarden.conf             murmur.conf             sogo-auth.conf
…
```
Bây giờ, hãy xem `nginx-http-auth.conf`:
```content super_user
cat /etc/fail2ban/filter.d/nginx-http-auth.conf
```
```output
# fail2ban filter configuration for nginx


[Definition]


failregex = ^ \[error\] \d+#\d+: \*\d+ user "(?:[^"]+|.*?)":? (?:password mismatch|was not found in "[^\"]*"), client: <HOST>, server: \S*, request: "\S+ \S+ HTTP/\d+\.\d+", host: "\S+"(?:, referrer: "\S+")?\s*$

ignoreregex =

datepattern = {^LN-BEG}
…
```
Những file này chứa những biểu thức chính quy (regular expressions) xác định xem một dòng trong nhật ký có phải là một lần xác thực không thành công hay không. Chúng có thể được sửa đổi trực tiếp khi cần thiết.
Trong bước tiếp theo, bạn sẽ kích hoạt và kiểm tra Fail2ban.
### Bước 4: Kích hoạt Nginx Jails của bạn
Tại thời điểm này, bạn có thể kích hoạt dịch vụ Fail2ban của mình để nó sẽ tự động chạy từ bây giờ. Đầu tiên, chạy `systemctl enable`:
```content super_user
sudo systemctl enable fail2ban
```
Sau đó, khởi động bằng tay vào lần đầu tiên với `systemctl start`: 
```content super_user
sudo systemctl start fail2ban
```
Bạn có thể xác minh rằng nó đang chạy với `systemctl status` 
```content super_user
sudo systemctl status fail2ban
```
```output
● fail2ban.service - Fail2Ban Service
     Loaded: loaded (/lib/systemd/system/fail2ban.service; enabled; vendor preset: enabled
     Active: active (running) since Fri 2022-07-08 17:19:38 UTC; 7s ago
       Docs: man:fail2ban(1)
   Main PID: 5962 (fail2ban-server)
      Tasks: 7 (limit: 2327)
     Memory: 12.6M
        CPU: 195ms
     CGroup: /system.slice/fail2ban.service
             └─5962 /usr/bin/python3 /usr/bin/fail2ban-server -xf start
```
```note
**Note:** Để thực hiện bất kỳ thay đổi cấu hình nào trong tương lai, bạn cần khởi động lại dịch vụ fail2ban. Bạn có thể làm bằng cách sử dụng `sudo systemctl restart fail2ban` 
```
Nhận thông tin về Jails đã bật
Bạn có thể xem tất cả các jails đã kích hoạt của mình bằng cách sử dụng lệnh `fail2ban-client`
```content super_user
sudo fail2ban-client status
```
Bạn sẽ thấy danh sách jails:
```output
Status
|- Number of jail:      2
`- Jail list:           nginx-http-auth, sshd
```
Nếu bạn muốn xem chi tiết về các lệnh cấm được thi hành bởi bất kỳ jail nào, Sử dụng lại lệnh `fail2ban-client`":
```content super_user
sudo fail2ban-client status nginx-http-auth
```
```output
Status for the jail: nginx-http-auth
|- filter
|  |- File list:        /var/log/nginx/error.log 
|  |- Currently failed: 0
|  `- Total failed:     0
`- action
   |- Currently banned: 0
   |  `- IP list:
   `- Total banned:     0
```
Trong bước hướng dẫn tiếp theo, bạn sẽ phải kiểm tra việc bị cấm để xác minh rằng cấu hình Fail2ban của bạn đang hoạt động. 
### Bước 5: Thử nghiệm Fail2Ban Policies
Điều quan trọng là phải kiểm tra các chính sách Fail2ban của bạn để đảm bảo chúng chặn lưu lượng truy cập như mong đợi. Để thực hiện việc này, hãy điều hướng đến server của bạn trong trình duyệt web cục bộ. Ở lời nhắc xác thực Nginx, liên tục nhập thông tin đăng nhập không chính xác. Sau vài lần thử, server sẽ hoàn toàn ngừng phản hồi cho bạn, như thể kết nối của bạn bị ngắt:
![description image](https://media.cloudfly.vn/posts/Cách_Bảo_Vệ_Server_Nginx_Với_Fail2Ban_Trên_Ubuntu_20.04.png)
Nếu bạn nhìn vào trạng thái của cấu hình `nginx-http-auth` với `fail2ban-client`. Bạn sẽ thấy địa chỉ IP của mình bị cấm trên trang web:
```content super_user
sudo fail2ban-client status nginx-http-auth
```
```output
Status for the jail: nginx-http-auth
|- Filter
|  |- Currently failed: 0
|  |- Total failed:     5
|  `- File list:        /var/log/nginx/error.log
`- Actions
   |- Currently banned: 1
   |- Total banned:     1
   `- Banned IP list:   108.172.85.62
```
Bạn cũng có thể xem quy tắc mới bằng cách kiểm tra đầu ra `iptables`. `iptables` là lệnh tương tác với các quy tắc tường lửa và port cấp thấp trên server của bạn. Nếu bạn đã làm theo hướng dẫn của chúng tôi để thiết lập server ban đầu, bạn sẽ sử dụng `ufw` để quản lý các quy tắc tường lửa ở cấp cao hơn. chạy `iptables -S` sẽ hiển thị cho bạn tất cả các quy tắc tường lửa mà `ufw` đã tạo:
```content super_user
sudo iptables -S
```
```output
-P INPUT DROP
-P FORWARD DROP
-P OUTPUT ACCEPT
-N f2b-nginx-http-auth
-N ufw-after-forward
-N ufw-after-input
-N ufw-after-logging-forward
-N ufw-after-logging-input
-N ufw-after-logging-output
-N ufw-after-output
-N ufw-before-forward
-N ufw-before-input
-N ufw-before-logging-forward
-N ufw-before-logging-input
-N ufw-before-logging-output
…
```
Nếu bạn chuyển đầu ra của `iptables -S` thành `grep` để tìm kiếm trong các quy tắc đó cho chuỗi `f2b`. Bạn có thể thấy các quy tắc đã được thêm vào bởi fail2ban:
```content super_user
sudo iptables -S | grep f2b
```
```output
-N f2b-nginx-http-auth
-A INPUT -p tcp -m multiport --dports 80,443 -j f2b-nginx-http-auth
-A f2b-nginx-http-auth -s 108.172.85.62/32 -j REJECT --reject-with icmp-port-unreachable
-A f2b-nginx-http-auth -j RETURN
```
Dòng chứa `REJECT --reject-with icmp-port-` không thể truy cập đã được Fail2ban thêm vào và sẽ phản ánh địa chỉ IP của máy cục bộ của bạn. Khi bạn hài lòng với các rules đang hoạt động, bạn có thể bỏ cấm địa chỉ IP của mình với `fail2ban-client` bằng cách nhập:
```content super_user
sudo fail2ban-client set nginx-http-auth unbanip 108.172.85.62
```
Bây giờ bạn có thể thử xác thực lại một lần nữa.
## Kết luận 
Fail2ban cung cấp rất nhiều tính năng linh hoạt để xây dựng các chính sách phù hợp với nhu cầu bảo mật cụ thể của bạn. Bằng cách xem xét các biến và mẫu trong file `/etc/fail2ban/jail.local` và các tệp mà nó phụ thuộc vào trong `/etc/fail2ban/filter.d` và thư mục `/etc/fail2ban/action.d`. Bạn có thể tìm thấy nhiều phần để điều chỉnh và thay đổi khi nhu cầu của bạn cao hơn. Bảo vệ server của bạn bằng `fail2ban` có thể cung cấp cho bạn một hướng cơ sở bảo mật hữu ích.

Cách Bảo Vệ Server Nginx Với Fail2Ban Trên Ubuntu 20.04

Cách cài đặt và sử dụng Docker Compose trên Ubuntu 20.04

Cách cài đặt Gitea trên Ubuntu bằng Docker

Cách cấu hình thay đổi Web Root trong máy chủ Web Apache trên Ubuntu 20.04

Cách cài đặt xác thực mật khẩu với Apache trên Ubuntu 20.04

Cách sử dụng Apache làm Reverse-Proxy với mod_proxy trên Ubuntu 20.04

Cách bảo vệ SSH bằng Fail2Ban trên Ubuntu 20.04

Cách Cài Đặt MySQL Trên Ubuntu 20.04

Cách chuyển toàn bộ dữ liệu của PostgreSQL đến máy chủ mới trên Ubuntu 20.04

Cấu Hình BIND Như Một Cho Máy Chủ DNS Nội Bộ Trên Ubuntu 20.04

Cách Bảo Vệ Server Nginx Với Fail2Ban Trên Ubuntu 20.04

Bạn cần hỗ trợ thêm

Hotline (24/7)

Gửi Ticket

Live Chat

Cloud Server

Load Balancer

Dedicated Server

Colocation Server

Bài viết kỹ thuật

Cách cài đặt và sử dụng Docker Compose trên Ubuntu 20.04

Cách cài đặt Gitea trên Ubuntu bằng Docker

Cách cấu hình thay đổi Web Root trong máy chủ Web Apache trên Ubuntu 20.04

Cách cài đặt xác thực mật khẩu với Apache trên Ubuntu 20.04

Cách sử dụng Apache làm Reverse-Proxy với mod_proxy trên Ubuntu 20.04

Cách bảo vệ SSH bằng Fail2Ban trên Ubuntu 20.04

Cách Cài Đặt MySQL Trên Ubuntu 20.04

Cách chuyển toàn bộ dữ liệu của PostgreSQL đến máy chủ mới trên Ubuntu 20.04

Cấu Hình BIND Như Một Cho Máy Chủ DNS Nội Bộ Trên Ubuntu 20.04

Cách Bảo Vệ Server Nginx Với Fail2Ban Trên Ubuntu 20.04

Bạn cần hỗ trợ thêm

Hotline (24/7)

Gửi Ticket

Live Chat

Cloud Server

Load Balancer

Dedicated Server

Colocation Server