Ansible Playbook’larda Koşullu İfadeler Nasıl Kullanılır?

Ansible Playbook’larda Koşullu İfadeler Nasıl Kullanılır?

Ansible, otomasyon dünyasında basitliği, aracısız mimarisi ve güçlü yetenekleriyle öne çıkan bir araçtır. Ancak otomasyon, her zaman düz bir yol izlemez; çoğu zaman farklı durumlara, sistem yapılandırmalarına veya kullanıcı tercihlerine göre farklı eylemlerin gerçekleştirilmesi gerekir. İşte bu noktada “koşullu ifadeler” (conditionals) devreye girer. Ansible playbook’larınızın dinamik, esnek ve akıllı olmasını sağlayan koşullu ifadeler, belirli bir koşulun doğru olup olmadığına bağlı olarak görevleri, rolleri veya diğer otomasyon adımlarını yürütmenize olanak tanır.

Bu makalede, Ansible playbook’larında koşullu ifadelerin nasıl kullanılacağını, farklı senaryolara yönelik çeşitli teknikleri ve en iyi uygulamaları derinlemesine inceleyeceğiz.

Koşullu İfadeler Neden Önemlidir?

Otomasyonun temel prensiplerinden biri, “idempotency” yani bir işlemin birden çok kez tekrarlandığında aynı sonucu vermesidir. Koşullu ifadeler, bu prensibi desteklemede kritik bir rol oynar. Örneğin, bir paketi yalnızca yüklü değilse kurmak, bir hizmeti yalnızca çalışmıyorsa başlatmak veya bir yapılandırma dosyasını yalnızca belirli bir işletim sisteminde dağıtmak gibi senaryolarda koşullu ifadeler vazgeçilmezdir.

Koşullu ifadeler sayesinde:
* Esneklik: Playbook’larınız farklı ortamlar ve sistemler arasında daha esnek hale gelir.
* Verimlilik: Gereksiz görevlerin çalışmasını engelleyerek otomasyon süreçlerinizi hızlandırır.
* Hata Toleransı: Hatalı veya istenmeyen durumların oluşmasını önlemeye yardımcı olur.
* Dinamik Davranış: Sistemden toplanan bilgilere (facts) veya harici verilere göre playbook’larınızın davranışını değiştirebilirsiniz.

Temel Koşullu Yapı: when Anahtar Kelimesi

Ansible’da koşullu ifadelerin en temel ve yaygın kullanım şekli when anahtar kelimesidir. when ifadesi, bir görevin (task), bloğun (block) veya hatta bir rolün (role) yalnızca belirli bir koşul doğruysa yürütülmesini sağlar.

when ifadesi, Jinja2 şablon motorunu kullanarak değerlendirilen bir Python ifadesi alır. Bu ifade, True veya False olarak sonuçlanmalıdır.

Görev Düzeyinde when Kullanımı

Bir görevin yalnızca belirli bir koşul altında çalışmasını istiyorsanız, when ifadesini doğrudan göreve ekleyebilirsiniz:

- name: Apache web sunucusunu kur
  ansible.builtin.apt:
    name: apache2
    state: present
  when: ansible_os_family == "Debian"

- name: Nginx web sunucusunu kur
  ansible.builtin.yum:
    name: nginx
    state: present
  when: ansible_os_family == "RedHat"

Yukarıdaki örnekte, ansible_os_family bir Ansible fact’idir ve çalıştırıldığı sistemin işletim sistemi ailesini belirtir. Debian tabanlı bir sistemde Apache, RedHat tabanlı bir sistemde ise Nginx kurulacaktır.

Birden Fazla Koşul Kullanımı: and, or, not

Karmaşık senaryolarda birden fazla koşulu birleştirmek gerekebilir. Bunun için and (ve), or (veya) ve not (değil) mantıksal operatörlerini kullanabilirsiniz:

- name: Apache'yi yalnızca Debian ve üretim ortamında başlat
  ansible.builtin.service:
    name: apache2
    state: started
  when: ansible_os_family == "Debian" and environment == "production"

