Kem Intensif DevOps · Pelajaran

Mengautomatikkan Penyediaan Pengguna dan Kumpulan

Cipta, ubah suai dan audit akaun secara pukal menggunakan useradd, chage dan pengurusan serpihan sudoers

Pelajaran 1 daripada 413 langkah

Mengautomatikkan Penyediaan Pengguna dan Kumpulan ialah pelajaran Kem Intensif DevOps percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif DevOps, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif DevOps merangkumi sejumlah 4 pelajaran.

Mengapa Mengautomatikkan Penyediaan Pengguna?

Mengurus pengguna seorang demi seorang dengan useradd berfungsi dengan baik untuk beberapa akaun, tetapi persekitaran perusahaan lazimnya mendaftarkan puluhan atau ratusan pengguna secara serentak. Perintah manual mudah menghasilkan ralat, tidak konsisten dan tidak dapat diaudit.

Penskripan Bash membolehkan anda:

Mencipta pengguna dengan tetapan piawai (shell, direktori rumah, dasar kata laluan) setiap kali
Membaca CSV atau fail teks yang mengandungi pekerja baharu dan menyediakan akaun mereka dalam satu pelaksanaan
Mengelogi setiap tindakan supaya anda mempunyai jejak audit untuk pematuhan
Berintegrasi dengan saluran paip pengurusan konfigurasi (Ansible, Chef, Jenkins)

Pelajaran ini menerangkan langkah demi langkah pembinaan skrip penyediaan pengguna bertaraf pengeluaran dari awal, meliputi useradd, chage, usermod, pengurusan kumpulan, serpihan konfigurasi sudo, dan pengauditan selepas pelaksanaan.

Membaca Senarai Pengguna Secara Pukal

Format input piawai untuk penyediaan pukal ialah fail teks bersempadan — satu rekod bagi setiap baris. CSV biasa mungkin kelihatan seperti:

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

Gunakan IFS dan read dalam gelung while untuk menghuraikannya dengan selamat. Melangkau baris pengepala dengan tail -n +2 memastikan logiknya kemas.

Amalan pertahanan utama:

Buang ruang kosong di hadapan dan di belakang setiap medan
Langkau baris kosong dan baris ulasan yang bermula dengan #
Sahkan bahawa medan wajib tidak kosong sebelum memanggil sebarang perintah sistem

#!/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

Mencipta Pengguna dengan useradd

useradd ialah utiliti aras rendah yang menulis ke /etc/passwd, /etc/shadow dan /etc/group. Pilihan paling penting untuk penskripan ialah:

-m — mencipta direktori rumah
-s — menetapkan shell log masuk
-c — medan ulasan GECOS (nama penuh)
-G — kumpulan tambahan (dipisahkan dengan koma)
-e — tarikh luput akaun (YYYY-MM-DD)

Sentiasa semak sama ada pengguna itu sudah wujud dengan id sebelum memanggil useradd; menjalankannya pada pengguna sedia ada mengembalikan kod keluar 9 dan mencetak ralat yang boleh memenuhi log dengan tidak perlu.

Nota: useradd memerlukan keizinan root. Balut skrip anda dengan semakan keistimewaan pada bahagian awal.

#!/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

Menetapkan Kata Laluan Awal dengan Selamat

Jangan sekali-kali mengekod keras kata laluan dalam skrip. Dua pendekatan selamat untuk penyediaan pukal ialah:

Menjana kata laluan awal rawak dengan openssl rand atau /dev/urandom, mencetaknya sekali dan memaksa pengguna menukarnya semasa log masuk pertama
Menetapkan kata laluan yang telah dicincang menggunakan usermod -p dengan cincangan SHA-512 supaya teks biasa tidak pernah muncul dalam senarai proses

chpasswd ialah alat yang disyorkan untuk menetapkan kata laluan melalui skrip — ia membaca pasangan username:password daripada stdin, jadi kata laluan tidak pernah muncul dalam argumen baris perintah (yang boleh dilihat melalui ps).

Selepas menetapkan kata laluan, gunakan chage -d 0 untuk memaksa penetapan semula kata laluan dengan segera pada log masuk seterusnya.

#!/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"

Mengurus Tempoh Sah Kata Laluan dengan chage

chage (menukar tempoh sah) mengawal dasar tempoh sah kata laluan yang disimpan dalam /etc/shadow. Dasar keselamatan perusahaan lazimnya menetapkan:

Tempoh sah maksimum kata laluan (contohnya, 90 hari)
Bilangan hari minimum sebelum kata laluan boleh ditukar lagi
Tempoh amaran sebelum tamat tempoh
Penguncian akaun tidak aktif selepas penggunaan kata laluan terakhir

Pilihan utama chage:

-M <days> — tempoh sah maksimum kata laluan
-m <days> — tempoh sah minimum kata laluan
-W <days> — bilangan hari amaran sebelum tamat tempoh
-I <days> — bilangan hari tidak aktif sebelum akaun dikunci
-E <date> — tamat tempoh mutlak akaun
-l — menyenaraikan tetapan semasa bagi pengguna

#!/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

Pengurusan Kumpulan Secara Pukal

Kumpulan ialah mekanisme utama untuk mengawal akses kepada sumber. Skrip penyediaan mesti memastikan kumpulan yang diperlukan wujud sebelum menambahkan pengguna kepadanya — useradd -G nonexistent akan gagal.

Gunakan groupadd secara idempoten dengan menyemak kod keluar: ia mengembalikan 9 jika kumpulan itu sudah wujud. Idiom getent group <name> ialah alternatif yang mudah alih dan mudah dibaca berbanding mencari dalam /etc/group menggunakan grep.

gpasswd -a menambahkan pengguna kepada kumpulan tanpa menggantikan keahlian sedia ada (tidak seperti usermod -G, yang menggantikan senarai kumpulan tambahan).

#!/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"
}

Skrip Penyediaan Pukal Lengkap

Menggabungkan semuanya: satu skrip membaca CSV, mencipta pengguna dan kumpulan, menetapkan dasar kata laluan, mengelogi setiap tindakan dan mengendalikan ralat dengan baik tanpa menghentikan keseluruhan kelompok.

Keputusan reka bentuk penting dalam skrip di bawah:

LOG_FILE dengan cap masa merekodkan semua operasi untuk pengauditan
Ralat bagi pengguna individu direkodkan tetapi tidak membatalkan gelung (|| log_error)
Skrip ini idempoten — selamat untuk dijalankan semula selepas kegagalan separa
Semua output dihantar ke terminal dan fail log melalui tee

#!/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 ==="

Pengurusan Serpihan Konfigurasi sudo

Mengedit /etc/sudoers secara terus adalah berbahaya — ralat sintaks boleh menghalang semua orang daripada menggunakan sudo. Pendekatan selamat ialah menggunakan fail serpihan dalam /etc/sudoers.d/, setiap satunya disahkan dengan visudo -c -f sebelum ditempatkan.

Amalan terbaik untuk serpihan konfigurasi sudo:

Namakan fail mengikut pasukan atau peranan yang diberikan (contohnya, 10-developers, 20-ops)
Gunakan peraturan berasaskan kumpulan (%developers ALL=(ALL) NOPASSWD: /usr/bin/systemctl) dan bukannya baris bagi setiap pengguna
Sentiasa tetapkan keizinan kepada 0440 dan pemilikan kepada root:root
Sahkan dengan visudo -c — ia keluar dengan nilai bukan sifar bagi sebarang ralat sintaks

#!/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"

Mengaudit Akaun Sedia Ada

Selepas penyediaan (dan mengikut jadual tetap), anda hendaklah mengaudit pangkalan data pengguna untuk mencari anomali:

Akaun UID 0 — sebarang akaun dengan UID 0 selain root ialah penemuan keselamatan kritikal
Akaun tanpa kata laluan — entri dengan medan kata laluan kosong atau ! dalam /etc/shadow
Akaun yang telah tamat tempoh tetapi masih aktif — output chage -l boleh dihuraikan secara pukal
Pengguna dengan shell tetapi tanpa direktori rumah — salah konfigurasi yang menghalang log masuk

Menjana laporan berstruktur dan menghantarnya melalui e-mel kepada pasukan keselamatan adalah mudah dengan mail atau dengan menambahkannya pada laluan log yang dipantau.

#!/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"

Mengunci, Membuka Kunci dan Membuang Akaun

Proses nyahsertai sama pentingnya dengan proses menyertai. Apabila pengguna meninggalkan organisasi, urutan yang betul ialah:

Kunci akaun dengan segera (usermod -L) — menambah awalan ! pada cincangan kata laluan shadow, lalu menghalang log masuk tanpa memadamkan data
Tarik balik sudo — buang serpihan konfigurasi sudo mereka jika ada
Pindahkan pemilikan fail mereka kepada pengurus atau akaun arkib
Arkibkan direktori rumah sebagai tarball sebelum pemadaman
Padam dengan userdel -r — membuang direktori rumah dan spool mel

usermod -U membuka kunci akaun (membuang awalan !), yang berguna untuk penggantungan sementara.

#!/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"

Menguji Skrip dengan Mod Simulasi

Skrip penyediaan pengeluaran mesti boleh diuji tanpa kesan sampingan. Laksanakan mod simulasi menggunakan bendera DRY_RUN yang menggantikan semua perintah yang mengubah keadaan dengan stub echo.

Coraknya mudah: takrifkan pembantu run() yang sama ada melaksanakan atau menggemakan perintah bergantung pada bendera tersebut. Pendekatan ini bermakna:

Setiap laluan kod diuji semasa pengujian
Output menunjukkan dengan tepat perkara yang akan berlaku dalam pelaksanaan sebenar
Saluran paip CI boleh mengesahkan logik tanpa akses root

Lengkapkan simulasi dengan awalan pengguna ujian khusus (contohnya, test_) yang memudahkan pembersihan selepas ujian integrasi.

#!/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

Perintah Manakah yang Patut Digunakan untuk Menambahkan Pengguna kepada Kumpulan Tambahan Tanpa Membuang Keahlian Kumpulan Sedia Ada?

Dalam skrip penyediaan pukal, anda perlu memberikan pengguna sedia ada keahlian dalam kumpulan auditors. Pengguna itu sudah menjadi ahli kumpulan developers dan staff. Perintah manakah yang mengekalkan semua keahlian sedia ada sambil menambahkan keahlian baharu?

Jawab dalam pelajaran interaktif

Imbas Kembali Pelajaran: Mengautomatikkan Penyediaan Pengguna dan Kumpulan

Dalam pelajaran ini, anda membina kit alat penyediaan pengguna lengkap bertaraf pengeluaran. Berikut ialah perkara penting yang dipelajari:

Huraikan input secara defensif — gunakan gelung IFS/read, langkau baris kosong dan ulasan, serta sahkan medan sebelum sebarang panggilan sistem
Asas useradd — sentiasa gunakan -m (rumah), -s (shell), -c (ulasan) dan -G (kumpulan); semak kewujudan dengan id terlebih dahulu untuk idempotensi
Kata laluan — tetapkan melalui stdin chpasswd supaya teks biasa tidak terdapat dalam argumen proses; kuatkuasakan penetapan semula pada log masuk pertama dengan chage -d 0
chage untuk dasar — piawaikan tempoh sah maksimum (-M), bilangan hari amaran (-W) dan penguncian kerana tidak aktif (-I) merentas semua akaun bukan sistem
Keahlian kumpulan — gunakan gpasswd -a atau usermod -aG (dengan bendera -a) untuk menambah, bukannya menggantikan, keahlian
Serpihan konfigurasi sudo — tulis ke /etc/sudoers.d/, sahkan dengan visudo -c -f sebelum memasang, dan tetapkan keizinan 0440 root:root
Proses nyahsertai — kunci (usermod -L), arkibkan direktori rumah, kemudian padam; jangan sekali-kali langkau langkah pengarkiban
Mod simulasi — balut perintah yang mengubah keadaan dalam pembantu run() supaya saluran paip boleh mengesahkan logik tanpa kesan sampingan root

Menggabungkan corak ini memberikan anda lapisan automasi pengurusan identiti Linux yang boleh diulang, boleh diaudit dan selamat pada apa-apa skala.

Percuma untuk bermula

Pelajari Kem Intensif DevOps dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 142
Pelajaran: 568

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mengautomatikkan Penyediaan Pengguna dan Kumpulan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif DevOps, termasuk “Mengautomatikkan Penyediaan Pengguna dan Kumpulan”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kem Intensif DevOps merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mengautomatikkan Penyediaan Pengguna dan Kumpulan”?

Cipta, ubah suai dan audit akaun secara pukal menggunakan useradd, chage dan pengurusan serpihan sudoers Anda berlatih Kem Intensif DevOps menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif DevOps?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif DevOps di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Mengautomatikkan Penyediaan Pengguna dan Kumpulan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif DevOps ini?

Ya. Setiap pelajaran Kem Intensif DevOps menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Mengautomatikkan Penyediaan Pengguna dan Kumpulan
Mengawal Perkhidmatan systemd dan Menulis Fail Unit
Automasi Cakera, Sistem Fail dan Lekapan
Membina Skrip Pemeriksaan Kesihatan Sistem dan Amaran

← Kembali ke Kem Intensif DevOps