Ansible: Bloklar Nasıl Kullanılır

Bu, Ansible oyun kitaplarınızı daha okunabilir ve sürdürülebilir hale getirebilir.

Bloklar sayesinde hataları zarif bir şekilde yönetebilir, birden fazla görev için ayrıcalıkları aynı anda artırabilir ve iç içe geçmiş bloklar ile görevleri hiyerarşik olarak düzenleyebilirsiniz.

Bu eğitimde Ansible bloklarının nasıl kullanılacağını pratik örneklerle inceleyeceğiz.

Ansible Bloklarının Temel Sözdizimi

Yanıtlayıcı

- name: Example block
  block:
    - name: Task 1
      ansible.builtin.command: echo "This is task 1"

    - name: Task 2
      ansible.builtin.command: echo "This is task 2"

Bu örnekte, her iki görev de bir blok içinde gruplandırılmıştır. Ne zaman, ne zaman, ne zaman veya kurtarma gibi ortak nitelikleri tüm bloğa uygulayabilirsiniz.

Koşullu Yürütme ile Blokları Kullanma

Bir grup görevi yalnızca belirli bir koşul karşılandığında yürütmek istediğinizi varsayalım. Koşulu her bir göreve ayrı ayrı uygulamak yerine, tüm bloğa uygulayabilirsiniz.

Aşağıdaki içerikle bir playbook oluşturun.

- name: Conditional block example
  hosts: localhost
  vars:
    run_tasks: true
  tasks:
    - name: Execute tasks if condition is met
      block:
        - name: Task 1
          ansible.builtin.command: echo "This is task 1"

        - name: Task 2
          ansible.builtin.command: echo "This is task 2"
      when: run_tasks

Bu kılavuzda, run_tasks adlı bir değişken tanımlayıp true olarak ayarlıyoruz. Ardından, iki görevi gruplamak için bir blok kullanıyoruz. Bloğa when koşulu uygulandığından, her iki görev de yalnızca run_tasks true olduğunda çalışacaktır.

Bu yaklaşım, koşulu her göreve ayrı ayrı uygulamak yerine bloğa bir kez uygulayarak plabooku basitleştirir.

Yukarıdaki playbooku çalıştırın.

ansible-playbook conditional_block_example.yml

Bu, yalnızca run_tasks koşulu doğruysa görev bloğunu çalıştıracaktır.

PLAY [Conditional block example] ***********************************************

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

TASK [Execute tasks if condition is met] ***************************************
skipping: [localhost]

TASK [Task 1] ******************************************************************
ok: [localhost] => {
    "changed": false,
    "msg": "This is task 1"
}

TASK [Task 2] ******************************************************************
ok: [localhost] => {
    "changed": false,
    "msg": "This is task 2"
}

PLAY RECAP *********************************************************************
localhost                  : ok=1    changed=0    unreachable=0    failed=0    skipped=1    rescued=0    ignored=0

Hata İşleme ile Blokları Kullanma

Kurtarma ve her zaman bölümlerini ekleyerek hataları zarif bir şekilde ele almak için blokları kullanabilirsiniz.

Bir oyun kitabı oluşturalım.

- name: Error handling block example
  hosts: localhost
  tasks:
    - name: Block with error handling
      block:
        - name: Task that might fail
          ansible.builtin.command: /bin/false

        - name: Task that won't be executed
          ansible.builtin.command: echo "This won't run"

      rescue:
        - name: Handle the error
          ansible.builtin.command: echo "An error occurred"

      always:
        - name: This always runs
          ansible.builtin.command: echo "This runs always"

Bu kılavuzda, blok bölümü başarısız olabilecek görevleri içerir. Kurtarma bölümü, bloktaki herhangi bir görev başarısız olursa çalıştırılacak görevleri içerir ve her zaman bölümü, başarı veya başarısızlıktan bağımsız olarak çalıştırılacak görevleri içerir.

Bu yapı, hataları zarif bir şekilde yönetmenize ve belirli eylemlerin her zaman gerçekleştirilmesini sağlamanıza olanak tanır.

Şimdi yukarıdaki playbooku çalıştırın.

ansible-playbook error_handling_block_example.yml

Bu, hataları yönetecek ve belirli görevlerin her zaman çalışmasını sağlayacaktır.

PLAY [Error handling block example] ********************************************

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

TASK [Block with error handling] ***********************************************
fatal: [localhost]: FAILED! => {"changed": false, "cmd": "/bin/false", "rc": 1}

TASK [Handle the error] ********************************************************
ok: [localhost] => {
    "changed": false,
    "msg": "An error occurred"
}

TASK [This always runs] ********************************************************
ok: [localhost] => {
    "changed": false,
    "msg": "This runs always"
}

PLAY RECAP *********************************************************************
localhost                  : ok=3    changed=0    unreachable=0    failed=0    skipped=0    rescued=1    ignored=0

