Jenkins ile Role-Based Access Control (RBAC): Kullanıcı Yetkilendirme ve Erişim Yönetimi

Yazar:komut.io ekibi Jenkins Kurulum ve Yapılandırma
0 Yorum

Kurumsal bir Jenkins ortamında herkesin her şeye erişebildiği bir yapı, beklenmedik bir anda tüm pipeline’larınızı çökertebilir ya da hassas credential’larınızın yanlış ellere geçmesine yol açabilir. “Herkese admin ver, sorun çıkınca hallederiz” yaklaşımının ne kadar tehlikeli olduğunu bilen biri olarak, RBAC konusunu Jenkins özelinde derinlemesine ele almak istedim.

Jenkins’te RBAC Neden Önemli?

Jenkins, CI/CD süreçlerinin kalbinde yer alır. Production deployment’larını tetikler, kritik API anahtarlarını barındırır, kaynak kodunuza erişir. Bu kadar kritik bir sistemi herkesin özgürce kullanmasına izin vermek, kapıyı ardına kadar açık bırakmak gibidir.

Gerçek dünyadan bir senaryo düşünelim: Bir geliştirici ekibi var, QA mühendisleri var, DevOps ekibi var ve yöneticiler var. Geliştirici Ahmet’in production pipeline’ını çalıştırma yetkisine ihtiyacı yok. QA mühendisi Ayşe’nin Jenkins sistem ayarlarını değiştirmesine gerek yok. Ama herkesin kendi projesiyle ilgili build loglarını görebilmesi gerekiyor.

İşte tam bu noktada Role-Based Access Control devreye giriyor. Jenkins’te RBAC’ı düzgün kurarsanız:

  • Ekipler sadece kendi projelerine erişebilir
  • Credential’lar yanlış kişilerin eline geçmez
  • Audit trail tutulabilir hale gelir
  • Yanlışlıkla yapılan konfigürasyon değişikliklerinin önüne geçilir

Gerekli Plugin’lerin Kurulumu

Jenkins’te RBAC için en yaygın kullanılan plugin Role-based Authorization Strategy plugin’idir. Bunu kurmak için birkaç yol var.

Jenkins UI Üzerinden Kurulum

Manage Jenkins > Manage Plugins > Available sekmesine gidin ve “Role-based Authorization Strategy” araması yapın. Plugin’i kurun ve Jenkins’i yeniden başlatın.

CLI ile Plugin Kurulumu

# Jenkins CLI jar'ını indirin
wget http://your-jenkins-server:8080/jnlpJars/jenkins-cli.jar

# Plugin kurulumu
java -jar jenkins-cli.jar -s http://your-jenkins-server:8080 
  -auth admin:your-api-token 
  install-plugin role-strategy

# Jenkins'i yeniden başlat
java -jar jenkins-cli.jar -s http://your-jenkins-server:8080 
  -auth admin:your-api-token 
  safe-restart

Plugin’i Etkinleştirme

Plugin kurulduktan sonra Manage Jenkins > Configure Global Security yolunu izleyin. Authorization bölümünde “Role-Based Strategy” seçeneğini göreceksiniz. Bunu seçip kaydedin.

Dikkat: Bu adımı yaparken mevcut admin kullanıcınızın oturumu açık olsun. Yanlış yapılandırma sizi sistemden kilitleyebilir.

Role Yapısını Anlamak

Role-Based Authorization Strategy plugin’i üç tür rol tanımlar:

  • Global Roles: Jenkins genelinde geçerli olan roller. Tüm job’ları görme, sistem ayarlarını değiştirme gibi yetkiler buraya girer
  • Item Roles: Belirli job’lar veya folder’lar üzerindeki yetkiler. Regex pattern ile hangi job’lara uygulanacağı belirlenir
  • Agent Roles: Build agent’ları üzerindeki yetkiler. Hangi node’ların kullanılabileceğini kontrol eder

Global Rollerin Yapılandırılması

