_Tác giả đã chọn Mozilla Foundation để nhận khoản đóng góp như một phần của Viết cho DOnations chương trình._

Giới thiệu

Thử nghiệm đơn vị trong Ansible là chìa khóa để đảm bảo vai trò hoạt động như dự định. Phân tử làm cho quá trình này dễ dàng hơn bằng cách cho phép bạn chỉ định các kịch bản kiểm tra vai trò đối với các môi trường khác nhau. Sử dụng Ansible dưới mui xe, Molecule giảm tải vai trò cho một bộ cấp phép triển khai vai trò trong môi trường được định cấu hình và gọi trình xác minh (chẳng hạn như Testinfra) để kiểm tra độ trễ cấu hình. Điều này đảm bảo rằng vai trò của bạn đã thực hiện tất cả các thay đổi dự kiến ​​đối với môi trường trong kịch bản cụ thể đó.

Trong hướng dẫn này, bạn sẽ xây dựng một vai trò Ansible triển khai Apache đến một máy chủ và cấu hình Tường lửa. Để kiểm tra vai trò này hoạt động như dự định, bạn sẽ tạo một thử nghiệm trong Phân tử bằng cách sử dụng Docker như một trình điều khiển và Testinfra, một thư viện Python để kiểm tra trạng thái của các máy chủ. Phân tử sẽ cung cấp các thùng chứa Docker để kiểm tra vai trò và Testinfra sẽ xác minh rằng máy chủ đã được cấu hình như dự định. Khi bạn hoàn thành, bạn sẽ có thể tạo nhiều trường hợp thử nghiệm để xây dựng trên các môi trường và chạy các thử nghiệm này bằng cách sử dụng Phân tử.

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

Trước khi bạn bắt đầu hướng dẫn này, bạn sẽ cần những điều sau đây:

  • Một máy chủ Ubuntu 16.04. Làm theo các bước trong Thiết lập máy chủ ban đầu với Ubuntu 16.04 hướng dẫn tạo người dùng sudo không phải root và đảm bảo bạn có thể kết nối với máy chủ mà không cần mật khẩu. Chú thích: Phân tử có thể sử dụng Python 2.7 hoặc Python 3.6. Vì Ubuntu 16.04 bao gồm Python 3.5 và 2.7 theo mặc định, chúng tôi sẽ cài đặt và sử dụng Python 2.7 trong hướng dẫn này để sử dụng các kho lưu trữ dựng sẵn.
  • Docker được cài đặt trên máy chủ của bạn. Làm theo các bước được nêu trong Làm thế nào để cài đặt và sử dụng Docker trên Ubuntu 16.04và chắc chắn thêm người dùng không phải root của bạn vào docker nhóm.
  • Quen thuộc với Playbook Ansible. Để xem xét, hãy xem Quản lý cấu hình 101: Viết Ansible Playbooks.

Bước 1 - Chuẩn bị môi trường

Hãy bắt đầu bằng cách tạo một môi trường ảo trên máy chủ của chúng tôi và cài đặt các gói cần thiết cho thử nghiệm của chúng tôi trong môi trường đó.

Bắt đầu bằng cách đăng nhập với tư cách người dùng không phải root của bạn và đảm bảo các kho lưu trữ của bạn được cập nhật:

sudo apt-get update -y

Điều này sẽ đảm bảo rằng kho lưu trữ gói của bạn bao gồm phiên bản mới nhất của python-pip gói sẽ cài đặt pip và Python 2.7. Chúng tôi sẽ sử dụng pip để tạo môi trường ảo và cài đặt các gói bổ sung. Để cài đặt pip, chạy:

sudo apt-get install -y python-pip

Sử dụng pip để cài đặt virtualenv Mô-đun Python và mọi cập nhật:

pip install pip virtualenv -U

Các -U cờ nói pip để cập nhật bất kỳ gói nào đã được cài đặt trước đó.

Tiếp theo, hãy tạo và kích hoạt môi trường ảo:

virtualenv my_env

Kích hoạt nó để đảm bảo rằng hành động của bạn bị giới hạn trong môi trường đó:

. my_env/bin/activate

cài đặt, dựng lên molecule, ansibledocker-py sử dụng pip:

pip install molecule ansible docker-py

