Ansible Rollerini Molecule ile Ubuntu 16.04 Üzerinde Test Etme

Ansible Rollerini Molecule ile Ubuntu 16.04 Üzerinde Test Etme

Ansible, altyapı otomasyonu için güçlü ve popüler bir araçtır. Rolleri, görevleri ve şablonları kullanarak sunucuları yapılandırmak, uygulamaları dağıtmak ve sistemleri yönetmek için kullanılır. Ancak, bir Ansible rolü yazmak sadece başlangıçtır. Bir rolün beklendiği gibi çalıştığından, farklı senaryolarda doğru davrandığından ve en önemlisi, sistemde istenmeyen yan etkiler yaratmadığından emin olmak için kapsamlı bir şekilde test edilmesi hayati önem taşır. İşte bu noktada Molecule devreye girer. Bu makalede, Ansible rollerinizi Molecule kullanarak Ubuntu 16.04 üzerinde nasıl test edeceğinizi detaylı bir şekilde inceleyeceğiz.

Giriş: Neden Ansible Rollerini Test Etmeliyiz?

Ansible rolleri, karmaşık altyapı otomasyonunun temel yapı taşlarıdır. Bir rol, bir uygulamanın kurulumu, bir servisin yapılandırılması veya bir kullanıcının oluşturulması gibi belirli bir işlevi yerine getiren bir dizi görev, şablon ve değişken içerir. Bu rollerin güvenilirliği, tüm altyapınızın istikrarı için kritik öneme sahiptir. Test etmemek, potansiyel olarak üretim ortamlarında büyük sorunlara yol açabilecek hatalı yapılandırmalara, güvenlik açıklarına veya performans düşüşlerine neden olabilir.

Test etmenin başlıca faydaları şunlardır:

* Güvenilirlik: Rollerin beklendiği gibi çalıştığından emin olmak.
* Idempotence (Tekrar Çalıştırma Yeteneği): Bir rolün birden fazla kez çalıştırıldığında sistemin durumunu değiştirmemesi, sadece ilk çalıştırmada gerekli değişiklikleri yapması. Bu, otomasyonun temel prensiplerinden biridir.
* Hata Yakalama: Potansiyel hataları erken aşamada tespit etmek ve düzeltmek.
* Sürdürülebilirlik: Rollerin zaman içinde, bağımlılıklar veya sistem değişiklikleri nedeniyle bozulmamasını sağlamak.
* Dokümantasyon: Testler, rolün ne yapması gerektiğine dair canlı bir dokümantasyon görevi görür.
* Sürekli Entegrasyon (CI): Otomatik testler, CI/CD işlem hatlarının ayrılmaz bir parçasıdır ve kod değişikliklerinin anında doğrulanmasını sağlar.

Neden Molecule?

Molecule, Ansible rollerini test etmek için özel olarak tasarlanmış bir otomasyon çerçevesidir. Geliştiricilere, rolleri izole edilmiş ortamlarda (Docker konteynerleri, Vagrant VM’leri, bulut örnekleri vb.) çalıştırma, doğrulama ve yok etme yeteneği sunar. Molecule’ü diğer genel test yaklaşımlarından ayıran temel özellikler şunlardır:

* Çoklu Driver Desteği: Docker, Vagrant, OpenStack, EC2, Azure, GCE gibi farklı sanallaştırma ve bulut platformlarını destekler. Bu sayede rolleri farklı ortamlarda test edebilirsiniz. Bu makalede Ubuntu 16.04 imajı ile Docker driver’ını kullanacağız.
* Entegre Test Akışı: Bir rolün oluşturulmasından test edilmesine ve yok edilmesine kadar tüm yaşam döngüsünü yönetir. create, converge, verify, destroy gibi komutlarla belirli adımları kontrol edebilirsiniz.
* Çoklu Doğrulayıcı Desteği: Testinfra, InSpec, Goss gibi farklı test çerçevelerini kullanarak rolün çıktısını doğrulamanıza olanak tanır. Testinfra, Python tabanlı olduğu için Ansible kullanıcıları arasında oldukça popülerdir.
* Senaryo Yönetimi: Farklı test senaryoları oluşturarak bir rolün çeşitli durumlarını (örneğin, ilk kurulum, güncelleme, hata durumu) test etmenizi sağlar.
* Idempotence Kontrolü: molecule check komutu ile rolün tekrar çalıştırıldığında sistemde herhangi bir değişiklik yapmadığını otomatik olarak doğrular. Bu, Ansible otomasyonunun kalbinde yer alan önemli bir özelliktir.
* Linting: YAML ve Python kodlarınız için linting araçlarını entegre ederek kod kalitesini artırır.