Manage Jenkins > Manage and Assign Roles > Manage Roles yolunu izleyerek rol yönetim ekranına ulaşın.

Tipik bir kurumsal yapı için şu global rolleri oluşturmanızı öneririm:

// Jenkins init script ile rol tanımları (init.groovy.d/setup-roles.groovy)
import com.michelin.cio.hudson.plugins.rolestrategy.RoleBasedAuthorizationStrategy
import com.michelin.cio.hudson.plugins.rolestrategy.Role
import hudson.security.Permission

def strategy = new RoleBasedAuthorizationStrategy()

// Global viewer rolü - sadece okuma yetkisi
Set<Permission> viewerPermissions = new HashSet<>()
viewerPermissions.add(hudson.model.Hudson.READ)
viewerPermissions.add(hudson.model.Item.READ)
viewerPermissions.add(hudson.model.Item.DISCOVER)

Role viewerRole = new Role("viewer", viewerPermissions)
strategy.addRole(RoleBasedAuthorizationStrategy.GLOBAL, viewerRole)

Jenkins.instance.setAuthorizationStrategy(strategy)
Jenkins.instance.save()

Groovy Script ile Rol Oluşturma

Jenkins Script Console üzerinden de rol yönetimi yapabilirsiniz. Manage Jenkins > Script Console üzerinden aşağıdaki script’i çalıştırabilirsiniz:

import com.michelin.cio.hudson.plugins.rolestrategy.RoleBasedAuthorizationStrategy
import com.michelin.cio.hudson.plugins.rolestrategy.Role
import jenkins.model.Jenkins
import hudson.security.Permission

def jenkins = Jenkins.getInstance()
def strategy = (RoleBasedAuthorizationStrategy) jenkins.getAuthorizationStrategy()

// Developer rolü için izinler
def developerPermissions = [
    hudson.model.Item.BUILD,
    hudson.model.Item.CANCEL,
    hudson.model.Item.READ,
    hudson.model.Item.WORKSPACE,
    hudson.model.Run.UPDATE,
    hudson.model.Run.ARTIFACTS
] as Set

// Pattern ile item rolü oluştur - dev-* ile başlayan tüm job'lar
def developerRole = new Role("developer", "dev-.*", developerPermissions, "Developer ekip rolü")
strategy.addRole(RoleBasedAuthorizationStrategy.PROJECT, developerRole)

jenkins.save()
println "Developer rolü başarıyla oluşturuldu"

Gerçek Dünya Senaryosu: Çok Ekipli Yapı

Diyelim ki şöyle bir organizasyonunuz var:

  • DevOps Ekibi: Tüm pipeline’lara tam erişim
  • Backend Geliştiriciler: Sadece backend projelerine build/deploy yetkisi
  • Frontend Geliştiriciler: Sadece frontend projelerine build yetkisi
  • QA Ekibi: Tüm projeleri görüntüleyebilir, test job’larını çalıştırabilir
  • Yöneticiler: Sadece build durumlarını görebilir

Bu yapıyı Jenkins’te otomatize etmek için şu script’i kullanabilirsiniz:

import com.michelin.cio.hudson.plugins.rolestrategy.RoleBasedAuthorizationStrategy
import com.michelin.cio.hudson.plugins.rolestrategy.Role
import jenkins.model.Jenkins
import hudson.security.Permission

def jenkins = Jenkins.getInstance()
def strategy = (RoleBasedAuthorizationStrategy) jenkins.getAuthorizationStrategy()

// Temel okuma izni seti
def readPermissions = [
    hudson.model.Hudson.READ,
    hudson.model.Item.READ,
    hudson.model.Item.DISCOVER
] as Set

// Build izin seti
def buildPermissions = readPermissions + [
    hudson.model.Item.BUILD,
    hudson.model.Item.CANCEL,
    hudson.model.Item.WORKSPACE,
    hudson.model.Run.UPDATE
] as Set

