DevOps Bootcamp · บทเรียน

ไฟล์ชั่วคราวและไดเรกทอรีล็อกที่ปลอดภัย

ใช้ mktemp และ flock เพื่อสร้างทรัพยากรชั่วคราวที่ปราศจากการแข่งขัน และป้องกันการเรียกใช้สคริปต์พร้อมกัน

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

เหตุใดไฟล์ชั่วคราวจึงเป็นความเสี่ยงด้านความปลอดภัย

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

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

เครื่องมือหลักสองรายการที่กำจัดปัญหาเหล่านี้คือ mktemp และ flock บทเรียนนี้จะแสดงวิธีใช้เครื่องมือทั้งสองอย่างปลอดภัยและเชิงป้องกัน

การสร้างไฟล์ชั่วคราวที่ปลอดภัยด้วย mktemp

mktemp สร้างไฟล์ชั่วคราวด้วยชื่อแบบสุ่มที่คาดเดาไม่ได้และส่งคืนเส้นทางของไฟล์ คำสั่งนี้สร้างไฟล์แบบอะตอมิก จึงไม่มีกระบวนการอื่นแย่งใช้ชื่อไฟล์ไปก่อนได้

ไวยากรณ์: mktemp [TEMPLATE] — แม่แบบต้องลงท้ายด้วยอักขระ X อย่างน้อยสามตัว
X แต่ละตัวจะถูกแทนที่ด้วยอักขระแบบสุ่ม ทำให้ได้ชื่อที่ไม่ซ้ำ เช่น /tmp/script.aB3kQz
ไฟล์จะถูกสร้างด้วยสิทธิ์ 0600 (เจ้าของเท่านั้นที่อ่านได้) โดยอัตโนมัติ

ให้เก็บเส้นทางที่ส่งคืนไว้ในตัวแปรทันทีเสมอ เพื่อให้คุณอ้างถึงและลบไฟล์ได้ในภายหลัง

#!/usr/bin/env bash
set -euo pipefail

# Create a secure temp file
TMPFILE=$(mktemp /tmp/myapp.XXXXXX)
echo "Temp file created at: $TMPFILE"

# Write data to it
echo "some intermediate result" > "$TMPFILE"

# Read it back
cat "$TMPFILE"

# Clean up
rm -f "$TMPFILE"

ล้างทรัพยากรเสมอด้วย trap

หากสคริปต์ของคุณออกจากการทำงานโดยไม่คาดคิด — เนื่องจากข้อผิดพลาด สัญญาณ หรือการที่ set -e ทำงาน — ไฟล์ชั่วคราวจะถูกทิ้งไว้ เว้นแต่คุณจะลงทะเบียนตัวจัดการล้างทรัพยากร

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

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

วิธีนี้รับประกันว่าจะไม่มีไฟล์ค้างแม้ว่าสคริปต์จะถูกหยุดระหว่างการทำงาน

#!/usr/bin/env bash
set -euo pipefail

TMPFILE=$(mktemp /tmp/report.XXXXXX)

# Register cleanup before doing any real work
cleanup() {
    rm -f "$TMPFILE"
    echo "Cleaned up $TMPFILE" >&2
}
trap cleanup EXIT

# Do work — even if this fails, cleanup() will run
echo "Processing..." > "$TMPFILE"
grep "result" "$TMPFILE" || true

echo "Done. File will be removed on exit."

การสร้างไดเรกทอรีชั่วคราวด้วย mktemp -d

บางครั้งคุณจำเป็นต้องใช้ไดเรกทอรีทั้งชุดเพื่อเตรียมไฟล์หลายไฟล์ เช่น การสร้างแฟ้มจัดเก็บหรือแตกไฟล์ tarball ก่อนประมวลผล ให้ใช้ mktemp -d เพื่อสร้างไดเรกทอรีชั่วคราวที่ปลอดภัย

ไดเรกทอรีจะถูกสร้างด้วยสิทธิ์ 0700 (เข้าถึงได้เฉพาะเจ้าของ)
ล้างข้อมูลด้วย rm -rf ใน trap — โปรดระวังให้ลบเฉพาะตัวแปรเท่านั้น ห้ามใช้เส้นทางที่กำหนดตายตัว
ใช้ เครื่องหมายอัญประกาศคู่ และตรวจสอบว่าตัวแปรไม่ว่างก่อนเรียกใช้ rm -rf เพื่อเพิ่มการตรวจสอบความปลอดภัยอีกชั้น

#!/usr/bin/env bash
set -euo pipefail

TMPDIR=$(mktemp -d /tmp/extract.XXXXXX)

cleanup() {
    # Guard: only rm if variable is set and non-empty
    [[ -n "${TMPDIR:-}" ]] && rm -rf "$TMPDIR"
}
trap cleanup EXIT

echo "Working in $TMPDIR"

# Simulate staging files
echo "file one" > "$TMPDIR/part1.txt"
echo "file two" > "$TMPDIR/part2.txt"

ls "$TMPDIR"
echo "All done."

ปัญหาจากการเรียกใช้สคริปต์พร้อมกัน

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

การประมวลผลซ้ำ: ระเบียนฐานข้อมูลหรือไฟล์เดียวกันถูกประมวลผลสองครั้ง
ผลลัพธ์เสียหาย: อินสแตนซ์สองชุดเขียนลงไฟล์ผลลัพธ์เดียวกันพร้อมกัน
การหยุดชะงักหรือสถานะไม่สมบูรณ์: อินสแตนซ์ทั้งสองแก้ไขทรัพยากรที่ใช้ร่วมกันในลำดับสลับกันและคาดเดาไม่ได้

วิธีแก้แบบดั้งเดิมคือเขียนไฟล์ PID แล้วตรวจสอบเมื่อเริ่มทำงาน — แต่วิธีนี้มีช่วงเวลาที่เกิดสภาวะแข่งขันระหว่างการตรวจสอบกับการเขียน วิธีแก้สมัยใหม่ที่ถูกต้องคือ flock ซึ่งใช้กลไกการล็อกแบบให้ความร่วมมือของเคอร์เนลเพื่อรับประกันการล็อกที่ปราศจากสภาวะแข่งขัน

การล็อกด้วย flock: รูปแบบคำสั่งบรรทัดเดียว

flock จะขอรับการล็อกแบบให้ความร่วมมือบนตัวอธิบายไฟล์ก่อนเรียกใช้คำสั่ง วิธีใช้ที่ง่ายที่สุดคือครอบคลุมสคริปต์ทั้งชุดจากบรรทัดคำสั่ง:

flock -n /var/lock/myscript.lock bash myscript.sh

-n (ไม่บล็อก): ออกจากการทำงานทันทีด้วยสถานะ 1 หากมีการถือครองล็อกอยู่ แทนที่จะรอ
หากไม่ใช้ -n flock จะบล็อกจนกว่าล็อกจะพร้อมใช้งาน — เหมาะสำหรับการเข้าคิว
ไฟล์ล็อกเป็นเพียงเครื่องหมายบ่งชี้ เนื้อหาภายในไม่มีความสำคัญ และสามารถเก็บไว้ระหว่างการทำงานแต่ละครั้งได้อย่างปลอดภัย
เมื่อกระบวนการที่ถือครองล็อกสิ้นสุดลง เคอร์เนลจะปล่อยล็อกโดยอัตโนมัติ — ไม่ต้องล้างข้อมูลด้วยตนเอง

#!/usr/bin/env bash
# launcher.sh — prevents concurrent runs of worker.sh
set -euo pipefail

LOCKFILE="/tmp/myworker.lock"

if ! flock -n "$LOCKFILE" bash -c 'echo "Running worker..."; sleep 2; echo "Done."'; then
    echo "Another instance is already running. Exiting." >&2
    exit 1
fi

การใช้ flock ภายในสคริปต์ด้วยตัวอธิบายไฟล์

หากต้องการล็อกภายในสคริปต์แทนการครอบสคริปต์จากภายนอก ให้ใช้ exec เพื่อเปิดตัวอธิบายไฟล์ แล้วเรียกใช้ flock กับตัวอธิบายนั้น นี่คือรูปแบบมาตรฐานที่ใช้ในสคริปต์สำหรับระบบจริง

exec 200>"$LOCKFILE" เปิดไฟล์เพื่อเขียนด้วยตัวอธิบาย 200 (และสร้างไฟล์หากยังไม่มี)
flock -n 200 พยายามล็อกตัวอธิบาย 200 โดยไม่บล็อก
เนื่องจากล็อกผูกกับตัวอธิบายไฟล์ (ไม่ใช่ชื่อไฟล์) ล็อกจึงถูกปล่อยโดยอัตโนมัติเมื่อกระบวนการเชลล์สิ้นสุดลง
โดยทั่วไปจะใช้หมายเลขตัวอธิบาย 200-299 เพื่อหลีกเลี่ยงการชนกับ stdin/stdout/stderr

#!/usr/bin/env bash
set -euo pipefail

LOCKFILE="/tmp/myjob.lock"

# Open lock file on FD 200
exec 200>"$LOCKFILE"

# Attempt non-blocking lock
if ! flock -n 200; then
    echo "ERROR: Another instance of this script is running." >&2
    exit 1
fi

echo "Lock acquired. Starting work..."
sleep 1
echo "Work complete. Lock will be released on exit."

การรวม mktemp และ flock ไว้ในสคริปต์เดียว

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

ขอรับล็อกก่อน — ก่อนสร้างไฟล์ชั่วคราวใด ๆ — เพื่อให้อินสแตนซ์เดียวเท่านั้นที่ทำงานทั้งหมด
สร้างทรัพยากรชั่วคราวหลังยืนยันว่าได้รับล็อกแล้ว
ลงทะเบียน trap ทันทีหลังสร้างทรัพยากรชั่วคราว เพื่อรับประกันการล้างข้อมูลไม่ว่าสคริปต์จะสิ้นสุดอย่างไร
ไฟล์ล็อกต้องไม่อยู่ในไดเรกทอรีชั่วคราว — ไฟล์ต้องคงอยู่ระหว่างการทำงานแต่ละครั้งเพื่อให้ flock อ้างอิงได้

#!/usr/bin/env bash
set -euo pipefail

LOCKFILE="/tmp/report_builder.lock"
exec 200>"$LOCKFILE"

if ! flock -n 200; then
    echo "Already running — aborting." >&2
    exit 1
fi

# Now safe to create temp resources
TMPDIR=$(mktemp -d /tmp/report.XXXXXX)
TMPLOG=$(mktemp /tmp/report_log.XXXXXX)

cleanup() {
    rm -rf "${TMPDIR:-}"
    rm -f  "${TMPLOG:-}"
}
trap cleanup EXIT

echo "Building report in $TMPDIR" | tee "$TMPLOG"
echo "Step 1 complete"             >> "$TMPLOG"
cat "$TMPLOG"

ไดเรกทอรีล็อกเป็นกลไกล็อกทางเลือก

ในระบบที่ไม่มี flock ให้ใช้งาน (เช่น ระบบฝังตัวบางประเภทหรือระบบไฟล์เครือข่ายอย่าง NFS) คุณสามารถใช้ ไดเรกทอรีล็อก แทนได้ การทำงานของ mkdir เป็นแบบอะตอมิกบนระบบ POSIX: คำสั่งจะสำเร็จเฉพาะเมื่อไดเรกทอรีนั้นยังไม่มีอยู่

สร้างไดเรกทอรีล็อกด้วย mkdir /tmp/myscript.lock.d — หากมีอินสแตนซ์อื่นสร้างไว้แล้ว mkdir จะล้มเหลวทันที
เก็บข้อมูลเมตา (เช่น PID) ไว้ภายในไดเรกทอรีเพื่อใช้วินิจฉัยปัญหา
ลบไดเรกทอรีใน trap เมื่อเกิด EXIT เสมอ
ข้อควรระวัง: ต่างจาก flock ตรงที่ไดเรกทอรีล็อกจะไม่ถูกปล่อยโดยอัตโนมัติหากกระบวนการถูกหยุดด้วย -9 หรือเครื่องรีบูต — ให้เพิ่มการตรวจสอบล็อกค้าง

#!/usr/bin/env bash
set -euo pipefail

LOCKDIR="/tmp/myscript.lock.d"

# Atomic mkdir — fails if directory already exists
if ! mkdir "$LOCKDIR" 2>/dev/null; then
    # Check if the holding PID is still alive
    HOLDER_PID=$(cat "$LOCKDIR/pid" 2>/dev/null || echo "")
    if [[ -n "$HOLDER_PID" ]] && kill -0 "$HOLDER_PID" 2>/dev/null; then
        echo "Locked by PID $HOLDER_PID. Exiting." >&2
        exit 1
    else
        echo "Stale lock detected. Removing and continuing." >&2
        rm -rf "$LOCKDIR"
        mkdir "$LOCKDIR"
    fi
fi

echo "$$" > "$LOCKDIR/pid"
trap 'rm -rf "$LOCKDIR"' EXIT

echo "Lock acquired via directory. Running..."
sleep 1
echo "Done."

การรอด้วยการหมดเวลาร่วมกับ flock

บางครั้งคุณอาจต้องการรอล็อกแทนการล้มเหลวทันที — แต่ไม่ต้องการรอไปตลอด flock รองรับการหมดเวลาด้วยแฟล็ก -w

flock -w 10 200 จะรอล็อกนานสูงสุด 10 วินาที จากนั้นออกด้วยสถานะ 1 หากยังไม่พร้อมใช้งาน
เหมาะอย่างยิ่งสำหรับสคริปต์ที่ควรเข้าคิวต่อจากกระบวนการก่อนหน้าซึ่งใช้เวลาไม่นาน แต่ควรยุติการรอหากกระบวนการก่อนหน้าค้าง
ใช้ -w ร่วมกับข้อความแสดงข้อผิดพลาดที่มีความหมายและมีบริบท เช่น เส้นทางไฟล์ล็อกและระยะเวลาที่รอ เพื่อให้ผู้ดูแลระบบวินิจฉัยการค้างได้อย่างรวดเร็ว

#!/usr/bin/env bash
set -euo pipefail

LOCKFILE="/tmp/data_sync.lock"
TIMEOUT=15

exec 200>"$LOCKFILE"

echo "Waiting up to ${TIMEOUT}s for lock on $LOCKFILE..."

if ! flock -w "$TIMEOUT" 200; then
    echo "ERROR: Could not acquire lock after ${TIMEOUT}s." \
         "Another instance may be hung." >&2
    exit 1
fi

echo "Lock acquired. Syncing data..."
sleep 1
echo "Sync complete."

รายการตรวจสอบเพื่อความปลอดภัย: ทรัพยากรชั่วคราวที่ปลอดภัย

ก่อนนำสคริปต์ใด ๆ ที่ใช้ไฟล์ชั่วคราวหรือการล็อกไปใช้งานจริง ให้ตรวจสอบรายการต่อไปนี้:

ใช้ mktemp ห้ามใช้เส้นทางที่กำหนดตายตัว — /tmp/myapp.tmp คาดเดาได้และอาจถูกโจมตี
เก็บเส้นทางไว้ทันที — TMPFILE=$(mktemp ...) ก่อนเรียกใช้คำสั่งอื่น
ลงทะเบียน trap cleanup EXIT ทันทีหลังสร้าง — อย่ารอจนจบสคริปต์
ใส่เครื่องหมายอัญประกาศคู่ให้กับการใช้ตัวแปรทุกครั้ง — rm -f "$TMPFILE" ห้ามใช้ rm -f $TMPFILE
เลือกใช้ flock แทนไฟล์ PID — เคอร์เนลจัดการให้และปล่อยโดยอัตโนมัติเมื่อเกิดการหยุดทำงานผิดปกติ
ใช้ -n แบบไม่บล็อกเป็นค่าเริ่มต้น — การล็อกที่บล็อกอย่างเงียบ ๆ อาจซ่อนปัญหาด้านประสิทธิภาพ
วางไฟล์ล็อกไว้นอกไดเรกทอรีชั่วคราว — เพื่อให้ไฟล์อยู่รอดหลังการล้างข้อมูลโดย trap
ทดสอบพฤติกรรมการล้างข้อมูล — เรียกใช้สคริปต์แล้วใช้ kill -9 หยุดระหว่างการทำงาน จากนั้นตรวจสอบว่าไม่มีไฟล์ตกค้าง (สำหรับสคริปต์ที่ใช้ flock ส่วนการล็อกด้วยไดเรกทอรีต้องระมัดระวังเพิ่มเติม)

ตรวจสอบความรู้: พฤติกรรมแฟล็กของ flock

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

สรุป: ไฟล์ชั่วคราวและไดเรกทอรีล็อกที่ปลอดภัย

ในบทเรียนนี้ คุณได้เรียนรู้เครื่องมือสำคัญสองอย่างสำหรับการจัดการทรัพยากรอย่างป้องกันปัญหาใน Bash:

mktemp สร้างไฟล์ชั่วคราว (0600) และไดเรกทอรี (0700) ที่มีชื่อคาดเดาไม่ได้และตั้งค่าสิทธิ์อย่างปลอดภัย ช่วยกำจัดสภาวะแข่งขันและการโจมตีผ่านลิงก์สัญลักษณ์ซึ่งมักเกิดกับเส้นทางที่กำหนดตายตัว
trap cleanup EXIT รับประกันการลบไฟล์ชั่วคราวเมื่อออกจากการทำงานไม่ว่าด้วยวิธีใด — ออกตามปกติ เกิดข้อผิดพลาด หรือได้รับสัญญาณ — หากลงทะเบียนทันทีหลังสร้างไฟล์
flock ให้การล็อกแบบให้ความร่วมมือที่เคอร์เนลบังคับใช้: ใช้ -n เพื่อให้ล้มเหลวอย่างรวดเร็วเมื่อมีการแย่งใช้ล็อก ใช้ -w N เพื่อรอโดยมีเวลาหมดอายุ และใช้รูปแบบ exec 200>file สำหรับการล็อกภายในสคริปต์ ซึ่งเคอร์เนลจะปล่อยโดยอัตโนมัติเมื่อกระบวนการสิ้นสุดลง
ไดเรกทอรีล็อก (mkdir) เป็นทางเลือกสำรองที่ใช้ได้ในหลายสภาพแวดล้อมเมื่อไม่มี flock แต่ต้องตรวจสอบล็อกค้างอย่างชัดเจน
เก็บไฟล์ล็อกไว้นอกไดเรกทอรีชั่วคราวเสมอ และใส่เครื่องหมายอัญประกาศคู่ให้กับตัวแปรทุกตัวที่ใช้ในการล้างข้อมูล

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

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

บทเรียน “ไฟล์ชั่วคราวและไดเรกทอรีล็อกที่ปลอดภัย” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ไฟล์ชั่วคราวและไดเรกทอรีล็อกที่ปลอดภัย”

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

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

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

บทเรียน “ไฟล์ชั่วคราวและไดเรกทอรีล็อกที่ปลอดภัย” ใช้เวลานานแค่ไหน

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

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

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

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

โหมดเข้มงวดด้วย set -euo pipefail
ตัวจัดการ trap สำหรับการล้างข้อมูลและสัญญาณ
ไฟล์ชั่วคราวและไดเรกทอรีล็อกที่ปลอดภัย
สคริปต์แบบทำซ้ำได้อย่างปลอดภัยและตรรกะลองใหม่แบบถอยกลับ

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