Dưới đây là những gì mỗi gói sẽ làm:

  • molecule: Đây là gói Molecule chính, được sử dụng để kiểm tra vai trò.
  • ansible: Gói này cho phép sử dụng Playbook Ansible, thực thi vai trò và các bài kiểm tra liên quan của nó.
  • docker-py: Thư viện Python này được sử dụng bởi Molecule để giao tiếp với Docker. Chúng tôi cần điều này vì chúng tôi đang sử dụng Docker làm tài xế.

Tiếp theo, hãy tạo một vai trò trong Phân tử.

Bước 2 - Tạo một Role trong Molecule

Khi môi trường của chúng ta được thiết lập, hãy sử dụng Molecule để tạo ra một vai trò cơ bản mà chúng ta sẽ sử dụng để kiểm tra cài đặt Apache. Quá trình này sẽ tạo cấu trúc thư mục và một số kiểm tra ban đầu, và chỉ định Docker làm trình điều khiển để Molecule sử dụng Docker để chạy thử nghiệm của nó.

Tạo một vai trò mới có tên httpd:

molecule init role -r httpd -d docker

Các -r cờ chỉ định tên của vai trò, trong khi -d xác định trình điều khiển, trong đó quy định các máy chủ cho Molecule để sử dụng trong thử nghiệm.

Thay đổi vào thư mục của vai trò mới được tạo:

cd httpd

Kiểm tra vai trò mặc định để kiểm tra xem Molecule đã được thiết lập đúng chưa:

molecule test

Bạn sẽ thấy đầu ra sẽ liệt kê từng hành động thử nghiệm mặc định:

Output--> Validating schema /home/sammy/httpd/molecule/default/molecule.yml.
Validation completed successfully.
--> Test matrix

└── default
    ├── lint
    ├── destroy
    ├── dependency
    ├── syntax
    ├── create
    ├── prepare
    ├── converge
    ├── idempotence
    ├── side_effect
    ├── verify
    └── destroy
...

Trước khi bắt đầu kiểm tra, Molecule xác thực tệp cấu hình molecule.yml để đảm bảo mọi thứ đều theo thứ tự. Nó cũng in ma trận thử nghiệm này, xác định thứ tự các hành động thử nghiệm.

Chúng tôi sẽ thảo luận chi tiết từng hành động thử nghiệm khi chúng tôi đã tạo vai trò của mình và tùy chỉnh các thử nghiệm của mình. Bây giờ, chú ý đến PLAY_RECAP cho mỗi bài kiểm tra và đảm bảo rằng không có hành động mặc định nào trả về failed trạng thái. Ví dụ: PLAY_RECAP cho mặc định 'create' hành động sẽ giống như sau:

Output...
PLAY RECAP *********************************************************************
    localhost                  : ok=5    changed=4    unreachable=0    failed=0

Hãy tiếp tục sửa đổi vai trò của chúng ta để cấu hình Apache và Firewalld.

Bước 3 - Cấu hình Apache

Để cấu hình Apache, chúng ta sẽ tạo một tệp tác vụ cho vai trò, chỉ định các gói để cài đặt và các dịch vụ để kích hoạt. Những chi tiết này sẽ được trích xuất từ ​​một tệp biến và mẫu mà chúng tôi sẽ sử dụng để thay thế trang chỉ mục mặc định của Apache.

Tạo tệp tác vụ cho vai trò sử dụng nano hoặc trình soạn thảo văn bản yêu thích của bạn:

nano tasks/main.yml

Bạn sẽ thấy rằng tệp đã tồn tại. Xóa những gì ở đó và dán đoạn mã sau để cài đặt các gói cần thiết và kích hoạt các dịch vụ chính xác, mặc định HTML và các thiết lập tường lửa:

~/httpd/tasks/main.yml

---
- name: "Ensure required packages are present"
  yum:
    name: "{{ pkg_list }}"
    state: present

- name: "Ensure latest index.html is present"
  template:
    src: index.html.j2
    dest: /var/www/html/index.html

- name: "Ensure httpd service is started and enabled"
  service:
    name: "{{ item }}"
    state: started
    enabled: True
  with_items: "{{ svc_list }}"

- name: "Whitelist http in firewalld"
  firewalld:
    service: http
    state: enabled
    permanent: True
    immediate: True