// Tam proje izin seti
def fullProjectPermissions = buildPermissions + [
    hudson.model.Item.CONFIGURE,
    hudson.model.Item.CREATE,
    hudson.model.Item.DELETE,
    hudson.model.Run.DELETE,
    hudson.model.Run.ARTIFACTS
] as Set

// Global roller
def viewerGlobalRole = new Role("global-viewer", readPermissions)
strategy.addRole(RoleBasedAuthorizationStrategy.GLOBAL, viewerGlobalRole)

// Backend developer item rolü
def backendDevRole = new Role(
    "backend-developer",
    "backend-.*|services-.*|api-.*",
    buildPermissions,
    "Backend geliştirici rolü"
)
strategy.addRole(RoleBasedAuthorizationStrategy.PROJECT, backendDevRole)

// Frontend developer item rolü
def frontendDevRole = new Role(
    "frontend-developer",
    "frontend-.*|ui-.*|web-.*",
    buildPermissions,
    "Frontend geliştirici rolü"
)
strategy.addRole(RoleBasedAuthorizationStrategy.PROJECT, frontendDevRole)

// QA ekibi rolü - test ile başlayan tüm job'lar
def qaRole = new Role(
    "qa-engineer",
    ".*test.*|.*qa.*|.*e2e.*",
    buildPermissions,
    "QA ekip rolü"
)
strategy.addRole(RoleBasedAuthorizationStrategy.PROJECT, qaRole)

jenkins.save()
println "Tüm roller başarıyla yapılandırıldı"

Kullanıcı ve Grup Atamaları

Rolleri oluşturduktan sonra kullanıcılara veya gruplara atama yapmanız gerekiyor. Manage Jenkins > Manage and Assign Roles > Assign Roles ekranından bu işlemi yapabilirsiniz.

Script üzerinden kullanıcı atama:

import com.michelin.cio.hudson.plugins.rolestrategy.RoleBasedAuthorizationStrategy
import jenkins.model.Jenkins

def jenkins = Jenkins.getInstance()
def strategy = (RoleBasedAuthorizationStrategy) jenkins.getAuthorizationStrategy()

// Global rol ataması
strategy.assignRole(RoleBasedAuthorizationStrategy.GLOBAL, "global-viewer", "ahmet.yilmaz")
strategy.assignRole(RoleBasedAuthorizationStrategy.GLOBAL, "global-viewer", "ayse.kaya")

// Item rol ataması
strategy.assignRole(RoleBasedAuthorizationStrategy.PROJECT, "backend-developer", "ahmet.yilmaz")
strategy.assignRole(RoleBasedAuthorizationStrategy.PROJECT, "frontend-developer", "ayse.kaya")

// LDAP/AD grubu ataması (grup adı @ ile başlar bazı yapılandırmalarda)
strategy.assignRole(RoleBasedAuthorizationStrategy.GLOBAL, "global-viewer", "authenticated")
strategy.assignRole(RoleBasedAuthorizationStrategy.PROJECT, "qa-engineer", "qa-team-group")

jenkins.save()
println "Kullanıcı atamaları tamamlandı"

LDAP Entegrasyonu ile RBAC

Kurumsal ortamlarda genellikle LDAP veya Active Directory kullanılır. Jenkins’i LDAP ile entegre etmek için LDAP Plugin‘i kurmanız gerekir.

# LDAP plugin kurulumu
java -jar jenkins-cli.jar -s http://your-jenkins-server:8080 
  -auth admin:your-api-token 
  install-plugin ldap

LDAP yapılandırması için Manage Jenkins > Configure Global Security > Security Realm bölümünde LDAP seçeneğini seçin.

Temel LDAP yapılandırma parametreleri:

  • Server: ldap://your-ldap-server:389 veya ldaps://your-ldap-server:636
  • Root DN: dc=sirketiniz,dc=com
  • User search base: ou=users,dc=sirketiniz,dc=com
  • User search filter: uid={0} veya sAMAccountName={0} (AD için)
  • Group search base: ou=groups,dc=sirketiniz,dc=com

