DevOps Bootcamp · บทเรียน

การทำงานอัตโนมัติสำหรับการจัดเตรียมผู้ใช้และกลุ่ม

สร้าง แก้ไข และตรวจสอบบัญชีจำนวนมากด้วย useradd, chage และการจัดการส่วนย่อยของ sudoers

การทำงานอัตโนมัติสำหรับการจัดเตรียมผู้ใช้และกลุ่ม เป็นบทเรียน DevOps Bootcamp ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน DevOps Bootcamp และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส DevOps Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน

เหตุใดจึงต้องทำให้การจัดเตรียมผู้ใช้เป็นอัตโนมัติ

การจัดการผู้ใช้ทีละรายด้วย useradd ทำงานได้ดีสำหรับบัญชีจำนวนไม่มาก แต่สภาพแวดล้อมระดับองค์กรมักต้องเพิ่มผู้ใช้ใหม่หลายสิบหรือหลายร้อยรายพร้อมกัน คำสั่งที่ป้อนด้วยตนเองทำให้เกิดข้อผิดพลาดได้ง่าย ไม่สอดคล้องกัน และไม่สามารถตรวจสอบย้อนหลังได้

การเขียนสคริปต์ Bash ช่วยให้คุณสามารถ:

สร้างผู้ใช้ด้วยการตั้งค่ามาตรฐานเดียวกันทุกครั้ง (เชลล์ ไดเรกทอรีบ้าน นโยบายรหัสผ่าน)
อ่าน CSV หรือไฟล์ข้อความของพนักงานใหม่ แล้วจัดเตรียมผู้ใช้ทั้งหมดในการทำงานครั้งเดียว
บันทึกทุกการดำเนินการ เพื่อให้มีหลักฐานการตรวจสอบสำหรับการปฏิบัติตามข้อกำหนด
ผสานการทำงานกับกระบวนการจัดการการกำหนดค่าแบบต่อเนื่อง (Ansible, Chef, Jenkins)

บทเรียนนี้จะแนะนำการสร้างสคริปต์จัดเตรียมผู้ใช้ระดับพร้อมใช้งานจริงตั้งแต่ต้น โดยครอบคลุม useradd, chage, usermod, การจัดการกลุ่ม ไฟล์เสริมของ sudoers และการตรวจสอบหลังการทำงาน

การอ่านรายการผู้ใช้จำนวนมาก

รูปแบบข้อมูลนำเข้ามาตรฐานสำหรับการจัดเตรียมผู้ใช้จำนวนมากคือไฟล์ข้อความที่ใช้ตัวคั่น โดยมีหนึ่งระเบียนต่อหนึ่งบรรทัด CSV ทั่วไปอาจมีลักษณะดังนี้:

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

ใช้ IFS และ read ภายในลูป while เพื่อแยกวิเคราะห์อย่างปลอดภัย การข้ามบรรทัดส่วนหัวด้วย tail -n +2 ช่วยให้ตรรกะอ่านง่าย

แนวทางป้องกันที่สำคัญ:

ตัดช่องว่างด้านหน้าและด้านหลังของแต่ละฟิลด์
ข้ามบรรทัดว่างและบรรทัดคำอธิบายที่ขึ้นต้นด้วย #
ตรวจสอบว่าฟิลด์บังคับมีค่า ก่อนเรียกใช้คำสั่งระบบใด ๆ

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

useradd เป็นเครื่องมือระดับล่างที่เขียนข้อมูลลงใน /etc/passwd, /etc/shadow และ /etc/group ตัวเลือกที่สำคัญที่สุดสำหรับการเขียนสคริปต์มีดังนี้:

-m — สร้างไดเรกทอรีบ้าน
-s — กำหนดเชลล์เข้าสู่ระบบ
-c — ฟิลด์คำอธิบาย GECOS (ชื่อเต็ม)
-G — กลุ่มเสริม (คั่นด้วยจุลภาค)
-e — วันหมดอายุบัญชี (YYYY-MM-DD)

ตรวจสอบเสมอว่าผู้ใช้มีอยู่แล้วหรือไม่ด้วย id ก่อนเรียกใช้ useradd เพราะการเรียกใช้กับผู้ใช้ที่มีอยู่แล้วจะคืนรหัสออก 9 และพิมพ์ข้อผิดพลาดซึ่งอาจทำให้บันทึกการทำงานรกรุงรัง

หมายเหตุ: useradd ต้องใช้สิทธิ์ root โปรดครอบสคริปต์ด้วยการตรวจสอบสิทธิ์ตั้งแต่ต้นสคริปต์

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

การตั้งรหัสผ่านเริ่มต้นอย่างปลอดภัย

อย่าฝังรหัสผ่านไว้ในสคริปต์โดยเด็ดขาด แนวทางที่ปลอดภัยสองวิธีสำหรับการจัดเตรียมผู้ใช้จำนวนมาก ได้แก่:

สร้างรหัสผ่านเริ่มต้นแบบสุ่ม ด้วย openssl rand หรือ /dev/urandom แสดงรหัสผ่านเพียงครั้งเดียว และบังคับให้ผู้ใช้เปลี่ยนรหัสผ่านเมื่อเข้าสู่ระบบครั้งแรก
ตั้งรหัสผ่านที่แฮชไว้ล่วงหน้า โดยใช้ usermod -p กับแฮช SHA-512 เพื่อไม่ให้รหัสผ่านแบบข้อความธรรมดาปรากฏในรายการโพรเซส

chpasswd เป็นเครื่องมือที่แนะนำสำหรับการตั้งรหัสผ่านด้วยสคริปต์ — เครื่องมือนี้อ่านคู่ username:password จาก stdin ดังนั้นรหัสผ่านจะไม่ปรากฏในอาร์กิวเมนต์บรรทัดคำสั่ง (ซึ่งดูได้ผ่าน ps)

หลังตั้งรหัสผ่านแล้ว ให้ใช้ chage -d 0 เพื่อบังคับให้รีเซ็ตรหัสผ่านทันทีเมื่อเข้าสู่ระบบครั้งถัดไป

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

chage (เปลี่ยนอายุ) ควบคุมนโยบายอายุรหัสผ่านที่จัดเก็บไว้ใน /etc/shadow โดยทั่วไปนโยบายความปลอดภัยระดับองค์กรกำหนดให้มี:

อายุรหัสผ่านสูงสุด (เช่น 90 วัน)
จำนวนวันขั้นต่ำก่อนจะเปลี่ยนรหัสผ่านได้อีกครั้ง
ช่วงเวลาแจ้งเตือนก่อนหมดอายุ
การล็อกบัญชีเมื่อไม่มีการใช้งานหลังจากใช้รหัสผ่านครั้งล่าสุด

ตัวเลือก chage ที่สำคัญ:

-M <days> — อายุรหัสผ่านสูงสุด
-m <days> — อายุรหัสผ่านขั้นต่ำ
-W <days> — จำนวนวันแจ้งเตือนก่อนหมดอายุ
-I <days> — จำนวนวันไม่ใช้งานก่อนล็อกบัญชี
-E <date> — วันหมดอายุบัญชีแบบกำหนดตายตัว
-l — แสดงการตั้งค่าปัจจุบันของผู้ใช้

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

การจัดการกลุ่มจำนวนมาก

กลุ่มเป็นกลไกหลักสำหรับควบคุมการเข้าถึงทรัพยากร สคริปต์จัดเตรียมผู้ใช้ต้องตรวจสอบให้แน่ใจว่ากลุ่มที่จำเป็นมีอยู่ก่อนเพิ่มผู้ใช้เข้ากลุ่มเหล่านั้น — useradd -G nonexistent จะทำงานล้มเหลว

ใช้ groupadd แบบทำซ้ำได้อย่างปลอดภัย โดยตรวจสอบรหัสออก: คำสั่งนี้จะคืนค่า 9 หากกลุ่มมีอยู่แล้ว รูปแบบคำสั่ง getent group <name> เป็นทางเลือกที่พกพาได้และอ่านเข้าใจง่ายกว่าการใช้ grep กับ /etc/group

gpasswd -a เพิ่มผู้ใช้เข้ากลุ่มโดยไม่แทนที่การเป็นสมาชิกเดิม (ต่างจาก usermod -G ซึ่งจะแทนที่รายการกลุ่มเสริม)

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

สคริปต์จัดเตรียมผู้ใช้จำนวนมากฉบับสมบูรณ์

เมื่อนำทุกอย่างมารวมกัน: สคริปต์เดียวจะอ่าน CSV สร้างผู้ใช้และกลุ่ม ตั้งนโยบายรหัสผ่าน บันทึกทุกการดำเนินการ และจัดการข้อผิดพลาดอย่างเหมาะสมโดยไม่หยุดการทำงานทั้งชุด

การตัดสินใจด้านการออกแบบที่สำคัญในสคริปต์ด้านล่าง:

LOG_FILE พร้อมประทับเวลาจะบันทึกการดำเนินการทั้งหมดสำหรับการตรวจสอบ
ข้อผิดพลาดของผู้ใช้แต่ละรายจะถูกบันทึกไว้ แต่ไม่ทำให้ลูปหยุดทำงาน (|| log_error)
สคริปต์ทำงานซ้ำได้อย่างปลอดภัย — สามารถเรียกใช้ใหม่หลังเกิดความล้มเหลวบางส่วน
ผลลัพธ์ทั้งหมดจะส่งไปทั้งยังเทอร์มินัลและไฟล์บันทึกผ่าน 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 ==="

การจัดการส่วนเสริมของ sudoers

การแก้ไข /etc/sudoers โดยตรงเป็นเรื่องอันตราย — ข้อผิดพลาดทางไวยากรณ์จะทำให้ทุกคนถูกป้องกันไม่ให้ใช้ sudo แนวทางที่ปลอดภัยคือใช้ ไฟล์เสริม ใน /etc/sudoers.d/ โดยตรวจสอบความถูกต้องของแต่ละไฟล์ด้วย visudo -c -f ก่อนนำไปติดตั้ง

แนวทางปฏิบัติที่ดีสำหรับส่วนเสริมของ sudoers:

ตั้งชื่อไฟล์ตามทีม��รือบทบาทที่ไฟล์อนุญาต (เช่น 10-developers, 20-ops)
ใช้กฎตามกลุ่ม (%developers ALL=(ALL) NOPASSWD: /usr/bin/systemctl) แทนบรรทัดที่ระบุผู้ใช้แต่ละราย
กำหนดสิทธิ์เป็น 0440 และเจ้าของเป็น root:root เสมอ
ตรวจสอบด้วย visudo -c — คำสั่งจะคืนค่าที่ไม่ใช่ศูนย์หากพบข้อผิดพลาดทางไวยากรณ์ใด ๆ

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

การตรวจสอบบัญชีที่มีอยู่

หลังการจัดเตรียมผู้ใช้ (และตามกำหนดเวลาอย่างสม่ำเสมอ) ควรตรวจสอบฐานข้อมูลผู้ใช้เพื่อค้นหาความผิดปกติ:

บัญชี UID 0 — บัญชีใดก็ตามที่มี UID 0 นอกเหนือจาก root ถือเป็นประเด็นด้านความปลอดภัยร้ายแรง
บัญชีที่ไม่มีรหัสผ่าน — รายการที่มีฟิลด์รหัสผ่านว่างเปล่าหรือเป็น ! ใน /etc/shadow
บัญชีหมดอายุที่ยังใช้งานอยู่ — สามารถแยกวิเคราะห์ผลลัพธ์จาก chage -l จำนวนมากได้
ผู้ใช้ที่มีเชลล์แต่ไม่มีไดเรกทอรีบ้าน — การกำหนดค่าผิดพลาดที่ทำให้เข้าสู่ระบบไม่ได้

การสร้างรายงานที่มีโครงสร้างและส่งอีเมลให้ทีมความปลอดภัยทำได้ง่ายด้วย mail หรือโดยเพิ่มข้อมูลต่อท้ายเส้นทางบันทึกที่มีการตรวจติดตาม

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

การล็อก การปลดล็อก และการลบบัญชี

การยกเลิกสิทธิ์ผู้ใช้สำคัญไม่แพ้การเพิ่มผู้ใช้ใหม่ เมื่อผู้ใช้ออกจากองค์กร ลำดับที่ถูกต้องคือ:

ล็อก บัญชีทันที (usermod -L) — เติม ! ไว้หน้าค่าแฮชรหัสผ่านใน shadow เพื่อป้องกันการเข้าสู่ระบบโดยไม่ลบข้อมูล
เพิกถอนสิทธิ์ sudo — ลบส่วนเสริมของ sudoers หากมีอยู่
โอนความเป็นเจ้าของ ไฟล์ของผู้ใช้ให้ผู้จัดการหรือบัญชีเก็บถาวร
จัดเก็บถาวร ไดเรกทอรีบ้านเป็นไฟล์ tar ก่อนลบ
ลบ ด้วย userdel -r — ลบไดเรกทอรีบ้านและคิวจดหมาย

usermod -U ปลดล็อกบัญชี (ลบคำนำหน้า !) ซึ่งมีประโยชน์สำหรับการระงับบัญชีชั่วคราว

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

การทดสอบสคริปต์ด้วยโหมดทดลองทำงาน

สคริปต์จัดเตรียมผู้ใช้สำหรับใช้งานจริงต้องสามารถทดสอบได้โดยไม่ก่อให้เกิดผลข้างเคียง ให้ใช้โหมดทดลองทำงานด้วยแฟล็ก DRY_RUN ซึ่งแทนที่คำสั่งที่เปลี่ยนแปลงข้อมูลทั้งหมดด้วยโครงจำลอง echo

รูปแบบนี้เรียบง่าย: กำหนดตัวช่วย run() ให้เรียกใช้หรือแสดงคำสั่งแทน โดยขึ้นอยู่กับแฟล็ก วิธีนี้หมายความว่า:

เส้นทางการทำงานของโค้ดทุกเส้นทางจะถูกทดสอบระหว่างการทดสอบ
ผลลัพธ์จะแสดงสิ่งที่จะเกิดขึ้นอย่างชัดเจนหากเรียกใช้จริง
กระบวนการ CI สามารถตรวจสอบตรรกะได้โดยไม่ต้องใช้สิทธิ์ root

ใช้โหมดทดลองทำงานร่วมกับคำนำหน้าผู้ใช้สำหรับทดสอบโดยเฉพาะ (เช่น test_) เพื่อให้ล้างข้อมูลได้ง่ายหลังการทดสอบการผสานรวม

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

ควรใช้คำสั่งใดเพื่อเพิ่มผู้ใช้เข้ากลุ่มเสริมโดยไม่ลบการเป็นสมาชิกกลุ่มเดิม

ในสคริปต์จัดเตรียมผู้ใช้จำนวนมาก คุณต้องกำหนดให้ผู้ใช้ที่มีอยู่แล้วเป็นสมาชิกกลุ่ม auditors ผู้ใช้นี้เป็นสมาชิกกลุ่ม developers และ staff อยู่แล้ว คำสั่งใดจะคงการเป็นสมาชิกกลุ่มเดิมทั้งหมดไว้พร้อมกับเพิ่มกลุ่มใหม่

สรุปบทเรียน: การทำให้การจัดเตรียมผู้ใช้และกลุ่มเป็นอัตโนมัติ

ในบทเรียนนี้ คุณได้สร้างชุดเครื่องมือจัดเตรียมผู้ใช้ระดับพร้อมใช้งานจริงอย่างครบถ้วน ประเด็นสำคัญมีดังนี้:

แยกวิเคราะห์ข้อมูลนำเข้าอย่างรัดกุม — ใช้ลูป IFS/read ข้ามบรรทัดว่างและบรรทัดคำอธิบาย และตรวจสอบฟิลด์ก่อนเรียกใช้ระบบใด ๆ
พื้นฐานสำคัญของ useradd — ใช้ -m (ไดเรกทอรีบ้าน), -s (เชลล์), -c (คำอธิบาย) และ -G (กลุ่ม) เสมอ ตรวจสอบการมีอยู่ด้วย id ก่อนเพื่อให้เรียกใช้ซ้ำได้อย่างปลอดภัย
รหัสผ่าน — ตั้งค่าผ่าน stdin ของ chpasswd เพื่อไม่ให้ข้อความธรรมดาปรากฏในอาร์กิวเมนต์ของโพรเซส และบังคับให้รีเซ็ตเมื่อเข้าสู่ระบบครั้งแรกด้วย chage -d 0
ใช้ chage สำหรับนโยบาย — กำหนดอายุสูงสุด (-M) จำนวนวันแจ้งเตือน (-W) และการล็อกเมื่อไม่มีการใช้งาน (-I) ให้เป็นมาตรฐานเดียวกันในบัญชีที่ไม่ใช่บัญชีระบบทั้งหมด
การเป็นสมาชิกกลุ่ม — ใช้ gpasswd -a หรือ usermod -aG (พร้อมแฟล็ก -a) เพื่อเพิ่มต่อท้ายแทนการแทนที่สมาชิกเดิม
ส่วนเสริมของ sudoers — เขียนลงใน /etc/sudoers.d/ ตรวจสอบด้วย visudo -c -f ก่อนติดตั้ง และกำหนดสิทธิ์เป็น 0440 root:root
การยกเลิกสิทธิ์ผู้ใช้ — ล็อก (usermod -L) จัดเก็บไดเรกทอรีบ้าน แล้วจึงลบ อย่าข้ามขั้นตอนการจัดเก็บถาวรโดยเด็ดขาด
โหมดทดลองทำงาน — ครอบคำสั่งที่เปลี่ยนแปลงข้อมูลไว้ในตัวช่วย run() เพื่อให้กระบวนการต่อเนื่องสามารถตรวจสอบตรรกะได้โดยไม่ก่อผลกระทบจากการใช้สิทธิ์ root

เมื่อนำรูปแบบเหล่านี้มารวมกัน คุณจะได้ชั้นการทำงานอัตโนมัติสำหรับจัดการข้อมูลประจำตัวบน Linux ที่ทำซ้ำได้ ตรวจสอบย้อนหลังได้ และปลอดภัยในทุกระดับ

คำถามที่พบบ่อย

บทเรียน “การทำงานอัตโนมัติสำหรับการจัดเตรียมผู้ใช้และกลุ่ม” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การทำงานอัตโนมัติสำหรับการจัดเตรียมผู้ใช้และกลุ่ม” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส DevOps Bootcamp ให้อัปเกรดเป็น CoddyKit PRO คอร์ส DevOps Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การทำงานอัตโนมัติสำหรับการจัดเตรียมผู้ใช้และกลุ่ม”

สร้าง แก้ไข และตรวจสอบบัญชีจำนวนมากด้วย useradd, chage และการจัดการส่วนย่อยของ sudoers คุณปฏิบัติ DevOps Bootcamp ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน DevOps Bootcamp หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน DevOps Bootcamp บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การทำงานอัตโนมัติสำหรับการจัดเตรียมผู้ใช้และกลุ่ม” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน DevOps Bootcamp นี้ได้ไหม

ได้ บทเรียน DevOps Bootcamp ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

การทำงานอัตโนมัติสำหรับการจัดเตรียมผู้ใช้และกลุ่ม
การควบคุมบริการ systemd และการเขียนไฟล์ยูนิต
การทำงานอัตโนมัติด้านดิสก์ ระบบไฟล์ และการเมานต์
การสร้างสคริปต์ตรวจสอบสุขภาพระบบและแจ้งเตือน

← กลับไปที่ DevOps Bootcamp