Otomasyonun Gücü: Neden Ansible Kullanmalısınız?

Otomasyonun Gücü: Neden Ansible Kullanmalısınız?

Günümüzün hızla değişen IT altyapılarında, sunucu yönetimi ve uygulama dağıtımı gibi tekrarlayan görevler zaman alıcı ve hata yapmaya açık süreçler haline gelebilir. Peki, bu süreci nasıl daha verimli, tutarlı ve hatasız hale getirebiliriz? Ubuntu üzerinde Ansible kurulumu ve yapılandırması rehberimizle otomasyon dünyasına adım atın. Adım adım yönergeler, pratik örnekler ve ileri düzey ipuçlarıyla sunucu yönetimini kolaylaştırın. Bu kapsamlı rehber, manuel müdahaleyi en aza indirerek IT operasyonlarınızı dönüştürmenize yardımcı olacak.

Otomasyon, modern IT dünyasının vazgeçilmez bir parçasıdır. Geleneksel olarak, bir sistem yöneticisi birden fazla sunucuda aynı görevi yerine getirmek için her birine ayrı ayrı bağlanmak zorunda kalırdı. Bu durum, özellikle yüzlerce veya binlerce sunucudan oluşan büyük altyapılarda hem inanılmaz derecede zaman alıcı hem de insan hatasına açık bir süreçtir. Örneğin, yeni bir güvenlik güncellemesi dağıtmak, bir web sunucusunu yapılandırmak veya bir veritabanı yamasını uygulamak gibi görevler, manuel olarak yapıldığında saatler sürebilir ve tutarsız yapılandırmalara yol açabilir. İşte tam bu noktada, Ansible gibi güçlü bir otomasyon aracı devreye girer ve bu zorlukların üstesinden gelmenize olanak tanır.

Ansible, basitliği, aracısız mimarisi ve güçlü yetenekleriyle öne çıkan popüler bir açık kaynaklı otomasyon motorudur. Diğer otomasyon araçlarının aksine, yönetilen sunuculara herhangi bir ajan yazılımı yüklemenize gerek kalmaz. Bunun yerine, SSH protokolünü kullanarak uzak sunucularla iletişim kurar ve görevleri Python betikleri aracılığıyla yerine getirir. Bu aracısız yaklaşım, kurulum ve bakım karmaşıklığını önemli ölçüde azaltır, böylece otomasyon projelerinize daha hızlı başlayabilirsiniz. Ansible’ın temel amacı, IT altyapınızdaki yapılandırma yönetimini, uygulama dağıtımını ve görev otomasyonunu basitleştirmektir. İster küçük bir geliştirme ortamı yönetiyor olun isterse büyük ölçekli bir kurumsal altyapıyı, Ansible sunduğu esneklik ve güç ile size önemli avantajlar sağlar. Bu rehberde, Ubuntu işletim sistemi üzerinde Ansible’ı nasıl kuracağınızı, temel yapılandırmalarını nasıl yapacağınızı ve ilk otomasyon görevlerinizi nasıl gerçekleştireceğinizi adım adım öğreneceksiniz. Böylece, tekrarlayan görevlerden kurtularak daha stratejik işlere odaklanma fırsatı bulacaksınız.

Temel Kavramlar: Ansible Nedir ve Nasıl Çalışır?

Ansible’ın gücünü tam olarak anlamak için, öncelikle temel bileşenlerini ve çalışma prensiplerini kavramak önemlidir. Ansible, IT otomasyonunu kolaylaştırmak için tasarlanmış bir araçtır ve bu basitliği, belirli anahtar kavramlar üzerine inşa edilmiştir. En başta gelen özelliklerinden biri, yukarıda da bahsettiğimiz gibi, “aracısız” (agentless) mimarisidir. Bu, yönetilecek sunuculara (managed nodes) herhangi bir özel yazılım yüklemenize gerek olmadığı anlamına gelir. Ansible, standart SSH protokolü ve Python yorumlayıcısı aracılığıyla uzak sunucularla iletişim kurar. Bu yaklaşım, güvenlik duvarı yapılandırmalarını basitleştirir ve sistem kaynakları üzerinde ek yük oluşturmaz, bu da onu özellikle büyük ve heterojen ortamlar için cazip kılar.

Ansible mimarisinde üç ana rol bulunur: Kontrol Düğümü (Control Node), Yönetilen Düğümler (Managed Nodes) ve Envanter (Inventory). Kontrol düğümü, Ansible’ın kurulu olduğu ve tüm otomasyon görevlerinin başlatıldığı sunucudur. Genellikle bir Linux makinesi, örneğin bir Ubuntu sunucusu, kontrol düğümü olarak işlev görür. Yönetilen düğümler ise otomasyon görevlerinin uygulanacağı hedef sunucular veya cihazlardır. Bu düğümler Linux, Windows, ağ cihazları veya bulut servisleri olabilir. Envanter, Ansible’ın hangi sunucuları yönettiğini ve bu sunucular hakkında ek bilgileri (IP adresleri, kullanıcı adları, gruplar vb.) içeren bir dosyadır. Genellikle YAML veya INI formatında yazılır ve Ansible’ın hedef sunucuları tanımasını sağlar.

Ansible’ın otomasyon mantığı, Playbook’lar, Modüller ve Roller etrafında döner. Playbook’lar, Ansible’ın kalbidir ve otomasyon görevlerinizi tanımladığınız YAML formatındaki dosyalardır. Bir playbook, belirli bir dizi görevi (task) belirli bir grup sunucu (hosts) üzerinde nasıl yürüteceğinizi adım adım açıklar. Örneğin, bir web sunucusunu kurmak, bir veritabanı yapılandırmak veya bir uygulamayı dağıtmak gibi karmaşık iş akışları playbook’lar aracılığıyla tanımlanır. Modüller, Ansible’ın gerçekleştirebileceği belirli eylemleri temsil eden küçük programlardır. Yüzlerce hazır modül bulunur ve her biri belirli bir işlevi yerine getirir (örneğin, apt paketi yüklemek için, service servisleri yönetmek için, copy dosya kopyalamak için). Ansible, playbook’unuzda belirttiğiniz modülleri yönetilen düğümlerde çalıştırarak istenen durumu sağlar. Roller ise, playbook’ları ve ilgili dosyaları (değişkenler, şablonlar, görevler) organize etmenin ve yeniden kullanılabilir hale getirmenin bir yoludur. Karmaşık projelerde, rolleri kullanarak otomasyon kodunuzu daha modüler ve yönetilebilir hale getirebilirsiniz.

