Ansible ile RKE2 ve Rancher Kurulumlarını Otomatize Etmek

Modern bulut altyapılarında Kubernetes kümelerinin yönetimi, özellikle büyük ölçekli ve dinamik ortamlar için oldukça karmaşık olabilir. RKE2 ve Rancher gibi güçlü araçlar bu süreci kolaylaştırsa da, kurulum ve yapılandırma adımlarının manuel olarak yapılması zaman alıcı ve hataya açık bir süreci beraberinde getirir. Peki, bu süreci Ansible’ın gücüyle nasıl otomatize edebiliriz? Bu makalede, RKE2 kümelerinin ve Rancher yönetim platformunun Ansible ile nasıl hızlı, tutarlı ve tekrarlanabilir bir şekilde dağıtılacağını adım adım inceleyeceğiz. Bu rehber sayesinde altyapınızı kod olarak yönetmenin (Infrastructure as Code) avantajlarını keşfedecek ve operasyonel verimliliğinizi artıracaksınız.

Günümüzün hızlı tempolu yazılım geliştirme dünyasında, uygulamaların hızla dağıtılması ve güncellenmesi bir zorunluluktur. Bu bağlamda, konteynerleştirme teknolojileri ve özellikle Kubernetes, vazgeçilmez bir hal almıştır. Ancak Kubernetes kümelerinin kurulumu ve yönetimi, özellikle birden fazla ortamda (geliştirme, test, üretim) tekrarlı işlemler gerektirdiğinde ciddi zorluklar doğurabilir. Örneğin, her bir sunucuda işletim sistemi güncellemelerini yapmak, gerekli bağımlılıkları yüklemek, sertifikaları ayarlamak ve Kubernetes bileşenlerini kurmak gibi adımlar, zaman alıcı ve hataya açık süreçlerdir.

Manuel dağıtımlar, genellikle “snowflaking” adı verilen duruma yol açar; yani her ortamın birbirinden farklı yapılandırmalara sahip olması ve bu durumun tutarsızlıkları beraberinde getirmesi. Bu durum, hata ayıklama süreçlerini uzatır, üretim ortamında beklenmedik sorunlara neden olabilir ve güvenlik açıklarının ortaya çıkma riskini artırır. Ayrıca, büyük ölçekli bir altyapıda yüzlerce sunucuyu manuel olarak yönetmek imkansıza yakındır. İşgücü maliyetleri artar, operasyonel yük çoğalır ve ekipler inovasyona odaklanmak yerine rutin görevlerle boğuşmak zorunda kalır.

İşte bu noktada otomasyon devreye girer. Otomasyon, tekrarlayan görevleri makinelere devrederek insan hatasını minimuma indirir, dağıtım sürelerini kısaltır ve ortamlar arası tutarlılığı garanti eder. RKE2 (Rancher Kubernetes Engine 2) gibi hafif ve güvenli bir Kubernetes dağıtımı ile Rancher gibi çoklu küme yönetim platformunu bir araya getirmek, modern bir bulut stratejisinin temelini oluşturur. Ancak bu araçların gücünden tam anlamıyla faydalanabilmek için kurulum ve yapılandırma süreçlerinin otomatize edilmesi şarttır. Ansible, bu otomasyonu sağlamak için mükemmel bir araçtır. Agent-less mimarisi, basit YAML tabanlı playbooks yapısı ve geniş modül desteği sayesinde, RKE2 ve Rancher dağıtımlarını verimli bir şekilde yönetebiliriz. Böylece, geliştiriciler ve operasyon ekipleri daha hızlı, daha güvenilir ve daha yönetilebilir bir altyapıya sahip olurlar. Bu, aynı zamanda DevOps prensiplerinin temelini oluşturan sürekli entegrasyon ve sürekli teslimat (CI/CD) süreçlerinin de önemli bir parçasıdır.

RKE2, Rancher ve Ansible: Temel Taşları Anlamak

Otomasyon yolculuğumuza başlamadan önce, projemizin temel yapı taşları olan RKE2, Rancher ve Ansible’ı derinlemesine anlamak önemlidir. Bu üç teknoloji, modern konteyner orkestrasyonu ve altyapı yönetimi ekosisteminde kritik roller üstlenir.

RKE2 Nedir ve Neden Tercih Edilir?

RKE2 (Rancher Kubernetes Engine 2), Rancher Labs tarafından geliştirilen, CNCF sertifikalı, hafif ve güvenli bir Kubernetes dağıtımıdır. K3s’in güvenlik odaklı, kurumsal sürümü olarak da düşünülebilir. RKE2, özellikle güvenlik ve uyumluluk konularında hassas olan işletmeler için tasarlanmıştır. Temel özellikleri şunlardır:

• Güvenlik Odaklı: RKE2, FIPS 140-2 uyumluluğu, CIS (Center for Internet Security) Benchmark hardening ve otomatik sertifika yönetimi gibi güvenlik özellikleriyle öne çıkar. Bu, kümelerinizin endüstri standartlarına uygun ve daha az güvenlik açığına sahip olmasını sağlar.
• Hafif ve Hızlı: Minimal bağımlılıklarla tasarlanmıştır. Bu, kaynak tüketimini azaltır ve daha hızlı başlangıç süreleri sunar.
• Tek Bir İkili Dosya: Tüm Kubernetes bileşenlerini tek bir ikili dosya içinde sunar. Bu, kurulumu ve güncellemeyi oldukça basitleştirir.
• Yüksek Erişilebilirlik (HA): Etcd yerine PostgreSQL veya MySQL gibi harici veri tabanlarını veya dahili SQLite’ı destekleyerek daha esnek bir HA mimarisi sunar.

RKE2, özellikle kenar bilişim (edge computing) senaryolarından veri merkezi dağıtımlarına kadar geniş bir kullanım alanına sahiptir. Güvenli ve stabil bir Kubernetes altyapısı kurmak isteyenler için ideal bir tercihtir.

Rancher: Küme Yönetiminde Yeni Nesil Bir Yaklaşım

Rancher, çoklu Kubernetes küme yönetimi için tasarlanmış kapsamlı bir platformdur. Farklı lokasyonlarda veya farklı sağlayıcılarda çalışan (on-premise, bulut) Kubernetes kümelerini tek bir merkezi arayüzden yönetmenizi sağlar. Rancher’ın temel avantajları şunlardır:

• Merkezi Yönetim: Tek bir Rancher UI üzerinden tüm Kubernetes kümelerinizi (RKE2, K3s, EKS, AKS, GKE vb.) görüntüleyebilir, yapılandırabilir ve yönetebilirsiniz.
• Kullanıcı ve Rol Yönetimi: Kullanıcılara ve ekiplere kümelere erişim yetkileri atayabilir, böylece güvenli ve denetlenebilir bir ortam sağlayabilirsiniz.
• Uygulama Kataloğu: Helm grafikleri aracılığıyla uygulamaları kolayca dağıtabilir ve yönetebilirsiniz.
• İzleme ve Günlükleme: Kümelerin sağlık durumunu izlemek ve performans metriklerini görüntülemek için entegre araçlar sunar.
• Sertifika Yönetimi: Let’s Encrypt gibi hizmetlerle entegrasyonu sayesinde otomatik sertifika yönetimi sağlar.

Rancher, Kubernetes’in karmaşıklığını soyutlayarak geliştiricilerin ve operasyon ekiplerinin daha verimli çalışmasına olanak tanır. Çok sayıda kümenin bulunduğu ortamlarda operasyonel yükü önemli ölçüde azaltır.

Ansible: Altyapı Otomasyonunun Kalbi

Ansible, Red Hat tarafından geliştirilen açık kaynaklı bir BT otomasyon aracıdır. Temel amacı, sunucu sağlama, yapılandırma yönetimi, uygulama dağıtımı ve sürekli dağıtım gibi görevleri otomatize etmektir. Ansible’ı diğer otomasyon araçlarından ayıran bazı temel özellikler:

• Agent-less Mimarisi: Yönetilen hedeflerde herhangi bir aracı (agent) yazılımına ihtiyaç duymaz. Sadece SSH protokolü üzerinden iletişim kurar. Bu, kurulum ve bakım maliyetlerini önemli ölçüde azaltır.
• YAML Tabanlı Playbooklar: Otomasyon görevleri, insan tarafından kolayca okunabilen ve anlaşılabilen YAML formatındaki playbooklar aracılığıyla tanımlanır. Bu, öğrenme eğrisini düşürür.
• Idempotency (Tekrarlanabilirlik): Playbooklar, aynı işlemi birden çok kez çalıştırsanız bile sistemin istenen duruma gelmesini sağlar ve bu durumu korur. Örneğin, bir paketin zaten yüklü olup olmadığını kontrol eder ve sadece gerekli ise yükleme yapar.
• Modüler Yapı: Binlerce hazır modül (paket yönetimi, dosya işlemleri, servis yönetimi, bulut entegrasyonları vb.) sayesinde neredeyse her türlü görevi otomatize edebilir.

Ansible’ın bu özellikleri, RKE2 ve Rancher gibi karmaşık sistemlerin kurulumunu ve yapılandırmasını otomatize etmek için ideal bir aday haline getirir. Tutarlı, hızlı ve hatasız dağıtımlar sağlamak için Ansible’ın gücünden faydalanacağız. Bu üç teknolojinin uyumlu bir şekilde çalışması, güçlü, esnek ve yönetilebilir bir konteyner altyapısı oluşturmamızı sağlayacaktır.

Ansible Altyapısı ve Başlangıç Ayarları Nasıl Yapılır?

Ansible ile otomasyon sürecine başlamadan önce, Ansible kontrol makinemizi hazırlamamız ve temel yapılandırmaları yapmamız gerekmektedir. Bu adım, tüm otomasyon operasyonlarımızın temelini oluşturacaktır. Düzgün bir başlangıç yapılandırması, ilerleyen adımlarda yaşanabilecek olası sorunları minimize eder ve sürecin sorunsuz ilerlemesini sağlar.

Ansible Kontrol Makinesi ve Gerekli Bileşenler

Ansible, genellikle Linux tabanlı bir sunucu üzerinde çalıştırılır. Bu sunucuya “kontrol makinesi” denir. Kontrol makinesinin, hedef sunuculara SSH üzerinden bağlanabilmesi için gerekli ayarlamaların yapılmış olması şarttır. İlk olarak, kontrol makinesine Ansible’ı yüklememiz gerekir. Çoğu Linux dağıtımında bu işlem oldukça basittir:

# Ubuntu/Debian tabanlı sistemler için
sudo apt update
sudo apt install ansible

# CentOS/RHEL tabanlı sistemler için
sudo yum install epel-release
sudo yum install ansible

Ansible yüklendikten sonra, hedef sunucularımıza SSH anahtar çiftleri ile parola girmeden erişim sağlayabilmemiz önemlidir. Bu, otomasyonun kesintisiz çalışması için elzemdir. Kontrol makinenizde bir SSH anahtar çifti oluşturun ve genel anahtarı (public key) tüm hedef sunucularınızdaki /home/kullanici_adi/.ssh/authorized_keys dosyasına ekleyin.

