0Pricing
Linux Command Line & Bash Scripting Mastery · Pelajaran

Mengendalikan Layanan systemd dan Menulis File Unit

Kendalikan layanan dengan systemctl dan buat file unit serta timer kustom untuk daemon berbasis skrip.

Mengendalikan Layanan systemd dan Menulis File Unit adalah pelajaran Linux Command Line & Bash Scripting Mastery gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Linux Command Line & Bash Scripting Mastery, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Pengantar systemd dan systemctl

systemd adalah sistem init dan pengelola layanan yang digunakan oleh sebagian besar distribusi Linux modern. systemd bertanggung jawab untuk memulai, menghentikan, dan mengelola layanan sistem, serta menangani urutan boot dan keadaan sistem.

Alat utama untuk berinteraksi dengan systemd adalah systemctl. Dengannya, Anda dapat:

  • Memulai dan menghentikan layanan
  • Mengaktifkan atau menonaktifkan layanan saat boot
  • Memeriksa status dan catatan layanan
  • Memuat ulang konfigurasi tanpa memulai ulang

Semua layanan yang dikelola systemd ditentukan oleh berkas unit, yaitu berkas konfigurasi deklaratif yang disimpan di bawah /etc/systemd/system/ (seluruh sistem) atau ~/.config/systemd/user/ (per pengguna).

Perintah systemctl Esensial

Berikut adalah perintah systemctl yang paling umum digunakan untuk mengelola layanan sehari-hari. Setiap perintah bekerja pada nama unit seperti nginx.service atau cukup nginx.

  • systemctl start <unit> — memulai layanan segera
  • systemctl stop <unit> — menghentikan layanan yang sedang berjalan
  • systemctl restart <unit> — menghentikan lalu memulai kembali layanan (mulai ulang penuh)
  • systemctl reload <unit> — mengirim SIGHUP untuk memuat ulang konfigurasi tanpa menghentikan layanan
  • systemctl enable <unit> — membuat tautan simbolis agar unit dimulai saat boot
  • systemctl disable <unit> — menghapus tautan simbolis tersebut
  • systemctl status <unit> — menampilkan status, PID, dan baris log terbaru
#!/usr/bin/env bash
# Quick reference: inspect and control an nginx service
# (Requires nginx to be installed; run as root or with sudo)

systemctl status nginx
systemctl start nginx
systemctl enable nginx
systemctl reload nginx
systemctl restart nginx
systemctl stop nginx
systemctl disable nginx

Memeriksa Status Layanan Secara Mendetail

systemctl status memberikan gambaran lengkap tentang suatu unit. Memahami keluarannya sangat penting untuk mendiagnosis masalah dengan cepat.

  • Loaded: jalur ke berkas unit dan informasi apakah unit diaktifkan saat boot
  • Active: status saat ini — active (running), inactive (dead), failed
  • Main PID: pengenal proses utama layanan
  • CGroup: semua proses anak yang dimiliki layanan
  • Log lines: entri jurnal terbaru untuk unit ini

Anda juga dapat hanya menanyakan status aktif dengan systemctl is-active dan status pengaktifan dengan systemctl is-enabled. Keduanya ideal digunakan dalam skrip.

#!/usr/bin/env bash
# Script-friendly service health check
SERVICE="sshd"

if systemctl is-active --quiet "$SERVICE"; then
    echo "$SERVICE is running."
else
    echo "$SERVICE is NOT running. Attempting restart..."
    systemctl restart "$SERVICE"
fi

if systemctl is-enabled --quiet "$SERVICE"; then
    echo "$SERVICE is enabled at boot."
else
    echo "WARNING: $SERVICE is not enabled at boot."
fi

Mencantumkan dan Memfilter Unit

Saat mengelola banyak layanan, Anda memerlukan cara untuk mencantumkan dan memfilter unit secara efisien. systemctl list-units menampilkan semua unit yang sedang dimuat, sedangkan list-unit-files menampilkan semua berkas unit yang terpasang beserta status pengaktifannya.

Opsi pemfilteran yang berguna:

  • --type=service — hanya menampilkan unit layanan
  • --state=failed — hanya menampilkan unit yang gagal
  • --state=active — hanya menampilkan unit yang aktif
  • --all — menyertakan unit yang tidak aktif dalam daftar