LDAP grup tabanlı rol ataması için script:

import com.michelin.cio.hudson.plugins.rolestrategy.RoleBasedAuthorizationStrategy
import jenkins.model.Jenkins

def jenkins = Jenkins.getInstance()
def strategy = (RoleBasedAuthorizationStrategy) jenkins.getAuthorizationStrategy()

// LDAP gruplarını Jenkins rollerine bağla
def ldapGroupMappings = [
    "CN=jenkins-devops,OU=Groups,DC=sirket,DC=com": "devops-admin",
    "CN=jenkins-backend,OU=Groups,DC=sirket,DC=com": "backend-developer",
    "CN=jenkins-frontend,OU=Groups,DC=sirket,DC=com": "frontend-developer",
    "CN=jenkins-qa,OU=Groups,DC=sirket,DC=com": "qa-engineer",
    "CN=jenkins-readonly,OU=Groups,DC=sirket,DC=com": "global-viewer"
]

ldapGroupMappings.each { ldapGroup, jenkinsRole ->
    try {
        strategy.assignRole(RoleBasedAuthorizationStrategy.GLOBAL, jenkinsRole, ldapGroup)
        println "${ldapGroup} grubu ${jenkinsRole} rolüne atandı"
    } catch (Exception e) {
        println "Hata: ${ldapGroup} atamasında sorun: ${e.message}"
    }
}

jenkins.save()
println "LDAP grup atamaları tamamlandı"

Folder Tabanlı Erişim Kontrolü

CloudBees Folders Plugin veya standart Jenkins folder yapısıyla organizasyonel bir hiyerarşi kurabilirsiniz. Bu yaklaşım özellikle büyük ekiplerde çok işe yarar.

Jenkins
├── backend/
│   ├── user-service/
│   ├── payment-service/
│   └── notification-service/
├── frontend/
│   ├── web-app/
│   └── mobile-app/
└── infrastructure/
    ├── terraform-apply/
    └── k8s-deploy/

Bu yapıya uygun regex pattern’leri:

  • Backend rolleri için: backend/.*
  • Frontend rolleri için: frontend/.*
  • Infrastructure rolleri için: infrastructure/.*

Configuration as Code ile RBAC

JCasC (Jenkins Configuration as Code) plugin’i kullanarak RBAC yapılandırmanızı kod olarak yönetebilirsiniz. Bu yaklaşım özellikle GitOps felsefesiyle uyumludur.

# jenkins.yaml - JCasC konfigürasyon dosyası
jenkins:
  authorizationStrategy:
    roleBased:
      roles:
        global:
          - name: "admin"
            description: "Jenkins Administrators"
            permissions:
              - "Overall/Administer"
            assignments:
              - "admin-user"
              - "devops-team"
          - name: "global-viewer"
            description: "Read-only global access"
            permissions:
              - "Overall/Read"
              - "Job/Read"
              - "Job/Discover"
            assignments:
              - "authenticated"
        items:
          - name: "backend-developer"
            description: "Backend team job access"
            pattern: "backend-.*"
            permissions:
              - "Job/Build"
              - "Job/Cancel"
              - "Job/Read"
              - "Job/Workspace"
              - "Run/Update"
            assignments:
              - "backend-team-ldap-group"
          - name: "frontend-developer"
            description: "Frontend team job access"
            pattern: "frontend-.*"
            permissions:
              - "Job/Build"
              - "Job/Cancel"
              - "Job/Read"
            assignments:
              - "frontend-team-ldap-group"

JCasC konfigürasyonunu uygulamak için:

# JCasC plugin kurulumu
java -jar jenkins-cli.jar -s http://your-jenkins-server:8080 
  -auth admin:your-api-token 
  install-plugin configuration-as-code

# Konfigürasyonu yeniden yükle
curl -X POST http://admin:token@your-jenkins-server:8080/configuration-as-code/reload

Audit ve Monitoring