Playbook này bao gồm 4 nhiệm vụ:

  • Ensure required packages are present: Tác vụ này sẽ cài đặt các gói được liệt kê trong tệp biến dưới pkg_list. Tệp biến sẽ được đặt tại ~/httpd/vars/main.yml và bạn sẽ tạo nó ở cuối phần này.
  • Ensure latest index.html is present: Tác vụ này sẽ sao chép trang mẫu index.html.j2 và dán nó vào tệp chỉ mục mặc định /var/www/html/index.html được tạo bởi Apache. Bạn cũng sẽ tạo mẫu này trong bước này.
  • Ensure httpd service is started and enabled: Tác vụ này sẽ bắt đầu và bật các dịch vụ được liệt kê trong svc_list trong tệp biến.
  • Whitelist http in firewalld: Tác vụ này sẽ đưa vào danh sách trắng http dịch vụ trong firewalld. Firewalld là một giải pháp tường lửa hoàn chỉnh có mặt mặc định trên các máy chủ CentOS. Cho http dịch vụ để làm việc, chúng ta cần để lộ các cổng cần thiết. Hướng dẫn firewalld để đưa vào danh sách trắng một dịch vụ đảm bảo rằng nó đưa vào danh sách trắng tất cả các cổng mà dịch vụ yêu cầu.

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

Tiếp theo, hãy tạo một templates thư mục cho index.html.j2 trang mẫu:

mkdir templates

Tự tạo trang:

nano templates/index.html.j2

Dán vào mã sau đây:

~/httpd/templates/index.html.j2

<div style="text-align: center">
    <h2>Managed by Ansible</h2>
</div>

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

Bước cuối cùng trong việc hoàn thành vai trò là viết tệp biến, cung cấp tên của các gói và dịch vụ cho playbook vai trò chính của chúng tôi:

nano vars/main.yml

Dán nội dung mặc định bằng mã sau, trong đó chỉ định pkg_listsvc_list:

vars/main.yml

---
pkg_list:
  - httpd
  - firewalld
svc_list:
  - httpd
  - firewalld

Các danh sách này chứa thông tin sau:

  • pkg_list: Nó chứa tên của các gói mà role sẽ cài đặt: httpdfirewalld.
  • svc_list: Điều này bao gồm tên của các dịch vụ mà vai trò sẽ bắt đầu và bật: httpdfirewalld.

Chú thích: Đảm bảo rằng tệp biến của bạn không có bất kỳ dòng trống nào hoặc thử nghiệm của bạn sẽ không thành công trong quá trình đúc.

Bây giờ chúng ta đã hoàn thành việc tạo vai trò của mình, hãy cấu hình Molecule để kiểm tra xem nó có hoạt động như dự định hay không.

Bước 4 - Sửa đổi vai trò cho chạy thử nghiệm

Cấu hình phân tử bao gồm hai bước: sửa đổi tập tin cấu hình phân tử và tạo ra một tùy chỉnh yamllint tập tin. Yamllint là một đoạn mã YAML để kiểm tra tính hợp lệ của cú pháp, lặp lại khóa và các vấn đề về mỹ phẩm như độ dài dòng, dấu cách, và thụt đầu dòng.

Các sửa đổi của chúng tôi sẽ bao gồm:

  • Thêm tùy chọn vào ~/httpd/molecule/default/molecule.yml sử dụng tùy chỉnh yamllint tệp cấu hình và tự tạo tệp. Tệp này sẽ cho phép hai ngoại lệ: dòng lớn hơn 80 ký tự và giá trị trung thực. Bởi vì Ansible và Yamllint sử dụng cú pháp xung đột để biểu thị các giá trị trung thực, điều này sẽ ngăn chặn các lỗi cú pháp không cần thiết.

  • Thêm thông số nền tảng. Vì chúng tôi đang thử nghiệm vai trò cấu hình và bắt đầu httpd systemd dịch vụ, chúng ta cần phải sử dụng một hình ảnh với systemd cấu hình và chế độ đặc quyền được kích hoạt. Đối với hướng dẫn này, chúng tôi sẽ sử dụng milcom/centos7-systemd hình ảnh có sẵn trên Docker Hub. Chế độ Privileged cho phép các container chạy với hầu như tất cả các khả năng của máy chủ của chúng.