- name: Uygulamayı yalnızca test veya geliştirme ortamında dağıt
  ansible.builtin.git:
    repo: 'https://github.com/my/app.git'
    dest: /var/www/my_app
  when: environment == "test" or environment == "development"

- name: Yalnızca kök kullanıcı değilse bir dosya oluştur
  ansible.builtin.file:
    path: /tmp/user_file.txt
    state: touch
  when: ansible_user_id != "root"

Parantez kullanarak koşulların değerlendirme sırasını belirleyebilirsiniz:

- name: Gelişmiş koşullu görev
  ansible.builtin.debug:
    msg: "Bu görev çalışıyor!"
  when: (ansible_os_family == "Debian" and ansible_distribution_major_version == "10") or environment == "staging"

Değişken Varlığını Kontrol Etme: is defined, is not defined

Bir değişkenin tanımlı olup olmadığını veya boş olup olmadığını kontrol etmek sıkça karşılaşılan bir durumdur. Bu, özellikle isteğe bağlı değişkenler veya dinamik olarak oluşturulan değişkenlerle çalışırken önemlidir.

- name: Yalnızca 'my_variable' tanımlıysa bir mesaj göster
  ansible.builtin.debug:
    msg: "my_variable değeri: {{ my_variable }}"
  when: my_variable is defined

- name: Yalnızca 'my_list' tanımlı değilse bir liste oluştur
  ansible.builtin.set_fact:
    my_list: []
  when: my_list is not defined

- name: Yalnızca 'my_string' boş değilse bir dosya oluştur
  ansible.builtin.file:
    path: /tmp/my_file.txt
    state: touch
  when: my_string is not none and my_string | length > 0 # veya my_string | default('') | length > 0

is none ve is not none de kullanılabilir. Bir değişken tanımlı değilse, Jinja2 bunu none olarak kabul eder.

Liste İçeriklerini Kontrol Etme

Bir listenin belirli bir öğeyi içerip içermediğini kontrol etmek için in operatörünü kullanabilirsiniz:

- name: "webserver" grubundaki host'lar için Apache'yi kur
  ansible.builtin.apt:
    name: apache2
    state: present
  when: "'webserver' in group_names" # group_names, host'un dahil olduğu grupların listesidir

- name: "Ubuntu" veya "Debian" ise bir görev çalıştır
  ansible.builtin.debug:
    msg: "Bu bir Debian tabanlı sistemdir."
  when: ansible_distribution in ['Ubuntu', 'Debian']

Gelişmiş Koşullu Senaryolar

Ansible, when anahtar kelimesinin ötesinde daha karmaşık koşullu mantıklar için çeşitli mekanizmalar sunar.

Koşullu Döngüler (Conditionals with Loops)

Döngülerle birlikte when kullanmak, bir listedeki öğeleri belirli koşullara göre filtrelemenizi veya her bir öğe için farklı eylemler gerçekleştirmenizi sağlar.

- name: Belirli kullanıcıları oluştur
  ansible.builtin.user:
    name: "{{ item.name }}"
    state: present
    groups: "{{ item.groups | default('') }}"
  loop:
    - { name: 'john', groups: 'dev' }
    - { name: 'jane', groups: 'ops' }
    - { name: 'bob', groups: 'dev' }
  when: item.groups == 'dev'

Yukarıdaki örnekte, sadece groups değeri ‘dev’ olan kullanıcılar oluşturulacaktır.

Koşullu Rol ve Görev Dahil Etme

Büyük ve modüler playbook’larda, belirli rolleri veya görev dosyalarını koşullu olarak dahil etmek isteyebilirsiniz. Bu, playbook’larınızın daha düzenli ve yönetilebilir olmasını sağlar.

include_role, import_role, include_tasks, import_tasks modülleri ile when kullanabilirsiniz.

- name: Apache rolünü yalnızca Debian tabanlı sistemlerde dahil et
  ansible.builtin.include_role:
    name: apache
  when: ansible_os_family == "Debian"