Menggabungkan filter ini dengan grep memungkinkan Anda membuat alur inspeksi yang andal dalam skrip pemeliharaan.

#!/usr/bin/env bash
# List all failed services and report them
echo "=== Failed Services ==="
systemctl list-units --type=service --state=failed --no-legend

echo ""
echo "=== Services Enabled at Boot ==="
systemctl list-unit-files --type=service --state=enabled --no-legend | awk '{print $1}'

Anatomi Berkas Unit Layanan systemd

Berkas unit layanan adalah berkas teks biasa bergaya INI yang tersusun atas beberapa bagian. Setiap bagian mengatur aspek berbeda dari siklus hidup unit.

  • [Unit] — metadata: deskripsi dan dependensi pengurutan (After=, Requires=, Wants=)
  • [Service] — cara memulai/menghentikan proses: ExecStart, ExecStop, Restart, User, WorkingDirectory
  • [Install] — kapan unit ini harus diaktifkan: WantedBy=multi-user.target berarti unit diaktifkan selama boot multi-pengguna normal

Setelah menempatkan atau mengedit berkas unit di bawah /etc/systemd/system/, Anda harus menjalankan systemctl daemon-reload agar systemd memuat perubahan tersebut.

Menulis Berkas Unit Layanan Pertama Anda

Mari kita membuat berkas unit layanan sederhana untuk skrip server HTTP Python khusus. Berkas unit tersebut memberi tahu systemd secara tepat cara mengelola proses ini, seolah-olah proses tersebut adalah layanan sistem lainnya.

Direktif [Service] utama yang digunakan di sini:

  • Type=simple — systemd menganggap proses ExecStart sebagai proses utama
  • User=www-data — menjalankan proses dengan akun non-root demi keamanan
  • WorkingDirectory — menetapkan direktori kerja proses
  • Restart=on-failure — memulai ulang secara otomatis jika proses keluar dengan kode selain nol
  • RestartSec=5 — menunggu 5 detik di antara percobaan memulai ulang
#!/usr/bin/env bash
# Create a custom service unit file for a simple HTTP server
# Run as root

cat > /etc/systemd/system/mywebserver.service << 'EOF'
[Unit]
Description=My Custom Python Web Server
After=network.target

[Service]
Type=simple
User=www-data
WorkingDirectory=/var/www/mysite
ExecStart=/usr/bin/python3 -m http.server 8080
Restart=on-failure
RestartSec=5
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable --now mywebserver.service
systemctl status mywebserver.service

Jenis Layanan dan Siklus Hidup Proses

Direktif Type= di dalam [Service] memberi tahu systemd cara melacak kapan layanan selesai dimulai. Memilih jenis yang salah sering menyebabkan masalah pengurutan.

  • Type=simple — bawaan; systemd menganggap layanan telah dimulai segera setelah ExecStart diluncurkan. Tidak memerlukan sinyal kesiapan.
  • Type=forking — proses ExecStart membuat cabang lalu keluar; daemon sebenarnya berjalan sebagai proses anak. Gunakan PIDFile= agar systemd dapat melacaknya.
  • Type=notify — proses mengirim sd_notify(READY=1) saat benar-benar siap. Paling andal untuk daemon yang kompleks.
  • Type=oneshot — berjalan sekali lalu keluar; unit berikutnya menunggu hingga selesai. Ideal untuk skrip penyiapan.
  • Type=idle — seperti simple, tetapi eksekusinya ditunda hingga semua tugas aktif selesai.
#!/usr/bin/env bash
# Example: oneshot service for a database migration script
# /etc/systemd/system/db-migrate.service

cat > /etc/systemd/system/db-migrate.service << 'EOF'
[Unit]
Description=Run Database Migrations
After=postgresql.service
Requires=postgresql.service

[Service]
Type=oneshot
User=appuser
WorkingDirectory=/opt/myapp
ExecStart=/opt/myapp/scripts/migrate.sh
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl start db-migrate.service

Variabel Lingkungan dan Penguatan Keamanan

Berkas unit layanan mendukung beberapa direktif untuk meneruskan variabel lingkungan dan menerapkan pembatasan keamanan — keduanya penting dalam sistem produksi.

Direktif lingkungan:

  • Environment="KEY=value" — menetapkan satu variabel secara langsung
  • EnvironmentFile=/etc/myapp/env — memuat variabel dari sebuah berkas (satu KEY=value per baris)

Direktif penguatan keamanan umum:

  • NoNewPrivileges=true — mencegah proses memperoleh hak istimewa tambahan melalui setuid
  • ProtectSystem=strict — memasang /usr, /boot, dan /etc sebagai hanya-baca
  • PrivateTmp=true — memberikan layanan /tmp terisolasi miliknya sendiri
  • CapabilityBoundingSet= — menghapus semua kapabilitas Linux
#!/usr/bin/env bash
# Hardened service unit with environment file

cat > /etc/systemd/system/secureapp.service << 'EOF'
[Unit]
Description=Secure Application Daemon
After=network.target

[Service]
Type=simple
User=secureapp
Group=secureapp
WorkingDirectory=/opt/secureapp
EnvironmentFile=/etc/secureapp/env
ExecStart=/opt/secureapp/bin/server
Restart=on-failure
RestartSec=10

# Security hardening
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
PrivateTmp=true
CapabilityBoundingSet=
ReadWritePaths=/var/lib/secureapp /var/log/secureapp

[Install]
WantedBy=multi-user.target
EOF

# Create the environment file separately so secrets stay out of the unit file
install -m 600 -o secureapp /dev/null /etc/secureapp/env
echo 'APP_PORT=9000' >> /etc/secureapp/env
echo 'DB_URL=postgresql://localhost/mydb' >> /etc/secureapp/env

systemctl daemon-reload

Pengenalan Unit Pewaktu systemd

Pewaktu systemd adalah unit yang mengaktifkan unit lain (biasanya sebuah .service) berdasarkan jadwal. Pewaktu ini menggantikan tugas cron tradisional dengan mekanisme yang lebih terintegrasi, dapat dicatat dalam log, dan mudah dikendalikan.

Setiap unit pewaktu (foo.timer) dipasangkan dengan unit layanan yang memiliki nama dasar sama (foo.service) untuk melakukan pekerjaan sebenarnya. Anda mengaktifkan dan memulai pewaktu, bukan layanan secara langsung.

Jenis pewaktu:

  • Pewaktu waktu nyata (kalender) — berjalan pada waktu jam dinding menggunakan ekspresi OnCalendar= seperti daily, weekly, atau Mon *-*-* 02:00:00
  • Pewaktu monotonik — berjalan relatif terhadap peristiwa sistem menggunakan OnBootSec=, OnActiveSec=, atau OnUnitActiveSec=

Menulis Berkas Unit Pewaktu

Mari kita membuat pasangan pewaktu + layanan lengkap yang menjalankan skrip pencadangan setiap hari pada pukul 02.00. Perhatikan bahwa bagian [Timer] berada dalam berkas .timer tersendiri, sedangkan pekerjaan berada dalam berkas .service pasangannya.

Direktif [Timer] utama:

  • OnCalendar= — ekspresi kalender untuk jadwal
  • Persistent=true — jika sistem mati saat pewaktu seharusnya berjalan, jalankan segera pada boot berikutnya
  • RandomizedDelaySec= — tambahkan jeda acak hingga N detik untuk mencegah beban serentak ketika banyak hos menggunakan jadwal yang sama
  • Unit= — unit target yang ditentukan secara eksplisit (opsional jika namanya sama)
#!/usr/bin/env bash
# Create a daily backup timer pair
# Run as root

# 1. The service that does the work
cat > /etc/systemd/system/daily-backup.service << 'EOF'
[Unit]
Description=Daily Database Backup
After=network.target postgresql.service

[Service]
Type=oneshot
User=backup
ExecStart=/usr/local/bin/backup-db.sh
StandardOutput=journal
StandardError=journal
EOF

# 2. The timer that schedules it
cat > /etc/systemd/system/daily-backup.timer << 'EOF'
[Unit]
Description=Run Daily Database Backup at 02:00

[Timer]
OnCalendar=*-*-* 02:00:00
Persistent=true
RandomizedDelaySec=300

[Install]
WantedBy=timers.target
EOF

systemctl daemon-reload
systemctl enable --now daily-backup.timer

# Verify
systemctl list-timers daily-backup.timer

Memeriksa Log dan Memecahkan Masalah Unit

systemd mengarahkan semua keluaran layanan ke jurnal, yang Anda kueri menggunakan journalctl. Dengan demikian, log dari semua unit dipusatkan dalam satu penyimpanan yang dapat ditelusuri.

Opsi journalctl penting untuk memecahkan masalah layanan:

  • -u <unit> — memfilter berdasarkan nama unit
  • -f — mengikuti log secara waktu nyata (seperti tail -f)
  • -n 50 — hanya menampilkan 50 baris terakhir
  • --since "1 hour ago" — membatasi berdasarkan waktu
  • -p err — hanya menampilkan kesalahan dengan tingkat prioritas tersebut atau yang lebih tinggi
  • -b — hanya menampilkan log dari boot saat ini

Saat unit gagal dimulai, hal pertama yang harus dijalankan adalah journalctl -u <unit> -n 30 --no-pager, kemudian systemctl status <unit> untuk memperoleh konteks kesalahan terbaru.

#!/usr/bin/env bash
# Troubleshooting helper: dump unit status and recent logs
# Usage: ./service-debug.sh <unit-name>

UNIT="${1:-nginx.service}"

echo "=============================="
echo "STATUS: $UNIT"
echo "=============================="
systemctl status "$UNIT" --no-pager -l

echo ""
echo "=============================="
echo "RECENT LOGS (last 50 lines): $UNIT"
echo "=============================="
journalctl -u "$UNIT" -n 50 --no-pager

echo ""
echo "=============================="
echo "ERRORS ONLY (current boot)"
echo "=============================="
journalctl -u "$UNIT" -b -p err --no-pager

Uji Pemahaman: Berkas Unit systemd

Ujilah pemahaman Anda tentang konfigurasi unit layanan dan unit pewaktu systemd.

Ringkasan Pelajaran: Mengendalikan Layanan systemd dan Menulis Berkas Unit

Dalam pelajaran ini, Anda mempelajari konsep inti pengelolaan layanan systemd dan penulisan berkas unit pada tingkat profesional. Berikut ringkasan materi yang dibahas:

  • Dasar-dasar systemctl — start, stop, restart, reload, enable, disable, status, is-active, dan is-enabled untuk pemeriksaan yang mudah digunakan dalam skrip
  • Pencantuman dan pemfilteran — list-units dan list-unit-files dengan opsi --type dan --state untuk mengisolasi layanan yang gagal atau diaktifkan
  • Anatomi berkas unit — tiga bagian [Unit], [Service], dan [Install] beserta direktif utamanya
  • Jenis layanan — simple, forking, notify, oneshot, serta kapan masing-masing digunakan
  • Lingkungan dan keamanan — EnvironmentFile, NoNewPrivileges, ProtectSystem, dan PrivateTmp untuk daemon yang diperkuat keamanannya
  • Unit pewaktu — memasangkan berkas .timer dan .service, ekspresi OnCalendar, serta perilaku pengejaran jadwal Persistent
  • Journalctl — memfilter berdasarkan unit, waktu, boot, dan prioritas untuk mendiagnosis kegagalan secara efisien

Dengan keterampilan ini, Anda dapat mengelola layanan sistem apa pun, menjadwalkan tugas berulang secara andal, dan menulis berkas unit siap produksi untuk daemon Anda sendiri.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengendalikan Layanan systemd dan Menulis File Unit” gratis?

Ya — teks lengkap “Mengendalikan Layanan systemd dan Menulis File Unit” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Linux Command Line & Bash Scripting Mastery, upgrade ke CoddyKit PRO. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mengendalikan Layanan systemd dan Menulis File Unit”?

Kendalikan layanan dengan systemctl dan buat file unit serta timer kustom untuk daemon berbasis skrip. Kamu berlatih Linux Command Line & Bash Scripting Mastery dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Linux Command Line & Bash Scripting Mastery?

Tidak diperlukan pengalaman sebelumnya. Linux Command Line & Bash Scripting Mastery di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Mengendalikan Layanan systemd dan Menulis File Unit” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Linux Command Line & Bash Scripting Mastery ini?

Ya. Setiap pelajaran Linux Command Line & Bash Scripting Mastery menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Mengotomatiskan Penyediaan Pengguna dan Grup
  2. Mengendalikan Layanan systemd dan Menulis File Unit
  3. Otomatisasi Disk, Sistem File, dan Mount
  4. Membangun Skrip Pemeriksaan Kesehatan Sistem dan Peringatan
← Kembali ke Linux Command Line & Bash Scripting Mastery