Hãy chỉnh sửa molecule.yml để phản ánh những thay đổi này:

nano molecule/default/molecule.yml

Thêm đánh dấu yamllint tùy chọn và thông tin nền tảng:

~/httpd/molecule/default/molecule.yml

---
dependency:
  name: galaxy
driver:
  name: docker
lint:
  name: yamllint
  options:
    config-file: molecule/default/yamllint.yml
platforms:
  - name: centos7
    image: milcom/centos7-systemd
    privileged: True
provisioner:
  name: ansible
  lint:
    name: ansible-lint
scenario:
  name: default
verifier:
  name: testinfra
  lint:
    name: flake8

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

Lưu ý tham chiếu trong molecule.yml đến yamllint tập tại molecule/default/yamllint.yml. Hãy tạo tệp này:

nano molecule/default/yamllint.yml

Nhập cấu hình tùy chỉnh cho môi trường thử nghiệm của bạn bằng cách dán các quy tắc sau, xác định thông số kỹ thuật độ dài dòng và cài đặt giá trị trung thực:

~/httpd/molecule/default/yamllint.yml

---
extends: default
rules:
  line-length:
    max: 120
    level: warning
  truthy: disable

Chúng tôi đã thêm hai quy tắc:

  • line_length: Quy tắc này chỉ định rằng độ dài tối đa cho phép của dòng là 120 ký tự (tối đa 80 ký tự) và rằng đường viền sẽ đưa ra cảnh báo nếu quy tắc bị vi phạm.

  • truthy: Quy tắc này vô hiệu hóa các giá trị trung thực vì Ansible và Yamllint sử dụng cú pháp xung đột để thể hiện chúng. Điều này sẽ ngăn ngừa các lỗi cú pháp không cần thiết.

Bây giờ chúng ta đã cấu hình thành công môi trường thử nghiệm, hãy chuyển sang viết các trường hợp thử nghiệm mà Molecule sẽ chạy với vùng chứa của chúng ta sau khi thực hiện vai trò.

Bước 5 - Viết các trường hợp kiểm thử

Trong thử nghiệm cho vai trò này, chúng tôi sẽ kiểm tra các điều kiện sau:

  • Rằng httpdfirewalld gói được cài đặt.
  • Rằng httpdfirewalld dịch vụ đang chạy và được kích hoạt.
  • Rằng http dịch vụ được bật trong cài đặt tường lửa của chúng tôi.
  • Cái đó index.html chứa cùng một dữ liệu được chỉ định trong tệp mẫu của chúng tôi.

Nếu tất cả các bài kiểm tra này vượt qua, thì vai trò hoạt động như dự định.

Để viết các trường hợp thử nghiệm cho các điều kiện này, hãy chỉnh sửa các thử nghiệm mặc định trong ~/httpd/molecule/default/tests/test_default.py. Sử dụng Testinfra, chúng ta sẽ viết các test test như các hàm Python sử dụng các lớp Molecule.

Mở test_default.py:

nano molecule/default/tests/test_default.py

Xóa nội dung của tệp để bạn có thể viết các bài kiểm tra từ đầu.

Chú thích: Khi bạn viết các bài kiểm tra của mình, hãy chắc chắn rằng chúng được phân tách bằng hai dòng mới hoặc chúng sẽ thất bại.

Bắt đầu bằng cách nhập các mô-đun Python cần thiết:

~/httpd/molecule/default/tests/test_default.py

import os
import pytest

import testinfra.utils.ansible_runner

Các mô-đun này bao gồm:

  • os: Mô-đun Python tích hợp này cho phép chức năng phụ thuộc vào hệ điều hành, giúp cho Python có thể giao tiếp với hệ điều hành cơ bản.
  • pytest: Các pytest mô-đun cho phép viết thử.
  • testinfra.utils.ansible_runner: Mô-đun Testinfra này sử dụng Ansible như là phụ trợ để thực hiện lệnh.

Trong phần nhập khẩu mô-đun, dán vào đoạn mã sau, sử dụng phần phụ trợ Ansible để trả về cá thể máy chủ hiện tại:

~/httpd/molecule/default/tests/test_default.py

...
testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')

Với tệp thử nghiệm của chúng tôi được cấu hình để sử dụng chương trình phụ trợ Ansible, hãy viết các bài kiểm tra đơn vị để kiểm tra trạng thái của máy chủ của chúng tôi.

Thử nghiệm đầu tiên sẽ đảm bảo rằng httpdfirewalld đã được cài đặt:

~/httpd/molecule/default/tests/test_default.py

... 

@pytest.mark.parametrize('pkg', [
  'httpd',
  'firewalld'
])
def test_pkg(host, pkg):
    package = host.package(pkg)

    assert package.is_installed

Bài kiểm tra bắt đầu bằng pytest.mark.parametrize người trang trí, cho phép chúng tôi tham số hóa các đối số cho thử nghiệm. Thử nghiệm đầu tiên này sẽ mất test_pkg như một tham số để kiểm tra sự hiện diện của httpdfirewalld gói.

Bài kiểm tra tiếp theo kiểm tra xem có hay không httpdfirewalld đang chạy và được kích hoạt. Phải mất test_svc như một tham số:

~/httpd/molecule/default/tests/test_default.py

... 

@pytest.mark.parametrize('svc', [
  'httpd',
  'firewalld'
])
def test_svc(host, svc):
    service = host.service(svc)

    assert service.is_running
    assert service.is_enabled

Bài kiểm tra cuối cùng kiểm tra các tệp và nội dung được chuyển đến parametrize() hiện hữu. Nếu tệp không được tạo bởi vai trò của chúng tôi và nội dung không được đặt đúng cách, assert sẽ trở lại False:

~/httpd/molecule/default/tests/test_default.py

... 

@pytest.mark.parametrize('file, content', [
  ("/etc/firewalld/zones/public.xml", "<service name=\"http\"/>"),
  ("/var/www/html/index.html", "Managed by Ansible")
])
def test_files(host, file, content):
    file = host.file(file)

    assert file.exists
    assert file.contains(content)

Trong mỗi bài kiểm tra, assert sẽ trở lại True hoặc là False tùy thuộc vào kết quả thử nghiệm.

Tệp đã hoàn thành trông giống như sau:

~/httpd/molecule/default/tests/test_default.py

import os
import pytest

import testinfra.utils.ansible_runner

testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')

@pytest.mark.parametrize('pkg', [
  'httpd',
  'firewalld'
])
def test_pkg(host, pkg):
    package = host.package(pkg)

    assert package.is_installed

@pytest.mark.parametrize('svc', [
  'httpd',
  'firewalld'
])
def test_svc(host, svc):
    service = host.service(svc)

    assert service.is_running
    assert service.is_enabled

@pytest.mark.parametrize('file, content', [
  ("/etc/firewalld/zones/public.xml", "<service name=\"http\"/>"),
  ("/var/www/html/index.html", "Managed by Ansible")
])
def test_files(host, file, content):
    file = host.file(file)

    assert file.exists
    assert file.contains(content)

Bây giờ chúng tôi đã chỉ định các trường hợp thử nghiệm của mình, hãy kiểm tra vai trò.

Bước 6 - Kiểm tra vai trò với phân tử

Khi chúng tôi bắt đầu thử nghiệm, Molecule sẽ thực hiện các hành động mà chúng tôi đã xác định trong kịch bản của chúng tôi. Chúng tôi sẽ chạy kịch bản phân tử mặc định một lần nữa, thực hiện các hành động trong chuỗi kiểm tra mặc định trong khi xem xét kỹ hơn từng bước.

Chạy thử nghiệm cho kịch bản mặc định một lần nữa:

molecule test

Điều này sẽ bắt đầu chạy thử nghiệm. Đầu ra ban đầu in ma trận thử nghiệm mặc định:

Output--> Validating schema /home/sammy/httpd/molecule/default/molecule.yml.
Validation completed successfully.
--> Test matrix

└── default
    ├── lint
    ├── destroy
    ├── dependency
    ├── syntax
    ├── create
    ├── prepare
    ├── converge
    ├── idempotence
    ├── side_effect
    ├── verify
    └── destroy

Chúng ta hãy xem xét từng hành động thử nghiệm và đầu ra mong đợi, bắt đầu với linting.

Các linting hành động thực thi yamllint, flake8ansible-lint:

  • yamllint: Linter này được thực thi trên tất cả các tệp YAML có trong thư mục vai trò.
  • flake8: Mã linter Python này kiểm tra các thử nghiệm được tạo cho Testinfra.
  • ansible-lint: Linter này cho Playbook Ansible được thực hiện trong tất cả các kịch bản.

    Output...
    --> Scenario: 'default'
    --> Action: 'lint'
    --> Executing Yamllint on files found in /home/sammy/httpd/...
    Lint completed successfully.
    --> Executing Flake8 on files found in /home/sammy/httpd/molecule/default/tests/...
    Lint completed successfully.
    --> Executing Ansible Lint on /home/sammy/httpd/molecule/default/playbook.yml...
    Lint completed successfully.

Hành động tiếp theo, hủy hoại, được thực hiện bằng cách sử dụng destroy.yml tập tin. Điều này được thực hiện để kiểm tra vai trò của chúng tôi trên vùng chứa mới được tạo.

Theo mặc định, phá hủy được gọi là hai lần: lúc bắt đầu chạy thử nghiệm, để xóa bất kỳ vùng chứa nào đã tồn tại và cuối cùng, để xóa vùng chứa mới được tạo:

Output...
--> Scenario: 'default'
--> Action: 'destroy'

    PLAY [Destroy] *****************************************************************

    TASK [Destroy molecule instance(s)] ********************************************
    changed: [localhost] => (item=None)

    TASK [Wait for instance(s) deletion to complete] *******************************
    ok: [localhost] => (item=None)

    TASK [Delete docker network(s)] ************************************************

    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=1    unreachable=0    failed=0

Sau khi hành động phá hủy hoàn tất, kiểm tra sẽ chuyển sang depedency. Hành động này cho phép bạn kéo phụ thuộc từ ansible-galaxy nếu vai trò của bạn yêu cầu họ. Trong trường hợp này, vai trò của chúng tôi không:

Output...
--> Scenario: 'default'
--> Action: 'dependency'
Skipping, missing the requirements file.

Hành động thử nghiệm tiếp theo là cú pháp kiểm tra, được thực hiện trên mặc định playbook.yml playbook. Nó hoạt động theo cách tương tự với --syntax-check gắn cờ trong lệnh ansible-playbook --syntax-check playbook.yml:

Output...
--> Scenario: 'default'
--> Action: 'syntax'

    playbook: /home/sammy/httpd/molecule/default/playbook.yml

Tiếp theo, thử nghiệm sẽ chuyển sang tạo nên hoạt động. Điều này sử dụng create.yml trong thư mục Molecule của vai trò của chúng tôi để tạo vùng chứa Docker với thông số kỹ thuật của chúng tôi:

Output...
--> Scenario: 'default'
--> Action: 'create'

    PLAY [Create] ******************************************************************

    TASK [Log into a Docker registry] **********************************************
    skipping: [localhost] => (item=None)

    TASK [Create Dockerfiles from image names] *************************************
    changed: [localhost] => (item=None)

    TASK [Discover local Docker images] ********************************************
    ok: [localhost] => (item=None)

    TASK [Build an Ansible compatible image] ***************************************
    changed: [localhost] => (item=None)

    TASK [Create docker network(s)] ************************************************

    TASK [Create molecule instance(s)] *********************************************
    changed: [localhost] => (item=None)

    TASK [Wait for instance(s) creation to complete] *******************************
    changed: [localhost] => (item=None)

    PLAY RECAP *********************************************************************
    localhost                  : ok=5    changed=4    unreachable=0    failed=0

Sau khi tạo, kiểm tra sẽ chuyển sang chuẩn bị hoạt động. Hành động này thực thi playbook chuẩn bị, nó sẽ đưa host đến một trạng thái cụ thể trước khi chạy hội tụ. Điều này rất hữu ích nếu vai trò của bạn yêu cầu cấu hình trước của hệ thống trước khi vai trò được thực hiện. Một lần nữa, điều này không áp dụng cho vai trò của chúng tôi:

Output...
--> Scenario: 'default'
--> Action: 'prepare'
Skipping, prepare playbook not configured.

Sau khi chuẩn bị, hội tụ hành động thực hiện vai trò của bạn trên vùng chứa bằng cách chạy playbook.yml playbook. Nếu nhiều nền tảng được định cấu hình trong molecule.yml file, Molecule sẽ hội tụ trên tất cả những thứ này:

Output...
--> Scenario: 'default'
--> Action: 'converge'

    PLAY [Converge] ****************************************************************

    TASK [Gathering Facts] *********************************************************
    ok: [centos7]

    TASK [httpd : Ensure required packages are present] ****************************
    changed: [centos7] => (item=[u'httpd', u'firewalld'])

    TASK [httpd : Ensure latest index.html is present] *****************************
    changed: [centos7]

    TASK [httpd : Ensure httpd service is started and enabled] *********************
    changed: [centos7] => (item=httpd)
    changed: [centos7] => (item=firewalld)

    TASK [httpd : Whitelist http in firewalld] *************************************
    changed: [centos7]

    PLAY RECAP *********************************************************************
    centos7                   : ok=5    changed=4    unreachable=0    failed=0

Sau khi coverge, bài kiểm tra chuyển sang NULL. Hành động này kiểm tra playbook cho idempotence để đảm bảo không có thay đổi bất ngờ được thực hiện trong nhiều lần chạy:

Output...
--> Scenario: 'default'
--> Action: 'idempotence'
Idempotence completed successfully.

Hành động thử nghiệm tiếp theo là tác dụng phụ hoạt động. Điều này cho phép bạn tạo ra các tình huống mà bạn có thể thử nghiệm nhiều thứ hơn, như HA failover. Theo mặc định, Molecule không định cấu hình playbook có hiệu ứng phụ và nhiệm vụ bị bỏ qua:

Output...
--> Scenario: 'default'
--> Action: 'side_effect'
Skipping, side effect playbook not configured.

Phân tử sau đó sẽ chạy người xác minh hành động bằng cách sử dụng trình xác minh mặc định, Testinfra. Hành động này thực hiện các bài kiểm tra bạn đã viết trước đó trong test_default.py. Nếu tất cả các bài kiểm tra vượt qua thành công, bạn sẽ thấy một thông báo thành công và Molecule sẽ tiến hành bước tiếp theo:

Output...
--> Scenario: 'default'
--> Action: 'verify'
--> Executing Testinfra tests found in /home/sammy/httpd/molecule/default/tests/...
    ============================= test session starts ==============================
    platform linux2 -- Python 2.7.12, pytest-3.5.1, py-1.5.3, pluggy-0.6.0
    rootdir: /home/sammy/httpd/molecule/default, inifile:
    plugins: testinfra-1.12.0
collected 6 items

    tests/test_default.py ......                                             [100%]

    ========================== 6 passed in 37.88 seconds ===========================
Verifier completed successfully.

Cuối cùng, Molecule phá hủy các trường hợp đã hoàn thành trong khi kiểm tra và xóa mạng được gán cho các cá thể đó:

Output...
--> Scenario: 'default'
--> Action: 'destroy'

    PLAY [Destroy] *****************************************************************

    TASK [Destroy molecule instance(s)] ********************************************
    changed: [localhost] => (item=None)

    TASK [Wait for instance(s) deletion to complete] *******************************
    changed: [localhost] => (item=None)

    TASK [Delete docker network(s)] ************************************************

    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=2    unreachable=0    failed=0

Các hành động kiểm tra hiện đã hoàn tất, xác minh rằng vai trò của chúng tôi đã hoạt động như dự định.

Phần kết luận

Trong bài viết này, bạn đã tạo ra một vai trò Ansible để cài đặt và cấu hình Apache và Firewalld. Sau đó bạn đã viết các bài kiểm tra đơn vị với Testinfra mà Molecule sử dụng để khẳng định rằng vai trò đã chạy thành công.

Bạn có thể sử dụng cùng một phương thức cơ bản cho các vai trò rất phức tạp và tự động kiểm tra bằng cách sử dụng một đường ống CI. Phân tử là một công cụ có thể cấu hình cao có thể được sử dụng để kiểm tra vai trò với bất kỳ nhà cung cấp nào mà Ansible hỗ trợ, không chỉ Docker. Cũng có thể tự động kiểm tra dựa trên cơ sở hạ tầng của riêng bạn, đảm bảo rằng vai trò của bạn luôn được cập nhật và hoạt động. Chính thức Tài liệu phân tử là nguồn tài nguyên tốt nhất để học cách sử dụng Phân tử.