Ubuntu, Ansible kontrol düğümü olarak tercih edilmesinin birçok nedeni vardır. Öncelikle, Ubuntu geniş bir kullanıcı tabanına sahip popüler bir Linux dağıtımıdır ve bu da bol miktarda belge ve topluluk desteği bulabileceğiniz anlamına gelir. İkinci olarak, Python varsayılan olarak birçok Ubuntu sürümünde yüklü gelir ve Ansible büyük ölçüde Python üzerine inşa edilmiştir. Bu, kurulum sürecini basitleştirir ve bağımlılık sorunlarını azaltır. Ayrıca, Ubuntu’nun kararlılığı ve güvenilirliği, otomasyon ortamınız için sağlam bir temel sunar. Ansible’ın basit, insan tarafından okunabilir YAML sözdizimi sayesinde, karmaşık otomasyon görevlerini bile kolayca tanımlayabilir ve yönetebilirsiniz. Bu temel kavramları anladıktan sonra, Ansible’ı Ubuntu sisteminize kurmaya ve ilk otomasyon görevlerinizi gerçekleştirmeye hazır olacaksınız.

Ansible Kurulumu: Ubuntu Üzerinde Adım Adım Nasıl Yapılır?

Ansible’ın gücünden faydalanmaya başlamak için ilk adım, onu kontrol düğümü olarak kullanacağınız Ubuntu sistemine kurmaktır. Bu süreç oldukça basittir ve birkaç komutla tamamlanabilir. Kuruluma başlamadan önce, sisteminizin güncel olduğundan emin olmak her zaman iyi bir uygulamadır. Bu, potansiyel bağımlılık sorunlarını önler ve en son güvenlik yamalarına sahip olmanızı sağlar. Ardından, Ansible’ın temel bağımlılıklarından biri olan Python’ın doğru bir şekilde yüklü olduğundan emin olmalıyız, çünkü Ansible Python üzerinde çalışır ve uzak sunucularla iletişim kurmak için Python modüllerini kullanır. Modern Ubuntu sürümlerinde Python genellikle varsayılan olarak yüklü gelir, ancak yine de kontrol etmekte fayda var.

İlk olarak, sisteminizin paket listelerini güncelleyelim ve yüklü paketleri yükseltelim:

sudo apt update
sudo apt upgrade -y

Bu komutlar, paket yöneticinizin en son paket bilgilerine sahip olmasını ve mevcut tüm paketlerin güncel sürümlerine yükseltilmesini sağlar. Ardından, Ansible’ın bağımlılıklarını kurmak için gerekli olan software-properties-common ve python3-apt paketlerini yüklememiz gerekebilir. Bu paketler, PPA (Personal Package Archive) eklememize ve Python ile ilgili APT işlevlerini kullanmamıza olanak tanır:

sudo apt install software-properties-common python3-apt -y

Şimdi Ansible deposunu sistemimize ekleyebiliriz. Ansible’ın en güncel sürümünü almak için genellikle resmi PPA deposunu kullanmak en iyi yöntemdir:

sudo add-apt-repository --yes --update ppa:ansible/ansible

Bu komut, Ansible’ın resmi PPA’sını sisteminizin paket kaynaklarına ekler ve ardından paket listelerini otomatik olarak günceller. Depo eklendikten ve paket listeleri güncellendikten sonra, Ansible’ı kolayca kurabiliriz:

sudo apt install ansible -y

Kurulum tamamlandıktan sonra, Ansible’ın doğru bir şekilde yüklendiğini ve sürüm numarasını kontrol ederek doğrulayabiliriz:

ansible --version

Bu komut, Ansible’ın sürümünü, Python sürümünü ve diğer yapılandırma bilgilerini gösteren bir çıktı vermelidir. Eğer çıktı görüyorsanız, Ansible başarıyla kurulmuş demektir. Artık Ansible’ı kullanarak uzak sunucularınızı yönetmeye başlayabilirsiniz. Ancak, Ansible’ın yönetilen düğümlerle güvenli bir şekilde iletişim kurabilmesi için SSH anahtarlarının doğru bir şekilde yapılandırılması hayati öneme sahiptir. Bu, her bağlantıda şifre girmek zorunda kalmamanızı sağlar ve otomasyon süreçlerinizi kesintisiz hale getirir.

SSH Anahtarları ile Güvenli Bağlantı Nasıl Kurulur?

Ansible, yönetilen düğümlerle iletişim kurmak için SSH’yi kullanır ve bu bağlantıların güvenli ve parola gerektirmeyen bir şekilde gerçekleşmesi, otomasyonun temelini oluşturur. SSH anahtarları, bu güvenli ve sorunsuz bağlantıyı sağlamanın en iyi yoludur. Kontrol düğümünüzde bir SSH anahtar çifti oluşturarak ve genel anahtarı yönetilecek her sunucuya kopyalayarak, Ansible’ın bu sunuculara parola sormadan bağlanmasını sağlayabilirsiniz.

İlk olarak, kontrol düğümünüzde henüz bir SSH anahtar çifti yoksa, aşağıdaki komutu kullanarak oluşturabilirsiniz:

ssh-keygen

Bu komut, varsayılan olarak ~/.ssh/id_rsa (özel anahtar) ve ~/.ssh/id_rsa.pub (genel anahtar) dosyalarını oluşturacaktır. Komutu çalıştırdığınızda, anahtarın kaydedileceği konumu ve bir parola (passphrase) belirlemeniz istenecektir. Güvenlik için bir parola belirlemek iyi bir uygulamadır, ancak otomasyon senaryolarında parola girmeyi gerektirmeyen boş bir parola da tercih edilebilir (bu durumda güvenlik risklerini göz önünde bulundurmalısınız). Genellikle, otomasyon ortamlarında parola kullanılmaz ve bunun yerine anahtarların güvenliği farklı mekanizmalarla sağlanır.

Anahtar çifti oluşturulduktan sonra, genel anahtarınızı yönetilecek her bir sunucuya kopyalamanız gerekir. Bunu yapmanın en kolay yolu ssh-copy-id komutunu kullanmaktır:

ssh-copy-id kullanici_adi@hedef_sunucu_ip_adresi

Örneğin, sunucu1 adlı bir sunucuya ubuntu kullanıcısı ile bağlanmak istiyorsanız ve IP adresi 192.168.1.100 ise, komut şöyle olur:

ssh-copy-id ubuntu@192.168.1.100

Bu komutu ilk çalıştırdığınızda, hedef sunucunun parolasını girmeniz istenecektir. Parolayı doğru girdikten sonra, genel anahtarınız hedef sunucudaki ~/.ssh/authorized_keys dosyasına eklenecektir. Bu işlemden sonra, aynı kullanıcı ile hedef sunucuya parola girmeden bağlanabilmeniz gerekir. Bunu test etmek için basit bir SSH bağlantısı kurabilirsiniz:

ssh ubuntu@192.168.1.100

Eğer parola sormadan bağlanabiliyorsanız, SSH anahtarı yapılandırması başarılı olmuştur. Birden fazla sunucunuz varsa, bu adımı her bir yönetilen düğüm için tekrarlamanız gerekecektir. Ayrıca, kontrol düğümünüzde ssh-agent kullanmak, SSH anahtarlarınız için bir parola belirlemiş olsanız bile, her bağlantıda bu parolayı tekrar tekrar girmenizi engelleyerek otomasyon süreçlerinizi daha da kolaylaştırır. ssh-agent, anahtarlarınızı bellekte tutar ve siz oturumu kapatana veya ajanı durdurana kadar parolayı bir kez girmeniz yeterli olur. Bu kurulum, Ansible’ın yönetilen düğümlerle kesintisiz ve güvenli bir şekilde iletişim kurabilmesi için temel bir adımdır ve otomasyon süreçlerinizin verimliliğini büyük ölçüde artırır.

Envanter Yönetimi: Dinamik ve Statik Envanter Dosyaları Nasıl Oluşturulur?

Ansible’ın gücünün önemli bir kısmı, yönetilen düğümleri tanımlama ve düzenleme şeklinden gelir. Bu, Envanter (Inventory) dosyası aracılığıyla gerçekleştirilir. Envanter dosyası, Ansible’ın hangi sunucuları yöneteceğini, bu sunucuların IP adreslerini veya ana bilgisayar adlarını ve ayrıca bu sunucularla ilgili özel değişkenleri (örneğin, SSH portu, kullanıcı adı, özel yapılandırma parametreleri) içerir. Etkili bir envanter yönetimi, büyük ve karmaşık altyapılarda bile otomasyon görevlerinizin düzenli ve hedefli bir şekilde yürütülmesini sağlar.

Ansible iki ana envanter türünü destekler: statik ve dinamik. Statik envanter, manuel olarak oluşturduğunuz ve yönettiğiniz bir dosyadır. Genellikle /etc/ansible/hosts konumunda bulunur veya projenizin kök dizininde özel bir dosya olarak tanımlanır. Bu dosya, basit ve küçük ortamlar için idealdir. Sunucularınızı gruplara ayırabilir, bu gruplara özel değişkenler atayabilir ve daha okunabilir bir yapı oluşturabilirsiniz. İşte basit bir statik envanter dosyası örneği:

[web_sunuculari]
web1.example.com ansible_host=192.168.1.101
web2.example.com ansible_host=192.168.1.102

[db_sunuculari]
db1.example.com ansible_host=192.168.1.103

[tum_sunucular:children]
web_sunuculari
db_sunuculari

[vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=~/.ssh/id_rsa

Bu örnekte, [web_sunuculari] ve [db_sunuculari] adında iki grup tanımlanmıştır. Her sunucu için bir ana bilgisayar adı ve ansible_host değişkeni ile IP adresi belirtilmiştir. [tum_sunucular:children], web_sunuculari ve db_sunuculari gruplarını içeren üst bir grup oluşturur, böylece tüm sunuculara tek bir komutla erişilebilir. [vars] bölümü ise tüm envanterdeki sunucular için geçerli olacak genel değişkenleri tanımlar; burada SSH bağlantısı için kullanılacak kullanıcı adı (ansible_user) ve özel anahtar dosyası (ansible_ssh_private_key_file) belirtilmiştir. Bu sayede her sunucu için ayrı ayrı bu bilgileri belirtmenize gerek kalmaz. Statik envanter dosyalarını kullanarak, sunucularınızı mantıksal olarak gruplandırabilir ve otomasyon görevlerinizi belirli gruplara veya tüm altyapınıza uygulayabilirsiniz.

Büyük ve dinamik bulut ortamlarında (AWS, Azure, GCP gibi) veya sanallaştırma platformlarında (VMware, OpenStack), sunucu IP adresleri sık sık değişebilir veya yeni sunucular otomatik olarak oluşturulup yok edilebilir. Bu tür senaryolarda statik envanter dosyalarını manuel olarak güncellemek sürdürülemez hale gelir. İşte bu noktada dinamik envanter devreye girer. Dinamik envanter, harici bir betik (Python, Bash vb.) aracılığıyla çalıştırılan ve Ansible’ın anlık olarak sunucu bilgilerini almasını sağlayan bir mekanizmadır. Bu betikler, bulut sağlayıcınızın API’sini sorgulayarak veya diğer kaynaklardan veri çekerek envanter bilgilerini JSON formatında Ansible’a sunar. Örneğin, AWS için bir dinamik envanter betiği, EC2 örneklerinizi sorgulayarak mevcut tüm sunucuların listesini, IP adreslerini ve etiketlerini Ansible’a sağlayabilir. Bu sayede, altyapınızdaki değişiklikler otomatik olarak Ansible’a yansıtılır ve manuel müdahaleye gerek kalmaz.

Gerçek dünya senaryosu olarak, bir web sunucusu çiftliği kurduğunuzu düşünelim. Bu çiftlikte 5 adet Nginx web sunucusu ve 2 adet PostgreSQL veritabanı sunucusu bulunuyor. Statik envanter dosyanız şöyle görünebilir:

[web_servers]
webserver[1:5].example.com

[db_servers]
dbserver[1:2].example.com

[all_servers:children]
web_servers
db_servers

[web_servers:vars]
http_port=80
max_clients=200

[db_servers:vars]
db_port=5432
db_user=admin

Bu envanterde, webserver1‘den webserver5‘e kadar olan sunucuları tek bir satırda tanımlayabilir ve web_servers grubuna özel değişkenler atayabilirsiniz. Aynı durum veritabanı sunucuları için de geçerlidir. Bu yapılandırma, Ansible’ın belirli görevleri sadece web sunucularına veya sadece veritabanı sunucularına uygulamasını sağlar. Ayrıca, grup değişkenleri sayesinde, bir grubun tüm üyelerine aynı yapılandırma parametrelerini kolayca uygulayabilirsiniz. Envanter yönetimi, Ansible otomasyonunuzun ölçeklenebilirliği ve esnekliği için kritik bir bileşendir ve doğru bir şekilde yapılandırıldığında, altyapı yönetimini büyük ölçüde basitleştirir.

İlk Playbook’unuzu Oluşturma: Basit Bir Otomasyon Görevini Nasıl Gerçekleştirirsiniz?

Ansible’ın kalbi olan playbook’lar, otomasyon görevlerinizi tanımladığınız YAML formatındaki dosyalardır. Bir playbook, belirli bir dizi görevi (task) belirli bir grup sunucu (hosts) üzerinde nasıl yürüteceğinizi adım adım açıklar. İlk playbook’unuzu oluşturmak, Ansible ile otomasyon yolculuğunuzda önemli bir adımdır ve size aracın temel işleyişini kavrama fırsatı sunar. Bu bölümde, basit bir playbook oluşturarak yönetilen sunucularınızda nasıl görevler çalıştıracağınızı öğreneceğiz.

Playbook’lar YAML sözdizimi kullanır, bu da onları insan tarafından okunabilir ve yazılabilir kılar. Her playbook, bir veya daha fazla “oyun” (play) içerir ve her oyun, bir grup ana bilgisayar üzerinde belirli görevleri yürütür. Bir oyunun temel yapısı şunları içerir:

• hosts: Görevlerin uygulanacağı hedef sunucular veya envanter grupları.
• become: Görevlerin root ayrıcalıklarıyla (sudo gibi) çalıştırılıp çalıştırılmayacağını belirtir.
• tasks: Yürütülecek görevlerin listesi. Her görev bir modül çağrısıdır.

İlk olarak, tüm yönetilen düğümlerinize erişiminizi test etmek için basit bir “ping” playbook’u oluşturalım. Bir dosya oluşturun, örneğin ping_test.yml:

---
- name: Tüm sunucularda ping testi yap
  hosts: all
  become: false
  tasks:
    - name: Ping modülü ile bağlantıyı kontrol et
      ansible.builtin.ping:

Bu playbook’u çalıştırmak için kontrol düğümünüzde aşağıdaki komutu kullanın:

ansible-playbook ping_test.yml -i /path/to/your/inventory/hosts

-i parametresi ile envanter dosyanızın yolunu belirtmeyi unutmayın. Eğer her şey yolundaysa, playbook, envanterinizdeki tüm sunuculara bağlanacak ve her biri için “pong” yanıtını döndürecektir. Bu, Ansible’ın sunucularınızla başarılı bir şekilde iletişim kurabildiğini gösterir.

Şimdi daha pratik bir örnek yapalım: Yönetilen düğümlerinize Nginx web sunucusunu kuran bir playbook. Bu playbook, apt modülünü kullanarak Nginx paketini yükleyecek ve ardından service modülünü kullanarak Nginx servisini başlatıp etkinleştirecektir. nginx_kurulumu.yml adında bir dosya oluşturalım:

---
- name: Web sunucularına Nginx kur ve yapılandır
  hosts: web_sunuculari # Envanterinizdeki web sunucusu grubunu hedefle
  become: true # Root ayrıcalıklarıyla çalıştır
  tasks:
    - name: Apt paket listesini güncelle
      ansible.builtin.apt:
        update_cache: yes

    - name: Nginx paketini kur
      ansible.builtin.apt:
        name: nginx
        state: present

    - name: Nginx servisini başlat ve başlangıçta etkinleştir
      ansible.builtin.service:
        name: nginx
        state: started
        enabled: yes

Bu playbook’u çalıştırmak için:

ansible-playbook nginx_kurulumu.yml -i /path/to/your/inventory/hosts

Playbook başarıyla tamamlandıktan sonra, web_sunuculari grubundaki tüm sunuculara Nginx kurulmuş ve servisleri çalışır durumda olacaktır. Bu, Ansible’ın yapılandırma yönetimini nasıl otomatikleştirebileceğine dair harika bir örnektir. Benzer şekilde, dosyaları yönetmek, kullanıcılar oluşturmak veya farklı servisleri kontrol etmek için çeşitli modüller kullanabilirsiniz. Örneğin, bir sunucudaki bir dosyayı kopyalamak için copy modülünü, bir kullanıcının varlığını sağlamak için user modülünü kullanabilirsiniz. Ansible’ın gücü, yüzlerce modülü ve bu modüllerin bir playbook içinde birleştirilme yeteneğinde yatmaktadır. Bu sayede karmaşık otomasyon senaryolarını bile basit ve tekrarlanabilir adımlara bölebilirsiniz. İlk playbook’unuzu oluşturmak, otomasyon dünyasına attığınız ilk somut adımdır ve daha karmaşık görevleri otomatikleştirmek için size bir temel sağlar.

Yaygın Ansible Modülleri ve Kullanım Alanları Nelerdir?

Ansible’ın gücü, zengin modül kütüphanesinden gelir. Her modül, belirli bir görevi yerine getirmek için tasarlanmıştır ve binlerce farklı işlevi kapsar. Bu modüller, sistem yönetimi, ağ yapılandırması, bulut kaynak yönetimi ve daha fazlası dahil olmak üzere çeşitli alanlarda otomasyon sağlamak için kullanılabilir. İşte en sık kullanılan ve temel Ansible modüllerinden bazıları ve onların kullanım alanları:

• ansible.builtin.apt (veya yum, dnf, pacman): Debian tabanlı sistemlerde (Ubuntu gibi) paket yönetimi için kullanılır. Paketleri kurabilir, kaldırabilir, güncelleyebilir veya önbelleği yenileyebilir.

  
  - name: Git paketini kur
    ansible.builtin.apt:
      name: git
      state: present
          

• ansible.builtin.service: Sistem servislerini (Nginx, Apache, MySQL vb.) yönetmek için kullanılır. Servisleri başlatabilir, durdurabilir, yeniden başlatabilir veya başlangıçta etkinleştirebilir/devre dışı bırakabilir.

  
  - name: Apache servisini yeniden başlat
    ansible.builtin.service:
      name: apache2
      state: restarted
          

• ansible.builtin.copy: Kontrol düğümünden yönetilen düğümlere dosya veya dizin kopyalamak için kullanılır. İzinleri ve sahiplikleri de ayarlayabilir.

  
  - name: Yapılandırma dosyasını kopyala
    ansible.builtin.copy:
      src: /path/to/local/config.conf
      dest: /etc/app/config.conf
      owner: root
      group: root
      mode: '0644'
          

• ansible.builtin.file: Dosyaların, dizinlerin veya sembolik bağlantıların durumunu yönetmek için kullanılır. Dosya oluşturabilir, silebilir, izinlerini değiştirebilir veya dizinler oluşturabilir.

  
  - name: Log dizini oluştur
    ansible.builtin.file:
      path: /var/log/myapp
      state: directory
      mode: '0755'
          

• ansible.builtin.template: Jinja2 şablon motorunu kullanarak kontrol düğümündeki bir şablon dosyasını yönetilen düğümlerdeki nihai bir dosyaya dönüştürür. Değişkenleri dinamik olarak yapılandırma dosyalarına enjekte etmek için idealdir.

  
  - name: Nginx sanal host şablonunu dağıt
    ansible.builtin.template:
      src: nginx.conf.j2
      dest: /etc/nginx/sites-available/default
          

• ansible.builtin.user: Yönetilen düğümlerde kullanıcı hesaplarını yönetmek için kullanılır. Kullanıcı oluşturabilir, silebilir, parolalarını ayarlayabilir, grup üyeliklerini değiştirebilir.

  
  - name: Yeni bir kullanıcı oluştur
    ansible.builtin.user:
      name: devops_user
      state: present
      groups: sudo
      append: yes
          

• ansible.builtin.command ve ansible.builtin.shell: Yönetilen düğümlerde rastgele komutlar çalıştırmak için kullanılır. command modülü daha basit komutlar için güvenlidir (pipe, redirect gibi kabuk özelliklerini desteklemez), shell ise daha karmaşık kabuk komutlarını çalıştırabilir.

  
  - name: Disk kullanımını kontrol et
    ansible.builtin.shell: df -h
    register: disk_usage_output
  
  - name: Disk kullanımını göster
    ansible.builtin.debug:
      var: disk_usage_output.stdout_lines
          

Bu modüller, Ansible ile yapabileceğiniz işlemlerin sadece küçük bir kısmıdır. Her bir modülün birçok farklı parametresi bulunur ve bu parametreler, görevlerinizi belirli ihtiyaçlarınıza göre ince ayarlamanıza olanak tanır. Ansible dokümantasyonu, her modül hakkında detaylı bilgi ve örnekler sunar. Modülleri etkili bir şekilde kullanarak, neredeyse her türlü IT operasyonunu otomatikleştirebilir ve altyapınızın yönetimini basitleştirebilirsiniz.

Gelişmiş Ansible Yapılandırmaları: Roller ve Şablonlar ile Verimliliği Artırma

Basit playbook’lar ile otomasyon görevlerini yerine getirmek kolay olsa da, projeleriniz büyüdükçe ve karmaşıklaştıkça, kodunuzu daha düzenli, yeniden kullanılabilir ve sürdürülebilir hale getirmek için daha gelişmiş yapılandırmalara ihtiyacınız olacaktır. Ansible, bu ihtiyacı karşılamak için “Roller” ve “Jinja2 Şablonları” gibi güçlü özellikler sunar. Bu özellikler, otomasyon kodunuzu modüler hale getirerek ve dinamik yapılandırma dosyaları oluşturarak verimliliğinizi önemli ölçüde artırır.

Ansible Rolleri ile Projelerinizi Nasıl Yapılandırırsınız?

Ansible Rolleri, playbook’ları, değişkenleri, görevleri, şablonları ve diğer dosyaları mantıksal ve yeniden kullanılabilir bir yapıda organize etmenin standart bir yoludur. Bir rol, belirli bir uygulamanın veya sunucu türünün (örneğin, bir web sunucusu, bir veritabanı sunucusu) yapılandırması için gereken tüm bileşenleri tek bir dizin yapısı altında toplar. Bu, özellikle farklı projelerde veya farklı sunucu gruplarında benzer yapılandırmaları uygulamanız gerektiğinde büyük avantaj sağlar.

Bir rolün tipik dizin yapısı şöyledir:

rol_adi/
├── defaults/        # Varsayılan değişkenler (en düşük öncelikli)
│   └── main.yml
├── handlers/        # Tetikleyiciler (servisleri yeniden başlatmak gibi)
│   └── main.yml
├── tasks/           # Rolün ana görevleri
│   └── main.yml
├── templates/       # Jinja2 şablonları
├── files/           # Kopyalanacak statik dosyalar
├── vars/            # Rol özel değişkenleri (orta öncelikli)
│   └── main.yml
├── meta/            # Rolün meta verileri (yazar, bağımlılıklar vb.)
│   └── main.yml
└── README.md

Yeni bir rol oluşturmak için ansible-galaxy init komutunu kullanabilirsiniz:

ansible-galaxy init webserver

Bu komut, webserver adında yukarıdaki dizin yapısına sahip bir rol oluşturacaktır. Örneğin, bir Nginx web sunucusu rolü oluşturduğunuzu varsayalım. webserver/tasks/main.yml dosyasına Nginx kurulumu ve yapılandırma görevlerini ekleyebilirsiniz:

# webserver/tasks/main.yml
---
- name: Nginx'i kur
  ansible.builtin.apt:
    name: nginx
    state: present

- name: Nginx varsayılan yapılandırmasını kopyala
  ansible.builtin.template:
    src: default.conf.j2
    dest: /etc/nginx/sites-available/default
  notify: restart nginx

- name: Nginx servisini başlat ve başlangıçta etkinleştir
  ansible.builtin.service:
    name: nginx
    state: started
    enabled: yes

webserver/handlers/main.yml dosyasına ise tetikleyici (handler) tanımlayabilirsiniz:

# webserver/handlers/main.yml
---
- name: Nginx'i yeniden başlat
  ansible.builtin.service:
    name: nginx
    state: restarted

Bu rolü bir playbook içinde kullanmak için, playbook’unuzu şöyle yazabilirsiniz:

---
- name: Web sunucularını yapılandır
  hosts: web_sunuculari
  become: true
  roles:
    - webserver

Böylece, webserver rolü, web_sunuculari grubundaki tüm sunuculara uygulanacaktır. Roller, karmaşık otomasyon projelerini daha küçük, yönetilebilir ve yeniden kullanılabilir bileşenlere ayırarak kod kalitesini ve sürdürülebilirliği artırır.

Jinja2 Şablonları ile Dinamik Yapılandırma Dosyaları Nasıl Oluşturulur?

Çoğu zaman, yönetilen sunucularda dağıtmanız gereken yapılandırma dosyaları, sunucuya veya ortama özgü dinamik değerler içerir. Örneğin, bir veritabanı bağlantı dizesi, bir uygulamanın port numarası veya bir sunucunun IP adresi gibi bilgiler her sunucuda farklı olabilir. Jinja2 şablonları, bu tür dinamik yapılandırma dosyalarını oluşturmak için Ansible’ın en güçlü özelliklerinden biridir.

Jinja2, Python tabanlı bir şablon motorudur ve Ansible tarafından template modülü aracılığıyla kullanılır. Bir Jinja2 şablonu, normal bir metin dosyası gibi görünür ancak değişkenleri, döngüleri ve koşullu ifadeleri içerebilir. Ansible, bu şablonları yönetilen düğümlere kopyalamadan önce işler ve tüm değişkenleri gerçek değerleriyle değiştirir.

Örneğin, Nginx için bir sanal host yapılandırma dosyası oluşturmak istediğinizi varsayalım. Bu dosya, her sunucu için farklı bir sunucu adı veya kök dizini içerebilir. webserver/templates/default.conf.j2 adında bir şablon dosyası oluşturalım:

# webserver/templates/default.conf.j2
server {
    listen {{ http_port | default(80) }};
    listen [::]:{{ http_port | default(80) }};

    server_name {{ server_name | default('localhost') }};
    root /var/www/{{ app_name | default('html') }};
    index index.html index.htm index.nginx-debian.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

Bu şablonda, çift süslü parantezler ({{ variable_name }}) değişkenleri temsil eder. Örneğin, {{ http_port }} değişkeni, playbook veya envanterde tanımlanan http_port değeriyle değiştirilecektir. | default(80) ifadesi, eğer değişken tanımlanmamışsa varsayılan bir değer (bu durumda 80) kullanılmasını sağlar. Bu şablonu kullanmak için, playbook’unuzda veya rolünüzün görevlerinde template modülünü çağırırsınız:

- name: Nginx sanal host şablonunu dağıt
  ansible.builtin.template:
    src: default.conf.j2
    dest: /etc/nginx/sites-available/default
  notify: restart nginx

Ardından, playbook’unuzda veya envanterinizde bu değişkenleri tanımlayabilirsiniz. Örneğin, web_sunuculari grubunuz için http_port, server_name ve app_name değişkenlerini tanımlayabilirsiniz. Bu sayede, aynı şablonu kullanarak farklı sunucular için özelleştirilmiş Nginx yapılandırma dosyaları oluşturabilirsiniz. Jinja2 şablonları, yapılandırma dosyalarını elle düzenleme ihtiyacını ortadan kaldırarak otomasyon süreçlerinizin esnekliğini ve doğruluğunu önemli ölçüde artırır. Roller ve Jinja2 şablonlarının birleşimi, Ansible ile karmaşık ve ölçeklenebilir otomasyon çözümleri geliştirmenizi sağlar.

Vaka Analizi: Çok Sunuculu Bir Uygulama Dağıtımını Ansible ile Otomatize Etme

Ansible’ın gerçek dünyadaki faydalarını daha iyi anlamak için, popüler bir senaryoyu ele alalım: Nginx, PHP-FPM ve MySQL kullanan bir WordPress uygulamasının çok sunuculu bir ortama dağıtılması. Bu tür bir dağıtım, manuel olarak yapıldığında karmaşık, zaman alıcı ve hataya açık olabilir. Ansible ile bu süreci nasıl otomatikleştirebileceğimizi adım adım inceleyelim. Senaryomuzda üç farklı sunucu grubumuz olacak: bir web sunucusu (Nginx ve PHP-FPM), bir veritabanı sunucusu (MySQL) ve isteğe bağlı olarak bir uygulama sunucusu (WordPress dosyaları için).

Öncelikle, envanter dosyamızı bu senaryoya uygun şekilde yapılandıralım. Varsayalım ki web1.example.com web sunucumuz, db1.example.com ise veritabanı sunucumuz olsun:

# hosts
[web_servers]
web1.example.com

[db_servers]
db1.example.com

[all_servers:children]
web_servers
db_servers

[all_servers:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=~/.ssh/id_rsa

[web_servers:vars]
php_version="8.1"
nginx_port="80"
wp_db_name="wordpress_db"
wp_db_user="wordpress_user"
wp_db_password="SUPER_SECRET_PASSWORD"
wp_db_host="db1.example.com"

[db_servers:vars]
mysql_root_password="MYSQL_ROOT_PASSWORD"

Bu envanterde, her sunucu grubuna özel değişkenler tanımladık. Bu değişkenler, playbook’larımızda dinamik olarak kullanılacak ve her sunucunun kendi yapılandırmasına sahip olmasını sağlayacaktır. Şimdi, bu dağıtım için bir ana playbook oluşturalım, bu playbook farklı rolleri çağıracaktır:

# site.yml
---
- name: Web sunucusunu yapılandır
  hosts: web_servers
  become: true
  roles:
    - { role: common } # Ortak paketler, güvenlik ayarları
    - { role: nginx_php } # Nginx ve PHP-FPM kurulumu
    - { role: wordpress } # WordPress uygulamasının dağıtımı

- name: Veritabanı sunucusunu yapılandır
  hosts: db_servers
  become: true
  roles:
    - { role: common }
    - { role: mysql_server } # MySQL sunucusunun kurulumu ve veritabanı oluşturma

Bu site.yml playbook’u, her biri belirli bir işlevi yerine getiren dört farklı rolü çağırıyor: common (tüm sunucular için temel ayarlar), nginx_php (web sunucusu kurulumu), wordpress (WordPress dağıtımı) ve mysql_server (veritabanı sunucusu kurulumu). Her rol, kendi tasks/main.yml, templates/ ve vars/ dizinlerine sahip olacaktır. Örneğin:

roles/nginx_php/tasks/main.yml:

- name: Nginx ve PHP-FPM paketlerini kur
  ansible.builtin.apt:
    name:
      - nginx
      - php{{ php_version }}-fpm
      - php{{ php_version }}-mysql
      - php{{ php_version }}-cli
      - php{{ php_version }}-curl
      - php{{ php_version }}-gd
      - php{{ php_version }}-mbstring
      - php{{ php_version }}-xml
      - php{{ php_version }}-zip
    state: present
    update_cache: yes

- name: Nginx yapılandırma dosyasını kopyala
  ansible.builtin.template:
    src: nginx.conf.j2
    dest: /etc/nginx/sites-available/wordpress
  notify: restart nginx

- name: Nginx yapılandırmasını etkinleştir
  ansible.builtin.file:
    src: /etc/nginx/sites-available/wordpress
    dest: /etc/nginx/sites-enabled/wordpress
    state: link
  notify: restart nginx

- name: Nginx varsayılan sitesini devre dışı bırak
  ansible.builtin.file:
    path: /etc/nginx/sites-enabled/default
    state: absent
  notify: restart nginx

- name: PHP-FPM servisini başlat ve etkinleştir
  ansible.builtin.service:
    name: php{{ php_version }}-fpm
    state: started
    enabled: yes

roles/mysql_server/tasks/main.yml:

- name: MySQL sunucusunu kur
  ansible.builtin.apt:
    name: mysql-server
    state: present
    update_cache: yes

- name: MySQL root parolasını ayarla
  ansible.builtin.community.mysql.mysql_user:
    name: root
    password: "{{ mysql_root_password }}"
    host: localhost
    login_user: root
    login_password: "{{ mysql_root_password }}" # İlk çalıştırmada bu olmayacak, dikkat!
    state: present

- name: WordPress veritabanını oluştur
  ansible.builtin.community.mysql.mysql_db:
    name: "{{ wp_db_name }}"
    state: present

- name: WordPress veritabanı kullanıcısını oluştur ve yetkileri ver
  ansible.builtin.community.mysql.mysql_user:
    name: "{{ wp_db_user }}"
    password: "{{ wp_db_password }}"
    host: '%'
    priv: "{{ wp_db_name }}.*:ALL"
    state: present

Bu örneklerde, görevler arasında değişkenlerin nasıl kullanıldığına (php_version, wp_db_name vb.) ve notify anahtar kelimesiyle tetikleyicilerin (handlers) nasıl çağrıldığına dikkat edin. Örneğin, Nginx yapılandırma dosyası değiştiğinde Nginx servisi otomatik olarak yeniden başlatılır. Bu yapı, dağıtım sürecini hem otomatikleştirir hem de tutarlı hale getirir. Tüm bu rolleri ve playbook’u tamamladıktan sonra, tek bir komutla tüm WordPress uygulamanızı dağıtabilirsiniz:

ansible-playbook -i hosts site.yml

Bu vaka analizi, Ansible’ın karmaşık çok sunuculu uygulamaları dağıtma ve yapılandırma yeteneğini göstermektedir. Roller, kodunuzu modüler hale getirirken, değişkenler ve şablonlar dinamik ve esnek yapılandırmalar oluşturmanızı sağlar. Bu sayede, geliştiriciler ve sistem yöneticileri, altyapılarını “kod olarak altyapı” (Infrastructure as Code – IaC) prensiplerine uygun olarak yönetebilir, sürüm kontrol sistemleriyle entegre edebilir ve dağıtım süreçlerini hızlandırabilirler.

Mobil Uyumluluk ve Performans İpuçları: HTML Yapısını Optimize Etme

Web uygulamalarının ve içeriklerinin erişilebilirliği, günümüz dijital dünyasında kritik bir öneme sahiptir. Kullanıcıların büyük bir çoğunluğu internete mobil cihazlar üzerinden eriştiği için, oluşturduğumuz HTML içeriğinin mobil uyumlu ve performanslı olması vazgeçilmez bir gerekliliktir. Bu makalede doğrudan CSS veya JavaScript kodu sağlamasak da, temel HTML yapısını nasıl optimize edebileceğinizi ve mobil uyumluluğu destekleyen semantik elementleri nasıl kullanabileceğinizi açıklayabiliriz. Unutmayın ki, sağlam bir HTML yapısı, CSS medya sorgularının ve performans optimizasyonlarının etkili bir şekilde uygulanabilmesi için temel oluşturur.

Mobil uyumlu bir web sitesi oluşturmanın ilk adımı, HTML belgenizin başına doğru meta viewport etiketini eklemektir. Bu etiket, tarayıcıya sayfanın genişliğini cihazın ekran genişliğine göre ayarlamasını ve başlangıç yakınlaştırma seviyesini belirlemesini söyler. Bu etiket, içinde değil, içinde yer alsa da, mobil uyumluluğun temeli olduğu için burada bahsedilmesi önemlidir. İçerik oluştururken, HTML5’in sunduğu semantik etiketleri kullanmak, hem arama motorları için daha anlaşılır bir yapı sunar hem de ekran okuyucular gibi erişilebilirlik araçları için daha iyi bir deneyim sağlar. Örneğin, içeriğinizi <header>, <nav>, <main>, <article>, <section> ve <footer> gibi etiketlerle yapılandırmak, sayfanın farklı bölümlerini açıkça tanımlar.

Performans açısından, HTML yapısını sade ve temiz tutmak önemlidir. Gereksiz iç içe geçmiş div‘lerden kaçınmak, tarayıcının sayfayı daha hızlı işlemesine yardımcı olur. Resimler gibi medya öğeleri için <img> etiketini kullanırken, alt niteliğini her zaman doldurarak hem erişilebilirliği artırın hem de SEO’ya katkıda bulunun. Ayrıca, duyarlı resimler için <picture> etiketi veya srcset niteliği kullanarak, farklı ekran boyutlarına ve çözünürlüklere uygun resimlerin yüklenmesini sağlayabilirsiniz. Bu, mobil cihazlarda daha küçük boyutlu resimlerin yüklenerek bant genişliğinden tasarruf edilmesine ve sayfa yükleme süresinin iyileştirilmesine yardımcı olur.

Mobil uyumlu bir düzen için HTML içeriğinizi nasıl yapılandırabileceğinize dair kavramsal bir örnek aşağıdadır. Bu yapı, dış CSS stilleri ve medya sorguları ile kolayca hedef alınabilir:

<div class="responsive-container">
    <header class="site-header">
        <h2>Ansible Otomasyon Rehberi</h2>
        <nav class="main-navigation">
            <ul>
                <li><a href="#kurulum">Kurulum</a></li>
                <li><a href="#playbooklar">Playbooklar</a></li>
                <li><a href="#roller">Roller</a></li>
            </ul>
        </nav>
    </header>

    <main class="main-content">
        <section class="article-section" id="kurulum">
            <h3>Ansible Kurulum Adımları</h3>
            <p>Bu bölümde Ansible'ın Ubuntu üzerine nasıl kurulduğunu adım adım öğreneceksiniz.</p>
            <div class="code-block-wrapper">
                <pre><code>sudo apt install ansible</code></pre>
            </div>
        </section>

        <section class="article-section" id="vaka-analizi">
            <h3>Vaka Analizi: WordPress Dağıtımı</h3>
            <div class="card-grid">
                <div class="card">
                    <h4>Web Sunucusu</h4>
                    <p>Nginx ve PHP-FPM yapılandırması.</p>
                </div>
                <div class="card">
                    <h4>Veritabanı</h4>
                    <p>MySQL kurulumu ve veritabanı oluşturma.</p>
                </div>
            </div>
        </section>
    </main>

    <footer class="site-footer">
        <p>&copy; 2023 Ansible Rehberi.</p>
    </footer>
</div>

Yukarıdaki HTML yapısı, CSS medya sorguları kullanılarak farklı ekran boyutlarına göre kolayca adapte edilebilir. Örneğin, küçük ekranlarda main-navigation öğeleri dikey olarak istiflenebilirken, daha geniş ekranlarda yatay bir menü olarak görünebilir. card-grid sınıfına sahip bir div, küçük ekranlarda kartları alt alta gösterirken, büyük ekranlarda yan yana bir ızgara düzeni oluşturabilir. Performans için, script etiketlerini </body> kapanış etiketinden hemen önce yerleştirmek, sayfanın görsel içeriğinin daha hızlı yüklenmesini sağlar. Ayrıca, harici CSS ve JavaScript dosyalarını sıkıştırmak, gereksiz boşlukları ve yorumları kaldırmak da yükleme sürelerini iyileştiren önemli adımlardır. Bu temel HTML prensiplerine uymak, kullanıcı deneyimini iyileştiren ve arama motoru sıralamalarını olumlu etkileyen mobil uyumlu ve hızlı web içerikleri oluşturmanın ilk ve en önemli adımıdır.

Sonuç: Ansible ile Otomasyon Yolculuğunuz

Bu kapsamlı rehber boyunca, Ansible’ın temel kavramlarından başlayarak, Ubuntu üzerinde adım adım kurulumuna, envanter yönetimine, ilk playbook’larınızı oluşturmaya ve gelişmiş yapılandırmalar olan roller ve şablonların kullanımına kadar birçok önemli konuyu ele aldık. Ayrıca, çok sunuculu bir uygulama dağıtımını otomatikleştiren gerçek dünya vaka analizini inceleyerek Ansible’ın pratik uygulamalarını gördük. Ansible’ın aracısız mimarisi, basit YAML sözdizimi ve güçlü modül kütüphanesi sayesinde, IT operasyonlarınızı kolaylaştırmak ve verimliliği artırmak artık çok daha ulaşılabilir bir hedef haline geldi. Tekrarlayan manuel görevlerden kurtularak, sistem yöneticileri ve DevOps mühendisleri daha stratejik projelere odaklanabilir, altyapılarını “kod olarak altyapı” prensipleriyle yönetebilir ve dağıtım süreçlerini hızlandırabilirler.

Ansible ile otomasyon yolculuğunuz, bu rehberle başlamış olsa da, keşfedilecek daha birçok özellik ve yetenek bulunmaktadır. Modülleri derinlemesine incelemek, daha karmaşık playbook’lar yazmak, CI/CD boru hatlarına entegre etmek veya farklı bulut sağlayıcılarıyla çalışmak gibi konular, otomasyon becerilerinizi daha da ileriye taşıyacaktır. Ansible’ın sunduğu esneklik ve güç, her büyüklükteki organizasyonun altyapı yönetimini basitleştirmesine ve daha çevik hale gelmesine olanak tanır. Unutmayın, pratik yapmak ve farklı senaryolar üzerinde denemeler yapmak, Ansible’da ustalaşmanın anahtarıdır. Bu rehberin, otomasyon dünyasına girişinizde sağlam bir temel oluşturduğunu ve sizi daha ileriye taşımak için ilham verdiğini umuyoruz. Ansible ile altyapınızı yönetmek artık bir zevk haline gelecek!

Sıkça Sorulan Sorular

Ansible öğrenmek ne kadar sürer?

Ansible’ın temel prensiplerini ve basit playbook’ları öğrenmek genellikle birkaç gün sürer. YAML sözdizimi oldukça basittir. Ancak, ileri düzey konuları (roller, şablonlar, dinamik envanter, hata ayıklama) ve karmaşık senaryoları tam olarak kavramak için haftalar veya aylar süren pratik ve deneyim gerekebilir.

Ansible ile hangi işletim sistemlerini yönetebilirim?

Ansible, kontrol düğümü olarak Linux (Ubuntu, CentOS vb.) veya macOS üzerinde çalışır. Yönetilen düğümler olarak ise neredeyse tüm Linux dağıtımlarını, Windows sunucularını, Unix türevlerini (FreeBSD, OpenBSD), ağ cihazlarını ve bazı bulut platformlarını (AWS, Azure, GCP) yönetebilir.

Ansible ücretli mi?

Hayır, Ansible açık kaynaklı ve tamamen ücretsiz bir araçtır. Red Hat tarafından desteklenen Ansible Tower (şimdiki adı Red Hat Ansible Automation Platform) ise ücretli bir kurumsal üründür ve Ansible’a ek olarak web tabanlı arayüz, RBAC, iş akışı görselleştirme gibi özellikler sunar.

Ansible alternatifleri nelerdir?

Ansible’ın popüler alternatifleri arasında Puppet, Chef ve SaltStack bulunur. Her birinin kendine özgü avantajları ve mimarileri vardır. Örneğin, Puppet ve Chef ajan tabanlı çalışırken, SaltStack hem ajan tabanlı hem de ajanız (SSH ile) çalışabilir.

Ansible ile hata ayıklama nasıl yapılır?

Ansible’da hata ayıklama için çeşitli yöntemler bulunur. -vvv veya -vvvv gibi verbosity seviyelerini artırarak daha detaylı çıktı alabilirsiniz. --check (dry run) ve --diff (değişiklikleri göster) parametreleri, playbook’un ne yapacağını görmenize yardımcı olur. Ayrıca ansible.builtin.debug modülü ile değişkenlerin değerlerini kontrol edebilir veya failed_when ve changed_when gibi koşullarla görevlerin davranışını ince ayarlayabilirsiniz.