Ayrıcalık Yükseltme ile Blokları Kullanma

Birden fazla göreve aynı anda ayrıcalık yükseltme (olma) uygulamak için blokları kullanabilirsiniz.

Aşağıdaki içerikle bir playbook oluşturun.

- name: Privilege escalation block example
  hosts: localhost
  tasks:
    - name: Block with privilege escalation
      block:
        - name: Task 1 as root
          ansible.builtin.command: echo "Task 1 as root"

        - name: Task 2 as root
          ansible.builtin.command: echo "Task 2 as root"
      become: yes

Bu kılavuzda, become: yes yönergesi bloğa uygulandığından, her iki görev de yükseltilmiş ayrıcalıklarla çalışır. Bu, birden fazla görevi farklı bir kullanıcı olarak çalıştırmanız gerektiğinde kullanışlıdır ve ayrıcalık yükseltmesini tüm bloğa uygulayarak gereksiz tekrarları azaltır.

Şimdi bu playbookuı çalıştıralım.

ansible-playbook privilege_escalation_block_example.yml

Bu playbook bloktaki görevleri kök ayrıcalıklarıyla yürütür.

PLAY [Privilege escalation block example] **************************************

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

TASK [Block with privilege escalation] *****************************************
ok: [localhost] => {
    "changed": false,
    "msg": "Task 1 as root"
}

ok: [localhost] => {
    "changed": false,
    "msg": "Task 2 as root"
}

PLAY RECAP *********************************************************************
localhost                  : ok=3    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

İç içe geçmiş bloklar

Karmaşık görev yapıları oluşturmak için blokları diğer blokların içine yerleştirebilirsiniz. Bu, görevleri mantıksal gruplar halinde düzenlemenize ve hiyerarşinin farklı seviyelerine belirli öznitelikler uygulamanıza yardımcı olabilir.

Bir playbook oluşturun ve aşağıdaki içeriği ekleyin.

- name: Nested blocks example
  hosts: localhost
  tasks:
    - name: Outer block
      block:
        - name: Task in outer block
          ansible.builtin.command: echo "This is in the outer block"

        - name: Inner block
          block:
            - name: Task in inner block
              ansible.builtin.command: echo

Bu kılavuzda, dış blok kendi içinde başka bir blok barındırır. Dış blok, dış blokta olduğunu belirten bir mesajı yankılayan bir göreve sahiptir. İç blok ise dış bloğun içine yerleştirilmiştir ve iç blokta olduğunu belirten bir mesajı yankılayan bir görev içerir.

Yukarıdaki playbooku çalıştırın.

ansible-playbook nested_blocks_example.yml

Aşağıdaki çıktıyı alacaksınız.

PLAY [Nested blocks example] ***************************************************

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

TASK [Outer block] *************************************************************
ok: [localhost] => {
    "changed": false,
    "msg": "This is in the outer block"
}

TASK [Inner block] *************************************************************
ok: [localhost] => {
    "changed": false,
    "msg": "This is in the inner block"
}

PLAY RECAP *********************************************************************
localhost                  : ok=3    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Blokları İşleyicilerle Kullanma

Önceki görev sonuçlarına göre koşullu olarak yürütülmesi gereken görevleri yönetmek için yararlı olabilecek işleyicileri bilgilendirmek için blokları kullanabilirsiniz.

Aşağıdaki içerikle bir playbook oluşturun:

- name: Blocks with handlers example
  hosts: localhost
  tasks:
    - name: Block with handler notification
      block:
        - name: Task that changes something
          ansible.builtin.command: echo "This changes something"
          notify: Restart service

        - name: Another task
          ansible.builtin.command: echo "This is another task"
      notify: Restart service

  handlers:
    - name: Restart service
      ansible.builtin.command: echo "Service restarted"

Bu örnekte, blok iki görev içerir ve her ikisi de işleyici Restart hizmetini bildirir. İşleyici Restart hizmeti, hizmetin yeniden başlatıldığını belirten bir iletiyi yankılayacak şekilde tanımlanmıştır.

Şimdi bu playbooku çalıştırın.

ansible-playbook blocks_with_handlers_example.yml

Bu playbook, işleyicileri bilgilendirmek için blokları kullanır ve böylece belirli görevlerin blok içindeki görevlerin sonuçlarına göre çalışmasını sağlar.

PLAY [Blocks with handlers example] ********************************************

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

TASK [Block with handler notification] *****************************************
ok: [localhost] => {
    "changed": false,
    "msg": "This changes something"
}

ok: [localhost] => {
    "changed": false,
    "msg": "This is another task"
}

RUNNING HANDLER [Restart service] **********************************************
ok: [localhost] => {
    "changed": false,
    "msg": "Service restarted"
}

PLAY RECAP *********************************************************************
localhost                  : ok=4    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0