0Pricing
DevOps Bootcamp · Ders

Kullanıcı ve Grup Sağlamayı Otomatikleştirme

useradd, chage ve sudoers parça yönetimini kullanarak hesapları toplu olarak oluşturun, değiştirin ve denetleyin.

Kullanıcı ve Grup Sağlamayı Otomatikleştirme, CoddyKit'te ücretsiz bir DevOps Bootcamp dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, DevOps Bootcamp öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. DevOps Bootcamp kursu toplamda 4 dersten oluşur.

Kullanıcı Hazırlama İşlemi Neden Otomatikleştirilir?

Kullanıcıları useradd ile teker teker yönetmek birkaç hesap için oldukça uygundur; ancak kurumsal ortamlarda aynı anda düzenli olarak onlarca veya yüzlerce kullanıcı sisteme dahil edilir. El ile girilen komutlar hataya açık, tutarsız ve denetlenemez hâle gelir.

Bash betikleri şunları yapmanızı sağlar:

  • Kullanıcıları her seferinde standart ayarlarla (kabuk, ana dizin, parola ilkesi) oluşturmak
  • Yeni çalışanların bulunduğu bir CSV veya metin dosyasını okumak ve kullanıcıları tek çalıştırmada hazırlamak
  • Uyumluluk gereklilikleri için denetim izi oluşturacak şekilde her işlemi günlük kaydına geçirmek
  • Yapılandırma yönetimi işlem hatlarıyla (Ansible, Chef, Jenkins) tümleştirmek

Bu derste, useradd, chage, usermod, grup yönetimi, sudoers ek dosyaları ve çalışma sonrası denetim konularını kapsayarak üretim ortamına uygun bir kullanıcı hazırlama betiğinin sıfırdan oluşturulması ele alınır.

Toplu Kullanıcı Listesini Okuma

Toplu hazırlama için standart girdi biçimi, her satırda bir kayıt bulunan, sınırlayıcılarla ayrılmış bir metin dosyasıdır. Tipik bir CSV şöyle görünebilir:

username,full_name,group,shell
alice,Alice Smith,developers,/bin/bash
bob,Bob Jones,ops,/bin/zsh

Güvenli bir şekilde ayrıştırmak için while döngüsü içinde IFS ve read kullanın. tail -n +2 ile başlık satırını atlamak, mantığın sade kalmasını sağlar.

Temel savunmacı uygulamalar:

  • Her alandaki baştaki ve sondaki boşlukları kaldırın
  • Boş satırları ve # ile başlayan yorum satırlarını atlayın
  • Herhangi bir sistem komutunu çağırmadan önce zorunlu alanların boş olmadığını doğrulayın
#!/usr/bin/env bash
# parse_users.sh — safely read a CSV of users
set -euo pipefail

USER_FILE="${1:-users.csv}"

[[ -f "$USER_FILE" ]] || { echo "ERROR: $USER_FILE not found"; exit 1; }