# SSH anahtar çifti oluşturma (eğer yoksa)
ssh-keygen -t rsa -b 4096

# Genel anahtarı hedef sunucuya kopyalama (kullanici_adi ve hedef_ip'yi değiştirin)
ssh-copy-id kullanici_adi@hedef_ip

Bu adımları tamamladıktan sonra, kontrol makinenizden hedef sunucularınıza parola sormadan SSH bağlantısı kurabildiğinizden emin olun.

Ansible Envanteri (Inventory) Oluşturma

Ansible, hangi sunucularda işlem yapacağını bir envanter dosyası aracılığıyla bilir. Bu dosya genellikle inventory.ini olarak adlandırılır ve sunucularınızı gruplandırmanıza olanak tanır. RKE2 ve Rancher dağıtımlarımız için aşağıdaki gibi bir yapıya sahip olabiliriz:

[rke2_servers]
server1 ansible_host=192.168.1.101
server2 ansible_host=192.168.1.102
server3 ansible_host=192.168.1.103

[rke2_agents]
agent1 ansible_host=192.168.1.104
agent2 ansible_host=192.168.1.105

[rancher_server]
rancher_node ansible_host=192.168.1.101 # Genellikle bir RKE2 sunucu düğümüne kurulur

Bu örnekte:

• [rke2_servers] grubu RKE2 kontrol düzlemi düğümlerini içerir.
• [rke2_agents] grubu RKE2 worker düğümlerini içerir.
• [rancher_server] grubu Rancher yönetim sunucusunun kurulacağı düğümü belirtir.

Her bir ana bilgisayar için ansible_host parametresi ile IP adresini veya hostname'i belirtebilirsiniz. Ayrıca, ansible_user, ansible_ssh_private_key_file gibi diğer parametreleri de ekleyebilirsiniz. Bu, Ansible'ın farklı sunuculara farklı kimlik bilgileriyle bağlanmasını sağlar.

Ansible Yapılandırma Dosyası (ansible.cfg)

Ansible'ın davranışını özelleştirmek için bir ansible.cfg dosyası oluşturabiliriz. Bu dosya, varsayılan envanter dosyasının yolunu, SSH bağlantı ayarlarını ve diğer birçok parametreyi belirlememize olanak tanır. Genellikle, projenizin kök dizininde veya kontrol makinesinin ana dizininde bulunur.

[defaults]
inventory = inventory.ini       # Varsayılan envanter dosyası
remote_user = ubuntu           # Hedef sunucularda kullanılacak kullanıcı adı
private_key_file = ~/.ssh/id_rsa # SSH özel anahtarının yolu
host_key_checking = False      # İlk bağlantıda host anahtarı kontrolünü devre dışı bırakır (güvenlik riski taşıyabilir, dikkatli kullanın)
forks = 5                     # Aynı anda kaç adet görevin çalışacağını belirler

host_key_checking = False ayarı, özellikle yeni ortamlar kurulurken veya sık sık sanal makineler oluşturup yok edildiğinde kullanışlı olabilir ancak üretim ortamlarında güvenlik nedeniyle True olarak bırakılması veya bilinen ana bilgisayarları ~/.ssh/known_hosts dosyasına eklemek daha güvenlidir. Bu temel yapılandırmalarla, Ansible ortamımız RKE2 ve Rancher dağıtımlarını otomatize etmek için hazır hale gelmiş olacaktır. Artık playbooklarımızı yazmaya başlayabiliriz.

Sıfırdan RKE2 Kümesi Kurulumu: Ansible Playbookları ile Adım Adım Rehber

RKE2 kümesi kurulumu, manuel olarak yapıldığında karmaşık ve hataya açık olabilir. Ancak Ansible ile bu süreç, tekrarlanabilir, tutarlı ve oldukça hızlı bir hale gelir. Bu bölümde, RKE2 sunucu (kontrol düzlemi) ve agent (worker) düğümlerini Ansible playbookları aracılığıyla nasıl kuracağımızı adım adım ele alacağız.

RKE2 Sunucu Düğümlerinin Kurulumu

RKE2 sunucu düğümleri, Kubernetes kontrol düzlemini barındırır ve Etcd veya harici bir veri tabanı ile kümenin durumunu yönetir. Yüksek erişilebilirlik için genellikle en az üç sunucu düğümü kurulur. İlk olarak, RKE2 ikili dosyasını indirmeli, gerekli servisleri yapılandırmalı ve başlatmalıyız. İşte bu adımları içeren bir Ansible playbook örneği:

---
- name: RKE2 Server Düğümlerini Kur
  hosts: rke2_servers
  become: yes
  vars:
    rke2_version: "v1.28.6+rke2r1" # Kurulacak RKE2 sürümü
    cluster_cidr: "10.42.0.0/16"
    service_cidr: "10.43.0.0/16"
    token: "my_rke2_shared_secret_token" # Güvenli bir token belirleyin

  tasks:
    - name: Gerekli Paketleri Yükle
      ansible.builtin.apt:
        name:
          - curl
          - containerd
        state: present
        update_cache: yes

    - name: RKE2 İkili Dosyasını İndir
      ansible.builtin.get_url:
        url: "https://github.com/rancher/rke2/releases/download/{{ rke2_version }}/rke2.linux-amd64.tar.gz"
        dest: "/tmp/rke2.linux-amd64.tar.gz"
        mode: '0644'

    - name: RKE2 İkili Dosyalarını Çıkar
      ansible.builtin.unarchive:
        src: "/tmp/rke2.linux-amd64.tar.gz"
        dest: "/usr/local/bin/"
        remote_src: yes
        owner: root
        group: root
        mode: '0755'

    - name: RKE2 Sembolik Bağlantıları Oluştur
      ansible.builtin.file:
        src: "/usr/local/bin/rke2"
        dest: "/usr/local/bin/kubectl"
        state: link
        force: yes

    - name: RKE2 Servis Dizinini Oluştur
      ansible.builtin.file:
        path: "/etc/rancher/rke2"
        state: directory
        mode: '0755'

    - name: RKE2 Server Yapılandırma Dosyasını Oluştur (İlk Sunucu)
      ansible.builtin.copy:
        content: |
          token: "{{ token }}"
          tls-san:
            - {{ hostvars[inventory_hostname]['ansible_host'] }}
            - rancher.domain.com # Rancher erişimi için alternatif bir domain
          cluster-cidr: "{{ cluster_cidr }}"
          service-cidr: "{{ service_cidr }}"
          # Yüksek erişilebilirlik için diğer sunucuların IP'lerini ekleyin
          # server: https://server1_ip:9345
          # server: https://server2_ip:9345
        dest: "/etc/rancher/rke2/config.yaml"
        mode: '0644'
      when: inventory_hostname == 'server1' # Yalnızca ilk sunucu için başlangıç yapılandırması

    - name: RKE2 Server Yapılandırma Dosyasını Oluştur (Diğer Sunucular için HA)
      ansible.builtin.copy:
        content: |
          token: "{{ token }}"
          tls-san:
            - {{ hostvars[inventory_hostname]['ansible_host'] }}
            - rancher.domain.com
          server: https://{{ hostvars['server1']['ansible_host'] }}:9345 # İlk sunucuya bağlanın
          cluster-cidr: "{{ cluster_cidr }}"
          service-cidr: "{{ service_cidr }}"
        dest: "/etc/rancher/rke2/config.yaml"
        mode: '0644'
      when: inventory_hostname != 'server1' # İlk sunucu dışındaki diğer sunucular için

    - name: RKE2 Servisini Etkinleştir ve Başlat
      ansible.builtin.systemd:
        name: rke2-server
        enabled: yes
        state: started

    - name: Kubeconfig Dosyasını Kopyala (kontrol makinesine)
      ansible.builtin.fetch:
        src: "/etc/rancher/rke2/rke2.yaml"
        dest: "./kubeconfig/{{ inventory_hostname }}-kubeconfig.yaml"
        flat: yes
      delegate_to: localhost
      run_once: true # Yalnızca bir sunucudan çekilmesi yeterli

    - name: Kubeconfig Dosyasındaki Adresi Düzelt
      ansible.builtin.lineinfile:
        path: "./kubeconfig/{{ inventory_hostname }}-kubeconfig.yaml"
        regexp: 'https://127.0.0.1:6443'
        line: "    server: https://{{ hostvars['server1']['ansible_host'] }}:6443"
        state: present
      delegate_to: localhost
      run_once: true

    - name: Kubeconfig Ortam Değişkenini Ayarla
      ansible.builtin.lineinfile:
        path: "~/.bashrc"
        line: "export KUBECONFIG=~/kubeconfig/server1-kubeconfig.yaml"
        state: present
      delegate_to: localhost
      run_once: true

  

Bu playbook, RKE2 ikili dosyalarını indirir, gerekli yapılandırmaları yapar ve RKE2 servislerini başlatır. Ayrıca, kümenizi yönetmek için kullanacağınız kubeconfig dosyasını kontrol makinenize çeker ve gerekli düzenlemeleri yapar. token değişkeni, tüm RKE2 düğümlerinin aynı kümeye katılması için kritik öneme sahiptir.

RKE2 Agent Düğümlerinin Kurulumu

Agent düğümleri, uygulamalarınızın çalıştığı iş yüklerini barındırır. Bu düğümler, sunucu düğümlerinin sağladığı kontrol düzlemine bağlanır. Agent düğümlerinin kurulumu, sunucu düğümlerine kıyasla daha basittir:

---
- name: RKE2 Agent Düğümlerini Kur
  hosts: rke2_agents
  become: yes
  vars:
    rke2_version: "v1.28.6+rke2r1"
    token: "my_rke2_shared_secret_token" # Sunucu tokenı ile aynı olmalı
    server_ip: "{{ hostvars['server1']['ansible_host'] }}" # İlk RKE2 sunucusunun IP'si

  tasks:
    - name: Gerekli Paketleri Yükle
      ansible.builtin.apt:
        name:
          - curl
          - containerd
        state: present
        update_cache: yes

    - name: RKE2 İkili Dosyasını İndir
      ansible.builtin.get_url:
        url: "https://github.com/rancher/rke2/releases/download/{{ rke2_version }}/rke2.linux-amd64.tar.gz"
        dest: "/tmp/rke2.linux-amd64.tar.gz"
        mode: '0644'

    - name: RKE2 İkili Dosyalarını Çıkar
      ansible.builtin.unarchive:
        src: "/tmp/rke2.linux-amd64.tar.gz"
        dest: "/usr/local/bin/"
        remote_src: yes
        owner: root
        group: root
        mode: '0755'

    - name: RKE2 Servis Dizinini Oluştur
      ansible.builtin.file:
        path: "/etc/rancher/rke2"
        state: directory
        mode: '0755'

    - name: RKE2 Agent Yapılandırma Dosyasını Oluştur
      ansible.builtin.copy:
        content: |
          server: https://{{ server_ip }}:9345
          token: "{{ token }}"
          # agent-labels:
          #   - "disk=ssd"
        dest: "/etc/rancher/rke2/config.yaml"
        mode: '0644'

    - name: RKE2 Agent Servisini Etkinleştir ve Başlat
      ansible.builtin.systemd:
        name: rke2-agent
        enabled: yes
        state: started
  

Bu playbook, agent düğümlerinde RKE2'yi kurar ve onları belirtilen RKE2 sunucu düğümüne bağlar. token ve server_ip değişkenlerinin doğru ayarlandığından emin olun. Bu iki playbook'u sırasıyla çalıştırdığınızda (önce sunucular, sonra agent'lar), tam teşekküllü bir RKE2 kümeniz hazır olacaktır. Kurulumun ardından, kubectl get nodes komutu ile düğümlerinizin durumunu kontrol edebilirsiniz.

Vaka Analizi: Büyük Ölçekli Bir Dağıtım Senaryosu

Bir e-ticaret şirketi olan "CloudMart", geliştirme, test ve üretim ortamları için üç ayrı RKE2 kümesi kurmak istiyordu. Her ortamın en az 3 sunucu ve 5 agent düğümüne sahip olması gerekiyordu. Manuel kurulumlar, her küme için yaklaşık 2 gün sürüyordu ve sık sık tutarsızlıklar yaşanıyordu. Ansible kullanarak, tüm bu kümelerin kurulumu ve temel yapılandırmaları için sadece 4 saatlik bir playbook geliştirildi. Bu playbook, tüm ortamları saniyeler içinde baştan sona kurabiliyor, hata oranını sıfıra indiriyor ve ortamlar arası tam tutarlılığı sağlıyordu. Operasyonel verimlilikte %95'in üzerinde bir artış gözlendi ve ekipler, altyapı kurulumu yerine iş değeri yaratan projelere odaklanabildi. Bu vaka analizi, otomasyonun büyük ölçekli altyapılardaki kritik rolünü açıkça göstermektedir.

Rancher Kurulumu ve Küme Yönetimi: RKE2 Üzerine Yerleştirmek ve Entegrasyon Nasıl Yapılır?

RKE2 kümemiz hazır olduğuna göre, şimdi sıra Rancher yönetim platformunu bu küme üzerine kurmaya ve RKE2 kümelerimizi merkezi olarak yönetmeye geldi. Rancher'ı bir Kubernetes kümesi üzerine kurmak için Helm'i kullanacağız. Dolayısıyla, Rancher kurulumuna başlamadan önce Helm ve sertifika yönetimi için cert-manager'ın kurulu olması gerekmektedir. Bu bölüm, bu adımları Ansible ile nasıl otomatize edeceğimizi açıklayacaktır.

Helm ve Cert-Manager Kurulumu

Rancher, Kubernetes'e Helm Chart'ları aracılığıyla dağıtılır. Ayrıca, Rancher'ın HTTPS üzerinden güvenli bir şekilde erişilebilir olması için sertifika yönetimi kritik öneme sahiptir. cert-manager, Kubernetes içindeki sertifika yaşam döngüsünü otomatize eden popüler bir araçtır. Bu bileşenleri kurmak için aşağıdaki playbook'u kullanabiliriz. Bu playbook'u genellikle Rancher'ın kurulacağı RKE2 sunucu düğümlerinden birine veya tüm sunuculara çalıştırmak iyi bir yaklaşımdır, ancak delegate_to: localhost kullanarak kontrol makinesinden de Kubernetes API'sine erişim sağlayabiliriz.

---
- name: Helm ve Cert-Manager'ı Kur
  hosts: rancher_node # Rancher'ın kurulacağı RKE2 sunucu düğümü
  become: yes
  vars:
    kubeconfig_path: "~/kubeconfig/server1-kubeconfig.yaml" # Kontrol makinesindeki kubeconfig yolu

  tasks:
    - name: Helm'i Kur (Kontrol Makinesine)
      ansible.builtin.shell: |
        curl -fsSL https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
      args:
        creates: /usr/local/bin/helm
      delegate_to: localhost
      run_once: true

    - name: Cert-Manager Helm Repo'sunu Ekle
      ansible.builtin.shell: |
        helm repo add jetstack https://charts.jetstack.io
        helm repo update
      environment:
        KUBECONFIG: "{{ kubeconfig_path }}"
      delegate_to: localhost
      run_once: true

    - name: Cert-Manager Namespace'i Oluştur
      ansible.builtin.command: kubectl create namespace cert-manager
      environment:
        KUBECONFIG: "{{ kubeconfig_path }}"
      ignore_errors: yes # Namespace zaten varsa hata vermesini engelle
      delegate_to: localhost
      run_once: true

    - name: Cert-Manager'ı Yükle
      ansible.builtin.shell: |
        helm install \
          cert-manager jetstack/cert-manager \
          --namespace cert-manager \
          --version v1.13.2 \
          --set installCRDs=true
      environment:
        KUBECONFIG: "{{ kubeconfig_path }}"
      delegate_to: localhost
      run_once: true

    - name: Cert-Manager Pod'larının Hazır Olmasını Bekle
      ansible.builtin.command: kubectl wait --namespace cert-manager --for=condition=ready pod --selector=app.kubernetes.io/instance=cert-manager --timeout=300s
      environment:
        KUBECONFIG: "{{ kubeconfig_path }}"
      delegate_to: localhost
      run_once: true
  

Bu playbook, Helm'i kontrol makinesine kurar, cert-manager Helm deposunu ekler, cert-manager için bir namespace oluşturur ve ardından cert-manager'ı kurar. KUBECONFIG ortam değişkenini ayarlayarak kubectl ve helm komutlarının doğru kümeye bağlanmasını sağlıyoruz.

Rancher Yöneticisinin Kurulumu

Helm ve Cert-Manager hazır olduğunda, Rancher'ı yüklemeye geçebiliriz. Rancher'ı kurarken HTTPS için bir hostname belirtmek ve bir Ingress Controller kullanmak önemlidir. RKE2 varsayılan olarak Traefik'i bir Ingress Controller olarak içerir, bu yüzden genellikle ekstra bir kuruluma ihtiyaç duyulmaz.

---
- name: Rancher Yöneticisini Kur
  hosts: rancher_node # Rancher'ın kurulacağı RKE2 sunucu düğümü
  become: yes
  vars:
    kubeconfig_path: "~/kubeconfig/server1-kubeconfig.yaml"
    rancher_hostname: "rancher.domain.com" # Rancher erişim URL'si
    rancher_version: "2.7.9" # Kurulacak Rancher sürümü

  tasks:
    - name: Rancher Helm Repo'sunu Ekle
      ansible.builtin.shell: |
        helm repo add rancher-stable https://releases.rancher.com/server-charts/stable
        helm repo update
      environment:
        KUBECONFIG: "{{ kubeconfig_path }}"
      delegate_to: localhost
      run_once: true

    - name: Rancher Namespace'i Oluştur
      ansible.builtin.command: kubectl create namespace cattle-system
      environment:
        KUBECONFIG: "{{ kubeconfig_path }}"
      ignore_errors: yes
      delegate_to: localhost
      run_once: true

    - name: Rancher'ı Yükle
      ansible.builtin.shell: |
        helm install rancher rancher-stable/rancher \
          --namespace cattle-system \
          --set hostname={{ rancher_hostname }} \
          --set bootstrapPassword=rancheradmin \
          --set ingress.tls.source=cert-manager \
          --set certmanager.version=v1.13.2 \
          --version {{ rancher_version }}
      environment:
        KUBECONFIG: "{{ kubeconfig_path }}"
      delegate_to: localhost
      run_once: true

    - name: Rancher Pod'larının Hazır Olmasını Bekle
      ansible.builtin.command: kubectl wait --namespace cattle-system --for=condition=ready pod --selector=app=rancher --timeout=600s
      environment:
        KUBECONFIG: "{{ kubeconfig_path }}"
      delegate_to: localhost
      run_once: true

    - name: Rancher URL'sini Bildir
      ansible.builtin.debug:
        msg: "Rancher başarıyla kuruldu ve {{ rancher_hostname }} adresinden erişilebilir durumda."
      delegate_to: localhost
      run_once: true
  

Bu playbook, Rancher Helm deposunu ekler, cattle-system namespace'ini oluşturur ve Rancher'ı Helm aracılığıyla yükler. hostname parametresi, Rancher'a erişeceğiniz alan adını belirtir. bootstrapPassword ile ilk giriş için bir parola belirleyebiliriz, ancak bunu Rancher UI üzerinden giriş yaptıktan sonra değiştirmek önemlidir. Rancher, cert-manager ile entegre olduğundan, otomatik olarak SSL sertifikalarını yönetecek ve Rancher arayüzüne güvenli erişim sağlayacaktır.

RKE2 Kümesini Rancher'a Entegre Etme

Rancher kurulduktan sonra, yönetim paneline erişip ilk kümenizi ekleyebilirsiniz. Bu işlemi de kısmen Ansible ile otomatize etmek mümkündür, ancak genellikle ilk kurulum manuel bir etkileşim gerektirebilir veya Rancher API'si üzerinden yapılabilir. Rancher UI üzerinden, "Import Existing" seçeneğini kullanarak RKE2 kümenizi kolayca ekleyebilirsiniz. Rancher size bir kubectl apply -f ... komutu verecektir. Bu komutu, kontrol makinenizden veya RKE2 kümenizdeki herhangi bir sunucu üzerinden çalıştırarak RKE2 kümenizi Rancher'a kaydedebilirsiniz. Bu sayede, RKE2 kümeniz artık Rancher'ın merkezi yönetiminden izlenebilir ve yönetilebilir hale gelir. Bu otomasyon adımları sayesinde, hem RKE2 kümesini hem de Rancher yönetimini hızlı ve hatasız bir şekilde kurarak operasyonel süreçlerinizi önemli ölçüde hızlandırabilirsiniz.

Gelişmiş Konfigürasyonlar ve En İyi Uygulamalar: Otomasyonu Bir Üst Seviyeye Taşıyın

RKE2 ve Rancher kurulumlarının temel otomasyonunu gerçekleştirdikten sonra, daha karmaşık senaryoları ele almak ve operasyonel güvenliği ve verimliliği artırmak için ileri düzey Ansible tekniklerini ve en iyi uygulamaları keşfetmek önemlidir. Bu bölüm, otomasyon süreçlerinizi bir üst seviyeye taşıyacak ipuçlarını ve yöntemleri sunmaktadır.

Ansible Vault ile Hassas Veri Yönetimi

Otomasyon betikleri genellikle API anahtarları, parolalar, özel anahtarlar gibi hassas bilgiler içerir. Bu tür verileri playbook'larda açık metin olarak tutmak ciddi bir güvenlik riskidir. Ansible Vault, hassas verileri şifrelemek ve güvenli bir şekilde yönetmek için tasarlanmıştır. Vault kullanmak, güvenlik ilkelerine uyumu sağlar ve yetkisiz erişimi engeller.

# Yeni bir şifreli dosya oluşturma
ansible-vault create vars/secret_vars.yml

# Mevcut bir dosyayı düzenleme
ansible-vault edit vars/secret_vars.yml

# Şifreli bir dosyayı görüntüleme
ansible-vault view vars/secret_vars.yml

Şifreli dosyanızda şu tür bilgiler saklayabilirsiniz:

# vars/secret_vars.yml (şifreli)
rke2_token: "super_secret_rke2_token_123"
rancher_bootstrap_password: "MySecureRancherPass"

Playbook'unuzda bu değişkenleri diğer değişkenler gibi kullanabilirsiniz. Playbook'u çalıştırırken Ansible, Vault parolasını isteyecek veya --vault-password-file argümanı ile parolayı sağlayabilirsiniz:

ansible-playbook rke2_install.yml --ask-vault-pass
# veya
ansible-playbook rke2_install.yml --vault-password-file ~/.ansible_vault_pass

Ansible Rolleri ile Modülerlik

Büyük ve karmaşık projelerde, tüm görevleri tek bir playbook içinde tutmak yönetimi zorlaştırabilir. Ansible Rolleri, görevleri, şablonları, değişkenleri ve işleyicileri mantıksal bir yapı altında gruplayarak otomasyonunuzu modüler hale getirir. Her rol, belirli bir işlevi (örneğin, "rke2-server", "rke2-agent", "rancher-install") yerine getirir. Bu, kod tekrarını azaltır, okunabilirliği artırır ve bakımı kolaylaştırır.

# Rol dizini yapısı örneği
roles/
├── rke2-server/
│   ├── tasks/
│   │   └── main.yml
│   ├── vars/
│   │   └── main.yml
│   └── templates/
├── rke2-agent/
│   ├── tasks/
│   │   └── main.yml
│   └── vars/
│       └── main.yml
└── rancher-install/
    ├── tasks/
    │   └── main.yml
    └── vars/
        └── main.yml

Ana playbook'unuzda rolleri şu şekilde çağırabilirsiniz:

---
- name: RKE2 ve Rancher Dağıtımı
  hosts: all
  become: yes

  roles:
    - role: rke2-server
      when: inventory_hostname in groups['rke2_servers']
    - role: rke2-agent
      when: inventory_hostname in groups['rke2_agents']
    - role: rancher-install
      when: inventory_hostname in groups['rancher_node']
  

Bu yapı, farklı ortamlar veya farklı küme tipleri için playbook'ları kolayca yeniden kullanmanıza olanak tanır.

Hata Yönetimi ve Idempotency (Tekrarlanabilirlik) Prensipleri

Ansible'ın temel güçlerinden biri idempotency'dir. Bir playbook'u defalarca çalıştırsanız bile sistemin istenen duruma gelmesini ve bu durumu korumasını sağlar. Bu, özellikle güncellemeler veya beklenmedik durumlar sonrasında sistemleri hızlıca kurtarmak için hayati öneme sahiptir. Playbook'larınızı yazarken her görevin idempotent olduğundan emin olun. Örneğin, bir paketi yüklerken, state: present kullanmak, paketin zaten yüklü olup olmadığını kontrol eder ve yalnızca yüklü değilse işlemi gerçekleştirir.

Hata yönetimi için ise ignore_errors veya block/rescue/always yapılarını kullanabilirsiniz. Örneğin, bir servis yeniden başlatılırken kısa süreli bir kesinti tolere edilebilirse ignore_errors: yes kullanabilirsiniz. Ancak kritik durumlarda, block ile bir dizi görevi sarmalayıp, rescue bloğunda kurtarma adımlarını tanımlayabilirsiniz.

    - name: Servisi Yeniden Başlat (Hata olursa devam et)
      ansible.builtin.systemd:
        name: my-service
        state: restarted
      ignore_errors: true # Hata olsa bile playbook çalışmaya devam eder
  

@media (max-width: 768px) {
      .sidebar {
        display: none;
      }
      .main-content {
        width: 100%;
      }
    }

Monitoring ve Logging Entegrasyonu (Kısaca)

RKE2 ve Rancher kümelerinizin sağlıklı çalıştığından emin olmak için izleme ve günlükleme çözümlerinin entegrasyonu kritik öneme sahiptir. Ansible, Prometheus, Grafana, ELK Stack (Elasticsearch, Logstash, Kibana) veya Loki gibi araçları kümelerinize dağıtmak için kullanılabilir. Playbook'lar aracılığıyla Helm grafikleri ile bu araçları kolayca kurabilir ve yapılandırabilirsiniz. Bu sayede, küme kaynaklarının kullanımını, uygulama performansını ve olası sorunları proaktif olarak tespit edebilirsiniz.

Örneğin, bir Prometheus ve Grafana kurulumu için ayrı bir Ansible rolü oluşturabilir ve bunu Rancher kurulumunuzdan sonra çalıştırabilirsiniz. Bu, uçtan uca otomasyon stratejinizin ayrılmaz bir parçası olmalıdır.

Bu ileri düzey teknikler, otomasyon projelerinizin ölçeklenebilirliğini, güvenliğini ve bakım kolaylığını önemli ölçüde artıracaktır. Ansible'ın esnekliği sayesinde, karmaşık altyapı dağıtımlarını bile basit, okunabilir ve yönetilebilir adımlara bölebilirsiniz.

Otomasyonun Gücü: RKE2 ve Rancher Yönetiminde Yeni Bir Dönem

Bu makale boyunca, RKE2 kümelerinin ve Rancher yönetim platformunun Ansible ile nasıl otomatize edileceğini ayrıntılı bir şekilde inceledik. Gerek temel kurulum adımları gerekse ileri düzey yapılandırma teknikleri ile operasyonel süreçlerinizi dönüştürmenin yollarını keşfettik. Manuel müdahalelerin getirdiği zorlukları aşarak, hızlı, tutarlı ve güvenilir altyapı dağıtımlarının kapısını araladık.

Otomasyon, günümüzün dinamik ve rekabetçi BT ortamında artık bir lüks değil, bir zorunluluktur. Ansible gibi güçlü bir araçla RKE2 ve Rancher entegrasyonu, şirketlerin DevOps hedeflerine ulaşmasında, ürünlerini pazara daha hızlı sunmasında ve operasyonel maliyetlerini düşürmesinde kritik bir rol oynamaktadır. Altyapıyı kod olarak yönetme (Infrastructure as Code - IaC) prensibini benimseyerek, altyapınızın versiyon kontrolü altında olmasını sağlar, değişikliklerin izlenebilirliğini artırır ve felaket kurtarma senaryolarında hızlı iyileşme süreleri sunarsınız.

Bu yaklaşım sayesinde, mühendislik ekipleri tekrarlayan ve zaman alıcı görevlerden kurtularak inovatif projelere ve iş değerine odaklanabilir. Daha az hata, daha yüksek tutarlılık ve daha hızlı dağıtım döngüleri, otomatize edilmiş bir altyapının doğrudan sonuçlarıdır. Rancher'ın çoklu küme yönetim yetenekleri ile RKE2'nin güvenlik ve hafiflik avantajlarını Ansible'ın otomasyon gücüyle birleştirmek, geleceğin bulut yerel altyapısının temelini oluşturmaktadır. Bu yolculukta edindiğiniz bilgiler ve pratik örnekler, kendi altyapı otomasyon stratejinizi oluşturmanız için sağlam bir temel sunmaktadır. Unutmayın, otomasyon sürekli bir iyileştirme sürecidir; playbook'larınızı düzenli olarak gözden geçirmek, güncellemek ve yeni senaryoları dahil etmek, sisteminizin çevikliğini ve güvenliğini sürekli kılacaktır.

Sıkça Sorulan Sorular

1. RKE2 ve K3s arasındaki temel fark nedir?

Cevap: RKE2 ve K3s her ikisi de hafif Kubernetes dağıtımlarıdır ve Rancher Labs tarafından geliştirilmiştir. Temel fark, RKE2'nin kurumsal düzeyde güvenlik ve uyumluluk standartlarına (örneğin FIPS 140-2, CIS Benchmark) daha fazla odaklanmasıdır. K3s ise daha çok IoT, edge ve düşük kaynaklı ortamlara yönelikken, RKE2 daha sağlam ve kurumsal iş yükleri için tasarlanmıştır.

2. Ansible playbooks'larında hassas bilgileri nasıl güvenli tutabilirim?

Cevap: Hassas bilgileri (parolalar, API anahtarları vb.) açık metin olarak tutmaktan kaçının. Ansible Vault kullanarak bu verileri şifreleyebilirsiniz. Vault dosyalarını versiyon kontrol sisteminize (Git gibi) ekleyebilir, ancak parolayı ayrı ve güvenli bir şekilde saklamalısınız. Genellikle, --vault-password-file argümanıyla parola dosyasının yolunu belirtmek en iyi yöntemdir.

3. RKE2 ve Rancher kurulumunda yüksek erişilebilirlik (HA) nasıl sağlanır?

Cevap: RKE2 tarafında HA için en az üç sunucu düğümü kullanmalı ve RKE2 yapılandırma dosyasında (config.yaml) diğer sunucuların adreslerini belirtmelisiniz. Veri tabanı olarak Etcd yerine harici bir PostgreSQL veya MySQL kümesi de kullanabilirsiniz. Rancher için de, birden fazla RKE2 sunucu düğümüne Rancher'ı kurarak ve bir yük dengeleyici önüne alarak HA sağlayabilirsiniz. Rancher'ın kendisi Kubernetes üzerine kurulduğu için, temel Kubernetes HA prensipleri Rancher için de geçerlidir.

4. Mevcut bir RKE2 kümesini Rancher'a nasıl ekleyebilirim?

Cevap: Rancher UI'da oturum açtıktan sonra, "Cluster Management" (Küme Yönetimi) bölümüne gidin ve "Import Existing" (Mevcut Kümeyi İçe Aktar) seçeneğini seçin. Rancher size bir kubectl komutu verecektir. Bu komutu, RKE2 kümenize erişebilen bir makineden (örneğin Ansible kontrol makinesi veya RKE2 sunucu düğümü) çalıştırın. Bu komut, Rancher agent'larını RKE2 kümenize dağıtarak Rancher'ın kümenizi yönetmesini sağlar.

5. Ansible ile RKE2 ve Rancher güncellemelerini nasıl otomatize edebilirim?

Cevap: RKE2 ve Rancher güncellemeleri için mevcut playbook'larınızı yeni versiyon numaralarıyla güncelleyerek ve tekrar çalıştırarak otomatize edebilirsiniz. RKE2 güncellemeleri genellikle ikili dosyaların değiştirilip servisin yeniden başlatılmasıyla yapılır. Rancher güncellemeleri ise Helm upgrade komutları ile gerçekleştirilir. Ancak, güncelleme öncesinde mutlaka yedekleme yapmalı ve öncelikle geliştirme/test ortamlarında denemelisiniz. Canlı ortamda kademeli güncellemeler ve kesinti sürelerini minimize edecek stratejiler (örneğin Canary dağıtımları) kullanmak önemlidir.