Ön Gereksinimler

Molecule ile Ansible rol testlerine başlamadan önce sisteminizde bazı temel araçların kurulu olması gerekir. Bu makalede Ubuntu 16.04 üzerinde test edeceğimiz için, test ortamı olarak Docker konteynerlerini kullanacağız. Dolayısıyla, ana makinenizde (geliştirme ortamınızda) Docker’ın kurulu olması önemlidir.

1. Ubuntu 16.04 İşletim Sistemi: Geliştirme ortamınız olarak Ubuntu 16.04 kullanıyorsanız, adımlar doğrudan uygulanabilir. Diğer Linux dağıtımlarında veya macOS üzerinde de benzer adımlarla ilerleyebilirsiniz.
2. Python 3 ve pip: Molecule ve Testinfra Python tabanlı araçlardır.

sudo apt update
    sudo apt install python3 python3-pip -y

3. Docker: Test ortamı olarak Docker konteynerlerini kullanacağımız için Docker motorunun kurulu ve çalışır durumda olması gerekir.

sudo apt install apt-transport-https ca-certificates curl software-properties-common -y
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
    sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu xenial stable"
    sudo apt update
    sudo apt install docker-ce -y
    sudo usermod -aG docker $USER # Kullanıcınızı docker grubuna ekleyin
    newgrp docker # Değişikliklerin hemen etkili olması için

Docker’ın doğru kurulduğundan emin olmak için:

docker run hello-world

4. Ansible: Molecule, Ansible’ı arka planda kullandığı için Ansible’ın da kurulu olması gerekir.

sudo pip3 install ansible

Molecule Kurulumu

Ön gereksinimleri tamamladıktan sonra Molecule’ü ve gerekli driver ile verifier eklentilerini kurabiliriz. Docker driver’ı ve Testinfra verifier’ı kullanacağımız için bunları da kurmalıyız.

sudo pip3 install molecule docker testinfra

Bu komut, Molecule’ün kendisini, Docker driver’ını ve Testinfra verifier’ını kuracaktır. Kurulumun başarılı olduğunu doğrulamak için:

molecule --version

Çıktı olarak Molecule sürüm numarasını görmelisiniz.

Molecule Temel Kavramları

Molecule’ün çalışma mantığını anlamak için bazı temel kavramları bilmek önemlidir:

* Driver (Sürücü): Test ortamını sağlayan mekanizmadır. Docker, Vagrant, OpenStack, EC2 gibi seçenekler mevcuttur. Biz bu makalede docker driver’ını kullanacağız. Bu driver, test için hafif ve hızlı konteynerler oluşturur.
* Provisioner (Sağlayıcı): Rolü test ortamında çalıştıran araçtır. Varsayılan olarak ve neredeyse her zaman ansible kullanılır. Molecule, Ansible’ı kullanarak rolünüzü test konteynerine/VM’ine uygular.
* Verifier (Doğrulayıcı): Rolün başarıyla uygulandığını ve sistemin beklenen durumda olduğunu kontrol eden test çerçevesidir. testinfra, inspec ve goss gibi seçenekler bulunur. testinfra, Python tabanlı ve kullanımı kolay olduğu için sıkça tercih edilir.
* Scenario (Senaryo): Bir rolün farklı test durumlarını tanımlamak için kullanılır. Örneğin, bir rolün ilk kurulumunu test eden bir senaryo, daha sonra rolün güncellenmesini test eden başka bir senaryo veya bir hata durumunu simüle eden farklı bir senaryo oluşturabilirsiniz. Her senaryo kendi Molecule yapılandırmasına ve test dosyalarına sahip olabilir. Varsayılan senaryo default olarak adlandırılır.
* Platform (Platform): Testin çalıştırılacağı sanal ortamı (konteyner veya VM) tanımlar. Örneğin, ubuntu:16.04 Docker imajı veya belirli bir Vagrant kutusu.

Bir Ansible Rolü Oluşturma

Test etmeye başlamadan önce basit bir Ansible rolüne ihtiyacımız var. Nginx web sunucusunu kuran ve yapılandıran basit bir rol oluşturalım. Ansible Galaxy’yi kullanarak temel rol yapısını oluşturalım:

ansible-galaxy init my_nginx_role
cd my_nginx_role

Bu komut, my_nginx_role adında bir dizin oluşturacak ve içinde tasks, handlers, vars, templates, defaults, meta gibi standart Ansible rol dizinlerini ve dosyalarını barındıracaktır.

Şimdi bu rolün içeriğini düzenleyelim. Amacımız Nginx’i kurmak, basit bir yapılandırma dosyası kopyalamak ve servisi başlatmak.

my_nginx_role/tasks/main.yml:

---
- name: Nginx paketini kur
  apt:
    name: nginx
    state: present
    update_cache: yes

- name: Nginx yapılandırma dosyasını kopyala
  template:
    src: nginx.conf.j2
    dest: /etc/nginx/nginx.conf
  notify: Nginx'i yeniden başlat

- name: Nginx servisini başlat ve etkinleştir
  service:
    name: nginx
    state: started
    enabled: yes

my_nginx_role/handlers/main.yml:

---
- name: Nginx'i yeniden başlat
  service:
    name: nginx
    state: restarted

my_nginx_role/templates/nginx.conf.j2:

user www-data;
worker_processes auto;
pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;

events {
    worker_connections 768;
    # multi_accept on;
}

http {
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;

    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3; # Dropping SSLv3, ref: POODLE
    ssl_prefer_server_ciphers on;

    access_log /var/log/nginx/access.log;
    error_log /var/log/nginx/error.log;

    gzip on;

    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-enabled/*;

    server {
        listen 80 default_server;
        listen [::]:80 default_server;
        root /var/www/html;
        index index.html index.htm index.nginx-debian.html;
        server_name _;
        location / {
            try_files $uri $uri/ =404;
        }
    }
}

Bu basit rol, Nginx’i kuracak, varsayılan bir yapılandırma dosyası ile değiştirecek ve servisi başlatacaktır.

Molecule ile Rolü Başlatma

Şimdi sıra Molecule yapılandırmasını oluşturmaya geldi. my_nginx_role dizini içinde iken aşağıdaki komutu çalıştırın:

molecule init scenario --driver docker --provisioner ansible --verifier testinfra

Bu komut, my_nginx_role/molecule/default dizinini oluşturacak ve içine bir dizi yapılandırma ve test dosyası yerleştirecektir:
* molecule/default/molecule.yml: Molecule’ün ana yapılandırma dosyası.
* molecule/default/create.yml: Test ortamını oluşturan playbook.
* molecule/default/converge.yml: Test edilecek Ansible rolünü çalıştıran playbook.
* molecule/default/verify.py: Testinfra testlerini içeren Python dosyası.
* molecule/default/destroy.yml: Test ortamını yok eden playbook.

molecule.yml Yapılandırması

molecule/default/molecule.yml dosyasını açalım ve Ubuntu 16.04 üzerinde test yapmak için düzenleyelim.

---
dependency:
  name: galaxy
driver:
  name: docker
platforms:
  - name: instance
    image: ubuntu:16.04
    pre_build_image: true
    command: "/sbin/init" # Systemd için gerekli olabilir, ancak çoğu durumda init yerine sleep de kullanılabilir.
    volumes:
      - /sys/fs/cgroup:/sys/fs/cgroup:ro # Systemd için gerekli
provisioner:
  name: ansible
  playbooks:
    converge: ${MOLECULE_SCENARIO_DIRECTORY}/converge.yml
  inventory:
    group_vars:
      all:
        ansible_python_interpreter: /usr/bin/python3 # Ubuntu 16.04'te varsayılan Python 2 olabilir.
verifier:
  name: testinfra
  options:
    verbose: true

Yukarıdaki yapılandırmanın önemli noktaları:

* dependency: galaxy olarak ayarlanmıştır. Bu, rolünüzün meta/main.yml dosyasında tanımlanan bağımlılıkları ansible-galaxy install komutu ile kurmasını sağlar.
* driver: docker olarak belirtilmiştir.
* platforms: Test edilecek sanal ortamları tanımlar.
* name: instance: Test konteynerine verdiğimiz isim.
* image: ubuntu:16.04: Konteyner için kullanılacak Docker imajı. Ubuntu 16.04’e özel olarak bu imajı kullanıyoruz.
* pre_build_image: true: Docker imajının önceden çekilmesini sağlar.
* command: "/sbin/init" ve volumes: /sys/fs/cgroup:/sys/fs/cgroup:ro: Eğer Nginx gibi bir servisi systemd ile yönetiyorsanız (ki Ubuntu 16.04’te systemd kullanılır), Docker konteynerinin systemd’yi doğru çalıştırması için bu ayarlar genellikle gereklidir. Aksi takdirde servisler düzgün çalışmayabilir.
* provisioner: ansible olarak ayarlanmıştır. inventory altında ansible_python_interpreter: /usr/bin/python3 belirtmek önemlidir, çünkü Ubuntu 16.04’te varsayılan Python sürümü Python 2 olabilir ve Ansible’ın Python 3 ile çalışmasını sağlamak isteyebiliriz.
* verifier: testinfra olarak ayarlanmıştır. verbose: true seçeneği test çıktısını daha detaylı hale getirir.

converge.yml Yapılandırması

molecule/default/converge.yml dosyası, Molecule’ün test konteynerinde çalıştıracağı Ansible playbook’udur. Bu playbook, test etmek istediğimiz rolü çağırır.

---
- name: Rolü test ortamında uygula
  hosts: all
  gather_facts: false # İlk kurulumda fact toplamayı atlayabiliriz, performansı artırır.
  roles:
    - role: my_nginx_role

Bu dosya, my_nginx_role‘ü instance adlı tüm host’larda çalıştırır.

Testinfra ile Test Yazma (verify.py)

Şimdi sıra rolümüzün doğru çalıştığını doğrulayacak testleri yazmaya geldi. molecule/default/verify.py dosyasını düzenleyelim.

import os
import pytest
import testinfra.utils.ansible_runner

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

@pytest.fixture(scope='module')
def host(ansible_host):
    return ansible_host

def test_nginx_package_installed(host):
    """
    Nginx paketinin kurulu olup olmadığını kontrol et.
    """
    assert host.package("nginx").is_installed

def test_nginx_service_running_and_enabled(host):
    """
    Nginx servisinin çalışır durumda ve etkin olup olmadığını kontrol et.
    """
    service = host.service("nginx")
    assert service.is_running
    assert service.is_enabled

def test_nginx_config_file_exists(host):
    """
    Nginx yapılandırma dosyasının var olup olmadığını kontrol et.
    """
    config_file = host.file("/etc/nginx/nginx.conf")
    assert config_file.exists
    assert config_file.is_file
    assert config_file.user == "root"
    assert config_file.group == "root"
    assert oct(config_file.mode) == "0o644" # Ya da istediğiniz izinler

def test_nginx_config_file_content(host):
    """
    Nginx yapılandırma dosyasının içeriğini kontrol et.
    """
    config_file = host.file("/etc/nginx/nginx.conf")
    assert config_file.contains("listen 80 default_server;")
    assert config_file.contains("user www-data;")

def test_nginx_port_listening(host):
    """
    Nginx'in 80 numaralı portta dinleyip dinlemediğini kontrol et.
    """
    assert host.socket("tcp://0.0.0.0:80").is_listening

Bu Testinfra testleri şunları kontrol eder:
* nginx paketinin kurulu olup olmadığını.
* nginx servisinin çalışır durumda ve sistem başlangıcında etkin olup olmadığını.
* /etc/nginx/nginx.conf dosyasının varlığını, dosya tipini, sahipliğini ve izinlerini.
* Yapılandırma dosyasının belirli içerikleri (örneğin, listen 80 ve user www-data) içerip içermediğini.
* Nginx’in 80 numaralı portta dinleyip dinlemediğini.

Bu testler, rolümüzün beklenen davranışları sergilediğini doğrulamak için yeterli bir başlangıç noktasıdır.

Molecule Komutları ve İş Akışı

Molecule, test akışını yönetmek için bir dizi komut sunar. my_nginx_role dizini içinde bu komutları çalıştırabilirsiniz:

1. molecule create: Test ortamını (Docker konteynerini) oluşturur. Bu adım, create.yml playbook’unu çalıştırır ve Docker imajını çeker.

molecule create

2. molecule converge: Ansible rolünü test ortamında çalıştırır. Bu adım, converge.yml playbook’unu çalıştırır ve rolünüzü uygular.

molecule converge

3. molecule verify: Rolün doğru çalıştığını doğrulamak için Testinfra testlerini çalıştırır. Bu adım, verify.py dosyasındaki testleri çalıştırır.

molecule verify

4. molecule destroy: Test ortamını (Docker konteynerini) yok eder. Bu adım, destroy.yml playbook’unu çalıştırır ve konteyneri siler.

molecule destroy

5. molecule test: Tüm bu adımları sırasıyla otomatik olarak çalıştıran ana komuttur: dependency, lint, destroy, create, converge, check, verify, destroy. Bu, genellikle sürekli entegrasyon (CI) ortamlarında kullanılan komuttur.

molecule test

Bu komut, rolünüzü uçtan uca test eder ve her adımın başarılı olduğundan emin olur.

6. molecule login: Hata ayıklama için test konteynerine veya VM’e SSH/exec ile bağlanmanızı sağlar.

molecule login

Bu komutu çalıştırdıktan sonra, test ortamınızdaki instance konteynerinin kabuğuna düşeceksiniz. Burada Nginx servisinin durumunu kontrol edebilir, dosyaları inceleyebilir veya sorunları giderebilirsiniz. Çıkmak için exit yazmanız yeterlidir.

7. molecule check: Rolün idempotence’ını (tekrar çalıştırılabilirlik) test eder. Rolü iki kez çalıştırır ve ikinci çalıştırmada herhangi bir değişikliğin yapılmadığından emin olur. Bu, Ansible rollerinin temel bir gereksinimidir.

molecule check

Bu komutun çıktısı, rolünüzün ikinci çalıştırmada “changed=0” veya “ok” durumunda olması gerektiğini gösterecektir. Eğer herhangi bir görev “changed” olarak işaretlenirse, rolünüz idempotence ilkesini ihlal ediyor demektir ve düzeltilmesi gerekir.

8. molecule lint: YAML ve Python kodlarınız için linting araçlarını çalıştırır. Bu, kod kalitesini artırmak ve yaygın hataları önlemek için faydalıdır.

molecule lint

Idempotence (Tekrar Çalıştırma) Testi

Ansible otomasyonunun en önemli prensiplerinden biri idempotence’tır. Bir Ansible rolü, bir sistemi istenen duruma getirmek için tasarlanmıştır. Bu rolün bir kez çalıştırılması ile on kez çalıştırılması arasında, sistemin son durumu açısından hiçbir fark olmamalıdır. Yani, ilk çalıştırmadan sonra yapılan ek çalıştırmalar sistemde herhangi bir değişiklik yapmamalıdır.

Molecule, bu özelliği molecule check komutu ile test etmenizi sağlar. Bu komutun çalışma prensibi şöyledir:
1. Test ortamını oluşturur (create).
2. Rolü ilk kez uygular (converge).
3. Rolü ikinci kez uygular (converge adımını tekrar çalıştırır), ancak bu kez Ansible’ın raporladığı değişiklikleri kontrol eder.
4. Eğer ikinci çalıştırmada herhangi bir görev “changed” olarak raporlanırsa, test başarısız olur. Bu, rolünüzün idempotence’ı ihlal ettiği anlamına gelir.
5. Testleri çalıştırır (verify).
6. Test ortamını yok eder (destroy).

Idempotence testi, özellikle bir rolün birden fazla kez çalıştırılması gereken sürekli dağıtım (CD) senaryolarında kritik öneme sahiptir. Örneğin, bir sunucuya yeni bir yapılandırma dağıttıktan sonra, aynı yapılandırmanın zaten mevcut olduğu durumlarda rolün gereksiz yere kaynakları yeniden yapılandırmaması veya servisleri yeniden başlatmaması gerekir.

Çoklu Platform ve Senaryolar

Molecule sadece tek bir platformda test yapmakla kalmaz, aynı zamanda farklı işletim sistemlerinde veya farklı senaryolarda da test yapma yeteneği sunar.

Çoklu Platform Testi

molecule.yml dosyasındaki platforms bölümüne birden fazla giriş ekleyerek rolünüzü farklı Ubuntu sürümlerinde veya hatta farklı dağıtımlarda test edebilirsiniz:

platforms:
  - name: instance-ubuntu1604
    image: ubuntu:16.04
    pre_build_image: true
    command: "/sbin/init"
    volumes:
      - /sys/fs/cgroup:/sys/fs/cgroup:ro
    # Diğer platform
  - name: instance-ubuntu1804
    image: ubuntu:18.04
    pre_build_image: true
    command: "/sbin/init"
    volumes:
      - /sys/fs/cgroup:/sys/fs/cgroup:ro

Bu yapılandırma ile molecule test komutu, rolünüzü hem Ubuntu 16.04 hem de Ubuntu 18.04 konteynerlerinde ayrı ayrı test edecektir. Bu, rolünüzün farklı ortamlarda uyumlu olduğunu doğrulamak için çok değerlidir.

Çoklu Senaryolar

Bir rolün farklı kullanım durumlarını veya yapılandırmalarını test etmek için birden fazla senaryo oluşturabilirsiniz. Örneğin, Nginx rolümüz için:
* default senaryosu: Varsayılan Nginx kurulumu.
* custom-port senaryosu: Nginx’i 8080 portunda dinleyecek şekilde yapılandırma.
* uninstall senaryosu: Nginx’i kaldırma ve sistemden tamamen temizleme.

Yeni bir senaryo oluşturmak için:

molecule init scenario custom-port --driver docker --provisioner ansible --verifier testinfra

Bu komut, molecule/custom-port dizinini oluşturacak ve kendi molecule.yml, converge.yml, verify.py dosyalarını içerecektir. custom-port/converge.yml içinde rolü çağırırken farklı değişkenler geçirebilir veya custom-port/verify.py içinde bu özel durumu doğrulayan testler yazabilirsiniz.

Örneğin, custom-port senaryosunun converge.yml dosyasında:

---
- name: Rolü özel port ile uygula
  hosts: all
  gather_facts: false
  roles:
    - role: my_nginx_role
      vars:
        nginx_port: 8080 # Rol içindeki bir değişkeni override etme

Ve custom-port/verify.py içinde 8080 portunu kontrol eden bir test ekleyebilirsiniz:

def test_nginx_custom_port_listening(host):
    assert host.socket("tcp://0.0.0.0:8080").is_listening

Belirli bir senaryoyu çalıştırmak için molecule --scenario custom-port test komutunu kullanabilirsiniz.

Hata Ayıklama ve Sorun Giderme

Testleriniz başarısız olduğunda veya rolünüz beklendiği gibi çalışmadığında, Molecule hata ayıklama sürecini kolaylaştırmak için birkaç araç sunar:

* molecule login: Bu komut, test konteynerine veya VM’e doğrudan SSH/exec erişimi sağlar. Konteyner içinde dosya sistemini inceleyebilir, servis durumlarını kontrol edebilir, logları okuyabilir ve sorunları manuel olarak ayıklayabilirsiniz.
* --debug veya -d flag’i: Molecule komutlarına --debug eklemek, daha ayrıntılı çıktı almanızı sağlar. Bu, özellikle Ansible veya Testinfra’dan gelen hata mesajlarını anlamak için faydalıdır. Örneğin: molecule --debug test.
* Ansible Verbosity: MOLECULE_ANSIBLE_VERBOSITY ortam değişkenini ayarlayarak Ansible’ın daha fazla ayrıntı vermesini sağlayabilirsiniz. Örneğin, MOLECULE_ANSIBLE_VERBOSITY=-vvv molecule converge komutu, Ansible’ın daha detaylı görev çıktılarını gösterecektir.
* Logları İnceleme: Konteyner içindeki servislerin loglarını (/var/log/nginx/error.log gibi) kontrol etmek, sorunların kaynağını bulmada yardımcı olabilir.
* Adım Adım Çalıştırma: molecule create, molecule converge, molecule verify gibi komutları tek tek çalıştırarak sorunun hangi adımda ortaya çıktığını izole edebilirsiniz. Özellikle converge adımından sonra molecule login ile bağlanıp durumu kontrol etmek, testleri çalıştırmadan önce rolün doğru çalıştığından emin olmak için faydalıdır.

Sonuç

Ansible rolleri, modern altyapı otomasyonunun vazgeçilmez bir parçasıdır. Ancak bu rollerin güvenilirliğini ve tutarlılığını sağlamak için kapsamlı testler yapmak hayati önem taşır. Molecule, bu görevi basitleştiren ve otomatikleştiren güçlü bir araçtır. Ubuntu 16.04 gibi belirli bir işletim sistemi üzerinde Docker konteynerlerini kullanarak, rolünüzün bu ortamda beklenen şekilde çalıştığından emin olabilirsiniz.

Bu makalede, Molecule’ün temel kavramlarını, kurulumunu, Nginx rolü örneğiyle nasıl kullanılacağını, molecule.yml yapılandırmasını, Testinfra ile test yazmayı ve temel Molecule komutlarını ele aldık. Ayrıca idempotence testinin önemini ve çoklu platform/senaryo testlerinin nasıl yapılacağını da inceledik.

Molecule’ü CI/CD işlem hatlarınıza entegre ederek, Ansible kodunuzdaki değişikliklerin otomatik olarak doğrulanmasını sağlayabilir, böylece üretim ortamlarınızın kararlılığını ve güvenliğini artırabilirsiniz. Unutmayın, iyi test edilmiş bir Ansible rolü, güvenilir bir altyapının temelidir.