RBAC kurmanın yanı sıra erişim loglarını takip etmek de kritik önem taşır.

Audit Trail Plugin kurarak tüm Jenkins aksiyonlarını loglayabilirsiniz:

java -jar jenkins-cli.jar -s http://your-jenkins-server:8080 
  -auth admin:your-api-token 
  install-plugin audit-trail

Log dosyasına yazmak için Manage Jenkins > Configure System > Audit Trail bölümünden log lokasyonunu belirleyin. Örneğin /var/log/jenkins/audit.log kullanabilirsiniz.

Audit loglarını analiz etmek için basit bir bash script:

#!/bin/bash
# audit-report.sh - Günlük erişim raporu

AUDIT_LOG="/var/log/jenkins/audit.log"
REPORT_DATE=$(date +%Y-%m-%d)

echo "Jenkins Audit Raporu - $REPORT_DATE"
echo "=================================="

echo -e "n[+] Bugünkü başarısız login denemeleri:"
grep "$REPORT_DATE" "$AUDIT_LOG" | grep "FAILED" | awk '{print $3}' | sort | uniq -c | sort -rn

echo -e "n[+] En çok job çalıştıran kullanıcılar:"
grep "$REPORT_DATE" "$AUDIT_LOG" | grep "BUILD" | awk '{print $5}' | sort | uniq -c | sort -rn | head -10

echo -e "n[+] Konfigürasyon değişiklikleri:"
grep "$REPORT_DATE" "$AUDIT_LOG" | grep "CONFIGURE" | while read line; do
    echo "  -> $line"
done

echo -e "n[+] Yeni kullanıcı oluşturmaları:"
grep "$REPORT_DATE" "$AUDIT_LOG" | grep "CREATE_USER"

Sık Yapılan Hatalar ve Çözümleri

Yıllarca Jenkins yönetimi yapan biri olarak karşılaştığım en yaygın hataları paylaşmak istiyorum:

Admin kullanıcısını kilitlemek: Global rollerde mutlaka bir admin kullanıcısı bırakın. “Overall/Administer” yetkisini tamamen kaldırmak sizi sistemin dışına atar.

Çok geniş pattern kullanımı: .* pattern’i her şeyi kapsar, dikkatli olun. Özellikle item rollerinde spesifik pattern’ler yazın.

LDAP group DN büyük/küçük harf duyarlılığı: Bazı LDAP implementasyonlarında grup DN’leri büyük/küçük harfe duyarlıdır. Jenkins’te atama yaparken LDAP’tan gelen değerin aynısını kullanın.

Anonymous kullanıcı izinleri: “Overall/Read” iznini anonymous kullanıcıya verirken dikkatli olun. Bu, kimliği doğrulanmamış kullanıcıların job listesini görmesine izin verir.

Sonuç

Jenkins’te RBAC doğru kurulduğunda hem güvenliği hem de ekip verimliliğini artırır. Her ekip üyesi sadece ihtiyacı olan şeylere erişir, sistem yöneticileri gereksiz yetkilerden kaynaklanan kazaları önlemiş olur.

Önerim şu yönde: Başlangıçta mevcut kullanıcılarınıza ihtiyaç duydukları minimum yetkileri verin, sonra talep geldikçe artırın. “Minimum privilege” prensibini Jenkins’te de uygulayın. JCasC ile konfigürasyonunuzu Git’te saklayın, böylece hem versiyon kontrolü yapabilir hem de hızlı recovery sağlayabilirsiniz.

Kurumunuzun büyüklüğüne göre LDAP entegrasyonu şart haline gelir. Tek tek kullanıcı yönetmek ölçeklenemiyor, merkezi dizin servisiyle senkronize bir yapı kurmak uzun vadede çok daha sürdürülebilir.

Son olarak audit logging’i ihmal etmeyin. Sorun çıktığında “kim ne zaman ne yaptı” sorusuna cevap verebilmek, hem sorun çözme hem de compliance açısından hayat kurtarıcıdır.

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir