Mestring av Linux-kommandolinjen og Bash-skripting · leksjon

Automatisering av bruker- og gruppeopprettelse

Opprett, endre og kontroller kontoer i store mengder ved hjelp av useradd, chage og håndtering av sudoers-fragmenter.

Leksjon 1 av 413 trinn

Automatisering av bruker- og gruppeopprettelse er en gratis leksjon i Mestring av Linux-kommandolinjen og Bash-skripting på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Mestring av Linux-kommandolinjen og Bash-skripting, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Mestring av Linux-kommandolinjen og Bash-skripting inneholder totalt 4 leksjoner.

Hvorfor automatisere klargjøring av brukere?

Det fungerer fint å administrere brukere én om gangen med useradd når det bare er snakk om noen få kontoer, men virksomhetsmiljøer oppretter jevnlig dusinvis eller hundrevis av brukere samtidig. Manuelle kommandoer blir lett utsatt for feil, inkonsistente og vanskelige å revidere.

Bash-skript lar Dem:

Opprette brukere med standardiserte innstillinger (skall, hjemmekatalog og passordpolicy) hver gang
Les en CSV- eller tekstfil med nye ansatte og klargjøre dem i én kjøring
Loggføre alle handlinger slik at De har et revisjonsspor for etterlevelse
Integrere med pipelines for konfigurasjonsstyring (Ansible, Chef, Jenkins)

Denne leksjonen viser hvordan De bygger et produksjonsklart skript for klargjøring av brukere fra grunnen av, med gjennomgang av useradd, chage, usermod, gruppeadministrasjon, sudoers-fragmenter og revisjon etter kjøring.

Lese en brukerliste for masseoppretting

Det kanoniske inndataformatet for masseklargjøring er en avgrenset tekstfil — én post per linje. En typisk CSV-fil kan se slik ut:

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

Bruk IFS og read i en while-løkke for å analysere filen på en trygg måte. Ved å hoppe over overskriftslinjen med tail -n +2 blir logikken ryddig.

Viktige defensive metoder:

Fjern innledende og avsluttende mellomrom fra hvert felt
Hopp over tomme linjer og kommentarl injer som begynner med #
Valider at obligatoriske felt ikke er tomme, før De kaller systemkommandoer

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

Opprette brukere med useradd

useradd er verktøyet på lavt nivå som skriver til /etc/passwd, /etc/shadow og /etc/group. De viktigste flaggene for skripting er:

-m — opprett hjemmekatalogen
-s — angi innloggingsskallet
-c — GECOS-kommentarfelt (fullt navn)
-G — tilleggsgrupper (kommaseparert)
-e — kontoens utløpsdato (YYYY-MM-DD)

Kontroller alltid om brukeren allerede finnes med id før De kaller useradd. Kjøring på en eksisterende bruker returnerer avslutningskode 9 og skriver ut en feil som kan fylle loggene unødvendig.

Merk: useradd krever root. Legg inn en rettighetssjekk øverst i skriptet.

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

Angi innledende passord på en sikker måte

Hardkod aldri passord i skript. To sikre metoder for masseklargjøring er:

Generer et tilfeldig innledende passord med openssl rand eller /dev/urandom, skriv det ut én gang, og tving brukeren til å endre det ved første innlogging
Angi et forhåndshashet passord ved å bruke usermod -p med en SHA-512-hash, slik at klarteksten aldri vises i prosesslisten

chpasswd er det anbefalte verktøyet for å angi passord i skript — det leser par med formatet username:password fra stdin, slik at passordet ikke vises blant kommandolinjeargumentene (synlig via ps).

Etter at passordet er angitt, bruker De chage -d 0 for å tvinge frem en umiddelbar tilbakestilling av passordet ved neste innlogging.

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

Administrere passordalder med chage

chage (change age) styrer passordets alderspolicy, som er lagret i /etc/shadow. Sikkerhetspolicyer i virksomheter krever vanligvis:

Maksimal passordalder (for eksempel 90 dager)
Minimum antall dager før et passord kan endres igjen
Varslingsperiode før utløp
Låsing av inaktiv konto etter siste bruk av passordet

Viktige chage-flagg:

-M <days> — maksimal passordalder
-m <days> — minste passordalder
-W <days> — antall varseldager før utløp
-I <days> — antall inaktive dager før kontoen låses
-E <date> — absolutt utløpsdato for kontoen
-l — vis gjeldende innstillinger for en bruker

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

Masseadministrasjon av grupper

Grupper er den primære mekanismen for å kontrollere tilgang til ressurser. Et klargjøringsskript må sørge for at nødvendige grupper finnes før brukere legges til i dem — useradd -G nonexistent vil mislykkes.

Bruk groupadd idempotent ved å kontrollere avslutningskoden: den returnerer 9 hvis gruppen allerede finnes. Idiomet getent group <name> er et portabelt og lettlest alternativ til å søke med grep i /etc/group.

gpasswd -a legger en bruker til i en gruppe uten å erstatte eksisterende medlemskap (i motsetning til usermod -G, som erstatter listen over tilleggsgrupper).

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

Fullstendig skript for masseklargjøring

La oss sette alt sammen: Ett enkelt skript leser en CSV-fil, oppretter brukere og grupper, angir passordpolicy, loggfører alle handlinger og håndterer feil på en kontrollert måte uten å stoppe hele batchen.

Viktige designvalg i skriptet nedenfor:

En LOG_FILE med tidsstempler registrerer alle operasjoner for revisjon
Feil for enkeltbrukere loggføres, men avbryter ikke løkken (|| log_error)
Skriptet er idempotent — det er trygt å kjøre på nytt etter delvise feil
All utskrift går både til terminalen og loggfilen via 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 ==="

Administrere sudoers-fragmenter

Det er farlig å redigere /etc/sudoers direkte — en syntaksfeil kan stenge alle ute fra sudo. Den sikre fremgangsmåten er å bruke drop-in-filer i /etc/sudoers.d/, der hver fil valideres med visudo -c -f før den installeres.

Anbefalte fremgangsmåter for sudoers-fragmenter:

Gi filene navn etter teamet eller rollen de gir tilgang til (for eksempel 10-developers, 20-ops)
Bruk gruppebaserte regler (%developers ALL=(ALL) NOPASSWD: /usr/bin/systemctl) i stedet for linjer per bruker
Angi alltid rettighetene til 0440 og eieren til root:root
Valider med visudo -c — kommandoen returnerer en verdi ulik null ved enhver syntaksfeil

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

Revidere eksisterende kontoer

Etter klargjøring, og regelmessig deretter, bør De revidere brukerdatabasen for avvik:

Kontoer med UID 0 — enhver konto med UID 0 bortsett fra root er et kritisk sikkerhetsfunn
Kontoer uten passord — oppføringer med et tomt passordfelt eller feltet ! i /etc/shadow
Utløpte kontoer som fortsatt er aktive — utdata fra chage -l kan analyseres samlet
Brukere med skall, men uten hjemmekatalog — en feilkonfigurering som hindrer innlogging

Det er enkelt å generere en strukturert rapport og sende den på e-post til sikkerhetsteamet med mail, eller ved å legge den til i en overvåket loggbane.

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

Låse, låse opp og fjerne kontoer

Avslutning av brukertilgang er like viktig som opprettelse. Når en bruker slutter, er riktig rekkefølge:

Lås kontoen umiddelbart (usermod -L) — setter ! foran passordhashen i shadow-filen og hindrer innlogging uten å slette data
Trekk tilbake sudo-tilgang — fjern sudoers-fragmentet deres hvis det finnes
Overfør eierskapet til filene deres til en leder eller arkivkonto
Arkiver hjemmekatalogen som en tar-fil før sletting
Slett med userdel -r — fjerner hjemmekatalogen og e-postkøen

usermod -U låser opp en konto (fjerner prefikset !), noe som er nyttig ved midlertidig suspensjon.

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

Teste skriptet med en tørrkjøringsmodus

Skript for produksjonsklargjøring må kunne testes uten bivirkninger. Implementer en tørrkjøringsmodus ved hjelp av et DRY_RUN-flagg som erstatter alle kommandoer som endrer systemet, med echo-stubber.

Mønsteret er enkelt: Definer en hjelpefunksjon run() som enten kjører eller skriver ut kommandoen, avhengig av flagget. Denne fremgangsmåten innebærer at:

Alle kodebaner kjøres under testing
Utdataene viser nøyaktig hva som ville skjedd ved en faktisk kjøring
CI-pipelines kan validere logikken uten root-tilgang

Suppler tørrkjøring med et eget prefiks for testbrukere (for eksempel test_), slik at de enkelt kan ryddes opp etter integrasjonstester.

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

Hvilken kommando skal De bruke for å legge en bruker til i en tilleggsgruppe uten å fjerne eksisterende gruppemedlemskap?

I et skript for masseklargjøring må De tildele en eksisterende bruker til gruppen auditors. Brukeren er allerede medlem av developers og staff. Hvilken kommando bevarer alle eksisterende medlemskap samtidig som det nye legges til?

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen: Automatisere klargjøring av brukere og grupper

I denne leksjonen har De bygget et komplett og produksjonsklart verktøysett for klargjøring av brukere. Her er de viktigste punktene:

Analyser inndata defensivt — bruk IFS/read-løkker, hopp over tomme linjer og kommentarer, og valider feltene før alle systemkall
Det viktigste i useradd — bruk alltid -m (hjem), -s (skall), -c (kommentar) og -G (grupper); kontroller om brukeren finnes med id først for idempotens
Passord — angi dem via stdin til chpasswd for å holde klarteksten borte fra prosessargumentene; krev tilbakestilling ved første innlogging med chage -d 0
chage for policy — standardiser maksimal alder (-M), varseldager (-W) og inaktivitetslås (-I) for alle kontoer som ikke er systemkontoer
Gruppemedlemskap — bruk gpasswd -a eller usermod -aG (med flagget -a) for å legge til medlemskap i stedet for å erstatte dem
Sudoers-fragmenter — skriv til /etc/sudoers.d/, valider med visudo -c -f før installasjon, og angi rettighetene 0440 root:root
Avslutning av brukertilgang — lås (usermod -L), arkiver hjemmekatalogen og slett deretter; hopp aldri over arkiveringstrinnet
Tørrkjøringsmodus — pakk kommandoer som endrer systemet inn i en hjelpefunksjon run(), slik at pipelines kan kontrollere logikken uten bivirkninger som krever root

Ved å kombinere disse mønstrene får De et repeterbart, reviderbart og sikkert automatiseringslag for identitetsadministrasjon i Linux, uansett skala.

Gratis å komme i gang

Lær deg Bash med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 22
Leksjoner: 88

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Automatisering av bruker- og gruppeopprettelse» gratis?

Ja – hele teksten i «Automatisering av bruker- og gruppeopprettelse» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Mestring av Linux-kommandolinjen og Bash-skripting-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Mestring av Linux-kommandolinjen og Bash-skripting inneholder totalt 4 leksjoner.

Hva lærer jeg i «Automatisering av bruker- og gruppeopprettelse»?

Opprett, endre og kontroller kontoer i store mengder ved hjelp av useradd, chage og håndtering av sudoers-fragmenter. Du øver på Mestring av Linux-kommandolinjen og Bash-skripting med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Mestring av Linux-kommandolinjen og Bash-skripting?

Ingen tidligere erfaring er nødvendig. Mestring av Linux-kommandolinjen og Bash-skripting på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Automatisering av bruker- og gruppeopprettelse»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Mestring av Linux-kommandolinjen og Bash-skripting-leksjonen?

Ja. Alle Mestring av Linux-kommandolinjen og Bash-skripting-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Automatisering av bruker- og gruppeopprettelse
Styring av systemd-tjenester og skriving av unit-filer
Automatisering av disker, filsystemer og montering
Bygging av skript for systemsjekk og varsling

← Tilbake til Mestring av Linux-kommandolinjen og Bash-skripting