- name: Nginx rolünü yalnızca RedHat tabanlı sistemlerde dahil et
  ansible.builtin.include_role:
    name: nginx
  when: ansible_os_family == "RedHat"

- name: Geliştirme ortamı görevlerini dahil et
  ansible.builtin.include_tasks: develop_tasks.yml
  when: environment == "development"

Not: import_role ve import_tasks statik dahil etmelerdir ve when koşulları playbook ayrıştırılırken değerlendirilir. include_role ve include_tasks dinamik dahil etmelerdir ve when koşulları çalışma zamanında değerlendirilir. Çoğu durumda include_* tercih edilir, çünkü daha esnektir.

Koşullu Değişken Tanımlama

Bazen bir değişkenin değerini belirli bir koşula göre ayarlamanız gerekebilir. Bunu set_fact modülüyle veya Jinja2 filtreleriyle yapabilirsiniz.

- name: Uygulama portunu ortama göre ayarla
  ansible.builtin.set_fact:
    app_port: 8080
  when: environment == "production"

- name: Uygulama portunu geliştirme için ayarla
  ansible.builtin.set_fact:
    app_port: 8000
  when: environment == "development"

- name: Varsayılan portu ayarla (eğer öncekiler çalışmadıysa)
  ansible.builtin.set_fact:
    app_port: 9000
  when: app_port is not defined # veya else gibi düşünebilirsiniz

Daha kısa bir yol için default filtresi veya ternary filtresi kullanılabilir:

- name: Portu tek bir değişkende tanımla
  ansible.builtin.set_fact:
    app_port: "{{ 8080 if environment == 'production' else 8000 }}"

Koşullu Hata Yönetimi: failed_when ve changed_when

Ansible, bir görevin başarılı mı yoksa başarısız mı olduğunu veya bir değişikliğe neden olup olmadığını varsayılan olarak belirli çıkış kodlarına veya durumlarına göre belirler. Ancak bu davranışı failed_when ve changed_when ile özelleştirebilirsiniz.

* failed_when: Bir görevin çıkışına veya durumuna bakarak görevin ne zaman başarısız sayılacağını tanımlar. Özellikle bir komut veya betik modülü kullanırken ve çıkış kodunun her zaman 0 olmadığı ancak yine de başarılı olduğu durumlar için kullanışlıdır.

- name: Bir komutu çalıştır ve belirli bir çıktı varsa başarısız say
      ansible.builtin.shell: /usr/local/bin/my_custom_script.sh
      register: script_output
      failed_when: "'ERROR' in script_output.stderr"

* changed_when: Bir görevin ne zaman “değiştirildi” (changed) olarak raporlanacağını tanımlar. Bu, idempotency’yi sağlamak ve Ansible raporlamasını doğru hale getirmek için çok önemlidir. Örneğin, bir komut her zaman çalışır ancak yalnızca belirli bir koşulda sistemde gerçek bir değişiklik yapar.

- name: Bir dosyayı güncelle, ancak yalnızca içerik değişirse "changed" olarak işaretle
      ansible.builtin.shell: /usr/local/bin/update_config.sh
      register: update_result
      changed_when: "'UPDATED' in update_result.stdout"
      # Eğer script her zaman 0 döndürüyor ama bazen bir hata varsa, failed_when de ekleyebiliriz
      failed_when: "'FAILED' in update_result.stderr"

Ansible Fact’leri ve Koşullar

Ansible facts, yönetilen host’lar hakkında toplanan dinamik verilerdir (işletim sistemi, ağ arayüzleri, bellek, disk vb.). Bu bilgiler, playbook’larınızda koşullu ifadeler için temel bir kaynaktır. setup modülü varsayılan olarak tüm playbook’ların başında fact’leri toplar.

Yaygın kullanılan fact’ler ve örnekleri:
* ansible_os_family: “Debian”, “RedHat”, “Windows”
* ansible_distribution: “Ubuntu”, “CentOS”, “Fedora”
* ansible_distribution_major_version: “20”, “8”
* ansible_processor_count: CPU çekirdek sayısı
* ansible_memtotal_mb: Toplam bellek miktarı (MB)
* ansible_hostname: Host adı
* ansible_default_ipv4.address: Varsayılan IPv4 adresi

- name: Yalnızca 4'ten fazla CPU çekirdeği olan host'larda CPU yoğun bir uygulama kur
  ansible.builtin.package:
    name: high_perf_app
    state: present
  when: ansible_processor_count > 4

- name: Yalnızca belirli bir IP adresine sahip host'larda özel bir yapılandırma uygula
  ansible.builtin.template:
    src: special_config.j2
    dest: /etc/special_app.conf
  when: ansible_default_ipv4.address == "192.168.1.100"

Kendi özel fact’lerinizi de oluşturabilir ve bunları koşullu ifadelerde kullanabilirsiniz. Bunun için set_fact modülünü veya fact_caching özelliğini kullanabilirsiniz.

Jinja2 Şablon Motoru ve Koşullar

Ansible, yapılandırma dosyalarını dinamik olarak oluşturmak için Jinja2 şablon motorunu kullanır. Jinja2’nin kendi içinde de koşullu ifadeler bulunur ({% if %}, {% elif %}, {% else %}, {% endif %}). Bu, bir dosyanın içeriğinin belirli koşullara göre değişmesini sağlamak için idealdir.

# templates/my_app.conf.j2
server {
    listen {{ app_port }};
    server_name {{ inventory_hostname }};

    {% if environment == "production" %}
    access_log /var/log/nginx/{{ inventory_hostname }}_access.log main;
    error_log /var/log/nginx/{{ inventory_hostname }}_error.log warn;
    {% else %}
    access_log /var/log/nginx/{{ inventory_hostname }}_dev_access.log debug;
    error_log /var/log/nginx/{{ inventory_hostname }}_dev_error.log debug;
    {% endif %}

    location / {
        proxy_pass http://localhost:{{ backend_port }};
    }
}

Playbook’ta bu şablonu kullanırken:

- name: Uygulama yapılandırma dosyasını dağıt
  ansible.builtin.template:
    src: my_app.conf.j2
    dest: /etc/nginx/conf.d/my_app.conf
  vars:
    app_port: 80
    backend_port: 8080
    environment: "production" # Bu değişken Jinja2 şablonu içinde kullanılacak

Burada, environment değişkeninin değerine göre access_log ve error_log ayarları farklı olacaktır.

Jinja2 ayrıca listeler üzerinde koşullu filtreleme yapmak için select ve reject gibi filtreler sunar:

- name: Yalnızca belirli bir koşulu karşılayan öğeleri işle
  ansible.builtin.debug:
    msg: "Öğe: {{ item }}"
  loop: "{{ my_list | selectattr('status', 'equalto', 'active') | list }}"
  vars:
    my_list:
      - { name: 'user1', status: 'active' }
      - { name: 'user2', status: 'inactive' }
      - { name: 'user3', status: 'active' }

Bu örnekte, my_list içindeki sadece status: active olan öğeler döngüye alınacaktır.

En İyi Uygulamalar ve İpuçları

* Okunabilirlik ve Sadelik: Karmaşık when ifadelerini mümkün olduğunca basitleştirin. Gerekirse birden fazla when ifadesini ayrı ayrı satırlarda kullanın veya karmaşık mantığı değişkenlere atayın. Parantezleri doğru kullanarak mantıksal operatörlerin sırasını netleştirin.
* Değişken Kapsamı: Koşullu ifadelerde kullanılan değişkenlerin doğru kapsamda (host, grup, play, rol, görev) tanımlandığından emin olun.
* Fact’leri Akıllıca Kullanın: Ansible fact’leri, sistem hakkında güvenilir bilgi sağlar. Koşullarınızı oluştururken bu fact’lerden faydalanın. Ancak, çok fazla fact toplamak performansı etkileyebilir, bu nedenle gereksiz fact toplamayı (gather_facts: false) devre dışı bırakmayı düşünebilirsiniz.
* Test Edilebilirlik: Koşullu mantığınızı küçük, izole testlerle doğrulayın. debug modülü, değişken değerlerini ve koşullu ifadelerin sonucunu kontrol etmek için çok faydalıdır.