tail -n +2 "$USER_FILE" | while IFS=',' read -r username full_name group shell; do
  # trim whitespace
  username="${username// /}"
  [[ -z "$username" || "$username" == \#* ]] && continue

  echo "Parsed -> user=$username group=$group shell=$shell"
done

useradd ile Kullanıcı Oluşturma

useradd, /etc/passwd, /etc/shadow ve /etc/group dosyalarına yazan düşük seviyeli yardımcı programdır. Betik yazımı için en önemli seçenekler şunlardır:

  • -m — ana dizini oluşturur
  • -s — oturum açma kabuğunu ayarlar
  • -c — GECOS yorum alanı (tam ad)
  • -G — ek gruplar (virgülle ayrılmış)
  • -e — hesap sona erme tarihi (YYYY-MM-DD)

useradd komutunu çağırmadan önce id ile kullanıcının zaten var olup olmadığını her zaman kontrol edin; mevcut bir kullanıcı üzerinde çalıştırıldığında çıkış kodu 9 döner ve günlük kayıtlarını gereksiz yere kalabalıklaştırabilecek bir hata yazdırır.

Not: useradd kök yetkileri gerektirir. Betiğinizin başına bir yetki denetimi ekleyin.

#!/usr/bin/env bash
# create_user.sh — idempotent single-user creation
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

USERNAME="$1"
FULL_NAME="${2:-}"
GROUP="${3:-staff}"
SHELL="${4:-/bin/bash}"

if id "$USERNAME" &>/dev/null; then
  echo "[SKIP] User $USERNAME already exists"
else
  useradd \
    --create-home \
    --shell "$SHELL" \
    --comment "$FULL_NAME" \
    --groups "$GROUP" \
    "$USERNAME"
  echo "[OK] Created $USERNAME"
fi

İlk Parolaları Güvenli Bir Şekilde Ayarlama

Parolaları betiklerde asla sabit olarak tanımlamayın. Toplu kullanıcı hazırlama için iki güvenli yaklaşım vardır:

  • Rastgele bir ilk parola oluşturmak: openssl rand veya /dev/urandom ile parolayı bir kez yazdırın ve kullanıcının ilk oturum açışında parolayı değiştirmesini zorunlu kılın
  • Önceden özetlenmiş bir parola ayarlamak: Düz metin parolanın işlem listesinde görünmemesi için SHA-512 özetiyle usermod -p kullanın

Betiklerle parola ayarlamak için önerilen araç chpasswd'dir — bu araç, username:password çiftlerini standart girdiden okur; böylece parola, ps aracılığıyla görülebilen komut satırı bağımsız değişkenlerinde görünmez.

Parolayı ayarladıktan sonra, bir sonraki oturum açmada hemen parola sıfırlamayı zorunlu kılmak için chage -d 0 kullanın.

#!/usr/bin/env bash
# set_temp_password.sh
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

USERNAME="$1"

# Generate a 16-char random password (alphanumeric only)
TMP_PASS=$(tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 16)

# Set password via chpasswd (password never in argv)
echo "${USERNAME}:${TMP_PASS}" | chpasswd

# Force password change on next login
chage -d 0 "$USERNAME"

echo "[OK] Temporary password for $USERNAME: $TMP_PASS"
echo "[OK] User must change password on first login"

chage ile Parola Yaşlandırmasını Yönetme

chage (yaşı değiştirme), /etc/shadow içinde saklanan parola yaşlandırma ilkesini denetler. Kurumsal güvenlik ilkeleri genellikle şunları zorunlu kılar:

  • En uzun parola geçerlilik süresi (ör. 90 gün)
  • Parolanın yeniden değiştirilebilmesi için geçmesi gereken en az gün sayısı
  • Sona erme öncesindeki uyarı dönemi
  • Son parola kullanımından sonra hesabın etkin olmaması nedeniyle kilitlenmesi

Temel chage seçenekleri:

  • -M <days> — en uzun parola geçerlilik süresi
  • -m <days> — en kısa parola geçerlilik süresi
  • -W <days> — sona erme öncesindeki uyarı günleri
  • -I <days> — hesap kilitlenmeden önceki etkin olmama günleri
  • -E <date> — mutlak hesap sona erme tarihi
  • -l — bir kullanıcının geçerli ayarlarını listeler
#!/usr/bin/env bash
# apply_password_policy.sh — enforce org-wide ageing policy
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

# Policy constants
MAX_AGE=90
MIN_AGE=1
WARN_DAYS=14
INACTIVE_DAYS=30

apply_policy() {
  local user="$1"
  chage \
    -M "$MAX_AGE" \
    -m "$MIN_AGE" \
    -W "$WARN_DAYS" \
    -I "$INACTIVE_DAYS" \
    "$user"
  echo "[OK] Policy applied to $user"
}

# Apply to all non-system users (UID >= 1000)
awk -F: '$3 >= 1000 && $3 < 65534 { print $1 }' /etc/passwd | while read -r user; do
  apply_policy "$user"
done

Toplu Grup Yönetimi

Gruplar, kaynak erişimini denetlemenin temel mekanizmasıdır. Bir hazırlama betiği, kullanıcıları gruplara eklemeden önce gerekli grupların var olduğundan emin olmalıdır — useradd -G nonexistent başarısız olur.

Çıkış kodunu kontrol ederek groupadd komutunu yinelemeye dayanıklı biçimde kullanın: grup zaten varsa 9 döndürür. getent group <name> kalıbı, /etc/group içinde grep kullanmaya kıyasla taşınabilir ve okunabilir bir alternatiftir.

gpasswd -a, mevcut üyelikleri değiştirmeden bir kullanıcıyı gruba ekler (usermod -G ise ek grup listesini değiştirir).

#!/usr/bin/env bash
# ensure_groups.sh — create groups if missing, then add users
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

REQUIRED_GROUPS=(developers ops security auditors)

for grp in "${REQUIRED_GROUPS[@]}"; do
  if getent group "$grp" &>/dev/null; then
    echo "[SKIP] Group $grp already exists"
  else
    groupadd "$grp"
    echo "[OK] Created group $grp"
  fi
done

# Safely add a user to a group (append, don't replace)
add_to_group() {
  local user="$1" group="$2"
  gpasswd -a "$user" "$group" 2>/dev/null && echo "[OK] $user -> $group"
}

Tam Toplu Hazırlama Betiği

Her şeyi bir araya getiren tek bir betik CSV dosyasını okur, kullanıcıları ve grupları oluşturur, parola ilkesini ayarlar, her işlemi günlük kaydına geçirir ve tüm toplu işlemi durdurmadan hataları düzgün bir şekilde ele alır.

Aşağıdaki betikteki önemli tasarım kararları:

  • Zaman damgaları içeren bir LOG_FILE, denetim amacıyla tüm işlemleri kaydeder
  • Bireysel kullanıcılarla ilgili hatalar günlük kaydına geçirilir, ancak döngü durdurulmaz (|| log_error)
  • Betiğin işlemleri yinelemeye dayanıklıdır — kısmi hatalardan sonra güvenle yeniden çalıştırılabilir
  • Tüm çıktılar tee aracılığıyla hem terminale hem de günlük dosyasına gönderilir
#!/usr/bin/env bash
# bulk_provision.sh — production user provisioning
set -uo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

USER_FILE="${1:-users.csv}"
LOG_FILE="/var/log/user_provision_$(date +%F).log"

log()  { echo "[$(date '+%F %T')] $*" | tee -a "$LOG_FILE"; }
err()  { log "ERROR: $*"; }

log "=== Provisioning started from $USER_FILE ==="

tail -n +2 "$USER_FILE" | while IFS=',' read -r username fullname group shell; do
  username="${username// /}"
  [[ -z "$username" || "$username" == \#* ]] && continue
  group="${group:-staff}"
  shell="${shell:-/bin/bash}"

  # Ensure group exists
  getent group "$group" &>/dev/null || groupadd "$group"

  # Create user idempotently
  if id "$username" &>/dev/null; then
    log "[SKIP] $username exists"
  else
    useradd -m -s "$shell" -c "$fullname" -G "$group" "$username" || { err "useradd failed for $username"; continue; }
    TMP="$(tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 14)"
    echo "${username}:${TMP}" | chpasswd
    chage -M 90 -m 1 -W 14 -I 30 -d 0 "$username"
    log "[OK] $username created (group=$group) tmp_pass=$TMP"
  fi
done

log "=== Provisioning complete ==="

sudoers Ek Dosyası Parçası Yönetimi

/etc/sudoers dosyasını doğrudan düzenlemek tehlikelidir — bir söz dizimi hatası herkesin sudo erişimini kaybetmesine neden olur. Güvenli yaklaşım, /etc/sudoers.d/ içinde ek dosyalar kullanmak ve bunları yerine yerleştirmeden önce her birini visudo -c -f ile doğrulamaktır.

sudoers parçaları için en iyi uygulamalar:

  • Dosyaları, yetki verdikleri ekibin veya rolün adını kullanarak adlandırın (ör. 10-developers, 20-ops)
  • Kullanıcı başına satırlar yerine grup tabanlı kurallar kullanın (%developers ALL=(ALL) NOPASSWD: /usr/bin/systemctl)
  • İzinleri her zaman 0440, sahipliği ise root:root olarak ayarlayın
  • visudo -c ile doğrulayın — herhangi bir söz dizimi hatasında sıfırdan farklı bir çıkış koduyla sonlanır
#!/usr/bin/env bash
# write_sudoers_fragment.sh
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

FRAGMENT_NAME="${1:-10-developers}"
SUDOERS_DIR="/etc/sudoers.d"
TMP_FILE="$(mktemp)"

# Write the fragment to a temp file first
cat > "$TMP_FILE" << 'EOF'
# Developers: restart services and view journals without full root
%developers ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart *, /usr/bin/journalctl
%ops        ALL=(ALL) NOPASSWD: ALL
EOF

# Validate BEFORE installing
if visudo -c -f "$TMP_FILE"; then
  install -m 0440 -o root -g root "$TMP_FILE" "${SUDOERS_DIR}/${FRAGMENT_NAME}"
  echo "[OK] Installed ${SUDOERS_DIR}/${FRAGMENT_NAME}"
else
  echo "[ERROR] sudoers syntax check failed — fragment NOT installed"
  rm -f "$TMP_FILE"
  exit 1
fi
rm -f "$TMP_FILE"

Mevcut Hesapları Denetleme

Kullanıcı hazırlama işleminden sonra ve düzenli aralıklarla, anormallikleri bulmak için kullanıcı veritabanını denetlemelisiniz:

  • UID 0 hesapları — root dışında UID değeri 0 olan herhangi bir hesap kritik bir güvenlik bulgusudur
  • Parolası olmayan hesaplar — /etc/shadow içindeki parola alanı boş olan veya ! içeren girdiler
  • Süresi dolduğu hâlde etkin hesaplar — chage -l çıktısı toplu olarak ayrıştırılabilir
  • Kabuğu olup ana dizini olmayan kullanıcılar — oturum açmayı bozan yapılandırma hatası

Yapılandırılmış bir rapor oluşturup bunu güvenlik ekibine mail ile göndermek veya izlenen bir günlük yoluna eklemek kolaydır.

#!/usr/bin/env bash
# audit_users.sh — produce a security-relevant user report
set -uo pipefail

REPORT="/var/log/user_audit_$(date +%F).txt"

echo "=== User Audit Report $(date) ===" > "$REPORT"

echo "" >> "$REPORT"
echo "--- Accounts with UID 0 (should be root only) ---" >> "$REPORT"
awk -F: '$3 == 0 { print $1 }' /etc/passwd >> "$REPORT"

echo "" >> "$REPORT"
echo "--- Accounts with empty password field ---" >> "$REPORT"
awk -F: '($2 == "" || $2 == "!") && $3 >= 1000 { print $1 }' /etc/shadow 2>/dev/null >> "$REPORT" || echo "  (requires root)" >> "$REPORT"

echo "" >> "$REPORT"
echo "--- Normal users (UID 1000-60000) ---" >> "$REPORT"
awk -F: '$3 >= 1000 && $3 < 60000 { printf "%-20s uid=%-6s shell=%s\n", $1, $3, $7 }' /etc/passwd >> "$REPORT"

cat "$REPORT"
echo "Report saved to $REPORT"

Hesapları Kilitleme, Kilidini Açma ve Kaldırma

Sistemden ayrılan kullanıcıların işlemleri, sisteme dahil edilen kullanıcıların işlemleri kadar önemlidir. Bir kullanıcı ayrıldığında doğru sıra şöyledir:

  1. Hesabı hemen kilitleyin (usermod -L) — silmeden oturum açmayı engellemek için shadow parola özetinin başına ! ekler
  2. sudo yetkisini kaldırın — varsa sudoers parçasını kaldırın
  3. Sahipliği devredin — dosyalarının sahipliğini bir yöneticiye veya arşiv hesabına aktarın
  4. Arşivleyin — silmeden önce ana dizini tar arşivi olarak saklayın
  5. Silin — ana dizini ve posta kuyruğunu kaldırmak için userdel -r kullanın

usermod -U, hesabın kilidini açar (! ön ekini kaldırır); geçici askıya alma durumlarında kullanışlıdır.

#!/usr/bin/env bash
# offboard_user.sh — lock, archive, then optionally delete
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

USERNAME="$1"
ARCHIVE_DIR="/srv/archived-homes"
mkdir -p "$ARCHIVE_DIR"

# 1. Lock account
usermod -L "$USERNAME"
echo "[OK] Account $USERNAME locked"

# 2. Remove sudoers fragment if present
SUDOERS_FILE="/etc/sudoers.d/${USERNAME}"
[[ -f "$SUDOERS_FILE" ]] && rm -f "$SUDOERS_FILE" && echo "[OK] Removed sudoers fragment"

# 3. Archive home directory
HOME_DIR="$(getent passwd "$USERNAME" | cut -d: -f6)"
if [[ -d "$HOME_DIR" ]]; then
  tar -czf "${ARCHIVE_DIR}/${USERNAME}_$(date +%F).tar.gz" -C "$(dirname "$HOME_DIR")" "$(basename "$HOME_DIR")"
  echo "[OK] Home archived to ${ARCHIVE_DIR}/${USERNAME}_$(date +%F).tar.gz"
fi

echo "[NOTICE] Review archive, then run: userdel -r $USERNAME"

Betiği Deneme Çalıştırma Moduyla Sınama

Üretim ortamındaki kullanıcı hazırlama betikleri, yan etki oluşturmadan sınanabilmelidir. Tüm değişiklik yapan komutları echo taslaklarıyla değiştiren bir deneme çalıştırma modu uygulamak için DRY_RUN seçeneğini kullanın.

Kalıp basittir: Seçeneğe bağlı olarak komutu çalıştıran veya yankılayan bir run() yardımcı işlevi tanımlayın. Bu yaklaşım şunları sağlar:

  • Sınama sırasında her kod yolu çalıştırılır
  • Çıktı, canlı çalıştırmada tam olarak ne olacağını gösterir
  • CI işlem hatları, kök erişimi olmadan mantığı doğrulayabilir

Deneme çalıştırmayı, tümleştirme sınamalarından sonra temizlemeyi kolaylaştıran özel bir sınama kullanıcı ön ekiyle (ör. test_) tamamlayın.

#!/usr/bin/env bash
# provision_with_dryrun.sh
set -euo pipefail

DRY_RUN="${DRY_RUN:-false}"

# Wrapper: execute or echo
run() {
  if [[ "$DRY_RUN" == "true" ]]; then
    echo "[DRY-RUN] $*"
  else
    "$@"
  fi
}

create_user() {
  local user="$1" group="$2"
  if id "$user" &>/dev/null; then
    echo "[SKIP] $user exists"
    return
  fi
  run useradd -m -s /bin/bash -G "$group" "$user"
  run chage -M 90 -m 1 -W 14 -d 0 "$user"
  echo "[OK] $user provisioned (dry=$DRY_RUN)"
}

# Test run
DRY_RUN=true create_user testuser developers
echo "---"
create_user realuser developers 2>/dev/null || true

Mevcut Grup Üyeliklerini Kaldırmadan Bir Kullanıcıyı Ek Gruba Eklemek İçin Hangi Komut Kullanılmalıdır?

Toplu kullanıcı hazırlama betiğinde mevcut bir kullanıcıyı auditors grubuna atamanız gerekiyor. Kullanıcı zaten developers ve staff gruplarının üyesi. Yeni grubu eklerken mevcut tüm üyelikleri koruyan komut hangisidir?

Ders Özeti: Kullanıcı ve Grup Hazırlamayı Otomatikleştirme

Bu derste üretim ortamına uygun, eksiksiz bir kullanıcı hazırlama araç seti oluşturdunuz. Temel çıkarımlar şunlardır:

  • Girdiyi savunmacı biçimde ayrıştırın — IFS/read döngülerini kullanın, boş ve yorum satırlarını atlayın, herhangi bir sistem çağrısından önce alanları doğrulayın
  • useradd temelleri — her zaman -m (ana dizin), -s (kabuk), -c (yorum) ve -G (gruplar) seçeneklerini kullanın; yinelemeye dayanıklılık için önce id ile varlığı kontrol edin
  • Parolalar — düz metni işlem bağımsız değişkenlerinden uzak tutmak için chpasswd standart girdisiyle ayarlayın; chage -d 0 ile ilk oturum açmada sıfırlamayı zorunlu kılın
  • İlke için chage — sistem hesapları dışındaki tüm hesaplarda en uzun süreyi (-M), uyarı günlerini (-W) ve etkin olmama kilidini (-I) standartlaştırın
  • Grup üyeliği — üyelikleri değiştirmek yerine sona eklemek için gpasswd -a veya -a seçeneğiyle usermod -aG kullanın
  • sudoers ek dosyaları — /etc/sudoers.d/ konumuna yazın, yüklemeden önce visudo -c -f ile doğrulayın, 0440 root:root izinlerini ayarlayın
  • Sistemden ayrılış işlemleri — kilitleyin (usermod -L), ana dizini arşivleyin, ardından silin; arşivleme adımını asla atlamayın
  • Deneme çalıştırma modu — işlem hatlarının mantığı kök yetkisiyle yan etki oluşturmadan doğrulayabilmesi için değişiklik yapan komutları bir run() yardımcı işlevi içine alın

Bu kalıpları birleştirerek her ölçekte Linux kimlik yönetimi için tekrarlanabilir, denetlenebilir ve güvenli bir otomasyon katmanı elde edersiniz.

Sıkça Sorulan Sorular

“Kullanıcı ve Grup Sağlamayı Otomatikleştirme” dersi ücretsiz mi?

Evet — “Kullanıcı ve Grup Sağlamayı Otomatikleştirme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve DevOps Bootcamp kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. DevOps Bootcamp kursu toplamda 4 dersten oluşur.

“Kullanıcı ve Grup Sağlamayı Otomatikleştirme” dersinde ne öğreneceğim?

useradd, chage ve sudoers parça yönetimini kullanarak hesapları toplu olarak oluşturun, değiştirin ve denetleyin. DevOps Bootcamp ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

DevOps Bootcamp öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te DevOps Bootcamp, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“Kullanıcı ve Grup Sağlamayı Otomatikleştirme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu DevOps Bootcamp dersinde kod yazıp çalıştırabilir miyim?

Evet. Her DevOps Bootcamp dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Kullanıcı ve Grup Sağlamayı Otomatikleştirme
  2. systemd Hizmetlerini Denetleme ve Unit Dosyaları Yazma
  3. Disk, Dosya Sistemi ve Bağlama Otomasyonu
  4. Sistem Durumu Denetimi ve Uyarı Betikleri Oluşturma
← DevOps Bootcamp Sayfasına Dön