- name: Koşulu test et
      ansible.builtin.debug:
        msg: "Koşul doğru mu? {{ ansible_os_family == 'Debian' and environment == 'production' }}"

* Performans: Mümkünse, koşulları daha üst seviyelerde (örneğin, play veya rol düzeyinde) değerlendirerek gereksiz görevlerin veya rol dahil etmelerinin önüne geçin.
* Idempotency’yi Destekleme: changed_when ve failed_when gibi ifadelerle Ansible’ın raporlamasını doğru hale getirerek otomasyonunuzun gerçekten idempotent olmasını sağlayın.
* register Kullanımı: Bir önceki görevin çıktısını register ile bir değişkene kaydederek, bu çıktıyı sonraki görevlerdeki when ifadelerinde kullanabilirsiniz.

- name: Bir komut çalıştır
      ansible.builtin.shell: ls /tmp/my_file.txt
      register: file_check_result
      ignore_errors: true # Dosya yoksa hata vermesin

    - name: Dosya varsa bir işlem yap
      ansible.builtin.debug:
        msg: "Dosya var!"
      when: file_check_result.rc == 0 # return code 0 ise dosya var demektir

Sıkça Yapılan Hatalar

* Tanımlanmamış Değişkenler: Bir değişken tanımlı değilse ve is defined kontrolü yapmadan onu bir koşulda kullanmaya çalışırsanız, Ansible bir hata verir. Daima değişkenlerin varlığını kontrol edin (my_var is defined).
* Tür Uyumsuzlukları: Karşılaştırma yaparken değişkenlerin türlerini (string, integer, boolean) göz önünde bulundurun. Örneğin, ansible_processor_count bir sayı iken, environment bir dize olabilir.
* Karmaşık Mantık Hataları: Özellikle and ve or operatörlerini bir arada kullanırken parantezlerin doğru yerleştirilmesi çok önemlidir. Yanlış parantez kullanımı, beklenmedik sonuçlara yol açabilir.
* when ve failed_when Karışıklığı: when bir görevin çalışıp çalışmayacağını kontrol ederken, failed_when çalışan bir görevin başarılı mı yoksa başarısız mı sayılacağını kontrol eder. Amaçlarını karıştırmayın.
* Liste Elemanlarını Yanlış Kontrol Etme: Bir listenin belirli bir öğeyi içerip içermediğini kontrol etmek için doğrudan when: my_list == 'item' yerine when: 'item' in my_list kullanın.

Sonuç

Ansible playbook’larında koşullu ifadeler, otomasyonunuzu daha dinamik, esnek ve akıllı hale getiren temel bir araçtır. when anahtar kelimesinden failed_when, changed_when gibi gelişmiş seçeneklere ve Jinja2 şablonları içindeki koşullara kadar geniş bir yelpazede kullanım imkanı sunarlar. Ansible fact’lerini etkin bir şekilde kullanarak sistemleriniz hakkında bilgi toplayabilir ve bu bilgiyi otomasyon kararlarınızda kullanabilirsiniz.

Bu makalede ele alınan teknikleri ve en iyi uygulamaları benimseyerek, daha sağlam, bakımı kolay ve hataya dayanıklı Ansible playbook’ları oluşturabilirsiniz. Unutmayın, iyi yazılmış koşullu ifadeler, otomasyonunuzun sadece çalışmasını değil, aynı zamanda doğru, verimli ve öngörülebilir bir şekilde çalışmasını sağlar. Otomasyon yolculuğunuzda koşullu ifadelerin gücünü keşfetmeye devam edin!