Mengakses shell di dalam container Docker merupakan salah satu keterampilan paling fundamental yang harus dikuasai oleh siapa pun yang bekerja dengan teknologi kontainerisasi. Baik untuk keperluan debugging, inspeksi konfigurasi, ataupun eksekusi perintah secara interaktif, kemampuan untuk masuk ke dalam container secara efektif dapat menghemat waktu dan menghindari frustrasi. Artikel ini menyajikan panduan lengkap mulai dari prasyarat, instalasi, konfigurasi, hingga troubleshooting yang mungkin Anda temui sehari-hari.

Prasyarat

Sebelum mulai menjalankan perintah untuk memasuki container Docker, ada sejumlah prasyarat teknis yang harus dipenuhi agar seluruh proses berjalan tanpa hambatan. Memahami prasyarat ini bukan sekadar formalitas, melainkan langkah kritis yang mencegah munculnya error yang sulit dilacak di kemudian hari.

Sistem operasi yang didukung mencakup distribusi Linux mayoritas seperti Ubuntu (18.04 ke atas), Debian (10 ke atas), CentOS 7+, Fedora, serta Arch Linux. Di luar Linux, Docker Desktop juga tersedia untuk macOS (Intel dan Apple Silicon) dan Windows 10/11 Pro dengan WSL 2 atau Hyper-V backend. Perlu dicatat bahwa performa dan kompatibilitas terbaik selalu ditemukan pada lingkungan Linux native, sementara pengguna Windows mungkin menghadapi nuansa tertentu terkait binding mount dan networking.

Versi software yang dibutuhkan yang disyaratkan adalah Docker Engine versi 20.10 atau lebih baru. Versi ini penting karena menghadirkan perbaikan keamanan kritis dan dukungan penuh terhadap fitur docker exec yang akan menjadi fokus utama artikel ini. Untuk memastikan versi yang terinstal di sistem Anda, jalankan perintah berikut:

docker --version
# Contoh output:
# Docker version 24.0.7, build afdd53b

Selain Docker Engine, pastikan Docker daemon (dockerd) sedang berjalan. Pada sebagian besar instalasi Linux modern, Docker dikelola sebagai service systemd:

sudo systemctl status docker
# Jika tidak aktif:
sudo systemctl start docker
sudo systemctl enable docker  # agar otomatis berjalan saat boot

Perangkat pendukung yang sangat direkomendasikan meliputi docker-compose (versi 2.0+) untuk mengelola multi-container, serta jq untuk mem-parsing output JSON dari perintah docker inspect. Keduanya bukanlah keharusan mutlak, namun akan sangat membantu ketika Anda bekerja di lingkungan produksi yang kompleks. Juga pastikan user Anda termasuk dalam grup docker agar tidak perlu menggunakan sudo pada setiap perintah:

sudo usermod -aG docker $USER
newgrp docker
# Verifikasi:
groups $USER
# Output: youruser : youruser docker ...

Terakhir, pastikan setidaknya ada satu container dalam keadaan running untuk keperluan praktik. Jika belum ada, Anda bisa membuatnya dengan cepat:

docker run -d --name my-nginx nginx:latest
docker ps
# Pastikan container muncul dengan status "Up"

Dengan seluruh prasyarat di atas terpenuhi, Anda siap melangkah ke tahap instalasi dan konfigurasi yang lebih mendalam.

Proses Instalasi

Bagian ini membahas proses instalasi Docker Engine dari awal bagi yang belum memilikinya, sekaligus langkah verifikasi untuk memastikan instalasi berjalan sempurna. Jika Docker sudah terinstal di sistem Anda, Anda bisa langsung melewati sub-bagian instalasi dan fokus pada verifikasi serta pengujian fungsionalitas docker exec.

Pada sistem berbasis Debian/Ubuntu, proses instalasi dimulai dengan memperbarui indeks paket dan menginstal dependensi yang diperlukan:

sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg lsb-release

Selanjutnya, tambahkan kunci GPG resmi dari Docker dan daftarkan repository-nya:

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Setelah repository terdaftar, lakukan instalasi Docker Engine beserta plugin Compose:

sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Untuk distribusi berbasis RHEL seperti CentOS atau Fedora, gunakan repository Docker via dnf:

sudo dnf install -y dnf-plugins-core
sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo dnf install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl start docker
sudo systemctl enable docker

Verifikasi instalasi merupakan langkah yang tidak boleh dilewatkan. Jalankan image hello-world untuk memastikan Docker dapat menarik dan menjalankan container dengan benar:

sudo docker run hello-world
# Contoh output:
# Hello from Docker!
# This message shows that your installation appears to be working correctly.

Langkah verifikasi berikutnya adalah menguji kemampuan docker exec secara langsung. Buat sebuah container yang berjalan lalu coba masuk ke dalamnya:

# Buat container interaktif di background
docker run -d --name test-container alpine:latest sleep 3600

# Masuk ke dalam container menggunakan exec
docker exec -it test-container /bin/sh

# Di dalam container, coba jalankan:
whoami
# Output: root

uname -a
# Output: Linux <container-id> 5.15.0-... x86_64 Linux

# Keluar dari container
exit

Jika seluruh langkah di atas berhasil tanpa error, maka instalasi Docker Engine serta kemampuan untuk memasuki container sudah siap digunakan. Bersihkan container uji jika diperlukan:

docker rm -f test-container

Mengatur Konfigurasi

Meskipun perintah docker exec secara default sudah dapat digunakan tanpa konfigurasi tambahan, memahami opsi-opsi konfigurasi yang tersedia akan membantu Anda menyesuaikan perilaku container agar sesuai kebutuhan spesifik, baik untuk debugging maupun untuk eksekusi tugas tertentu.

File konfigurasi Docker daemon berlokasi di /etc/docker/daemon.json. File ini mengatur perilaku global Docker daemon, termasuk log driver, storage driver, dan pengaturan keamanan. Berikut adalah contoh konfigurasi yang relevan untuk kegiatan debugging dan eksekusi di dalam container:

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  },
  "storage-driver": "overlay2",
  "default-runtime": "runc",
  "runtimes": {
    "runsc": {
      "path": "/usr/bin/runsc"
    }
  }
}

Konfigurasi log di atas sangat penting karena ketika Anda melakukan docker exec dan menghasilkan output, log tersebut tersimpan melalui log driver yang dikonfigurasi. Pembatasan ukuran log mencegah disk penuh di lingkungan produksi.

Opsi penting pada docker exec yang perlu dipahami meliputi:

  • -i (--interactive): Mempertahankan STDIN terbuka meskipun tidak terpasang. Tanpa flag ini, perintah interaktif seperti shell akan langsung keluar.
  • -t (--tty): Mengalokasikan pseudo-terminal. Flag ini membuat pengalaman shell terasa natural dengan dukungan format warna dan kontrol terminal.
  • -w (--workdir): Mengatur working directory di dalam container untuk perintah yang dieksekusi.
  • -e (--env): Menetapkan variabel lingkungan yang tersedia selama eksekusi perintah.
  • --user atau -u: Menentukan user yang menjalankan perintah, berguna untuk keamanan.
  • --privileged: Memberikan akses penuh ke perangkat host, sangat berbahaya dan hanya digunakan dalam skenario khusus.

Testing konfigurasi dapat dilakukan dengan membuat Dockerfile khusus yang mensimulasikan skenario nyata:

# Buat container dengan environment variable kustom
docker run -d --name config-test \
  -e DB_HOST=db.internal \
  -e DB_PORT=5432 \
  alpine:latest sleep 3600

# Eksekusi perintah dengan working directory dan env kustom
docker exec -w /tmp -e MY_VAR="hello" config-test /bin/sh -c 'echo "$MY_VAR at $(pwd)"'
# Output: hello at /tmp

Anda juga dapat menguji eksekusi sebagai user non-root:

# Eksekusi sebagai user nobody
docker exec -u nobody config-test whoami
# Output: nobody

# Verifikasi variabel lingkungan container
docker exec config-test env | grep DB_
# Output:
# DB_HOST=db.internal
# DB_PORT=5432

Untuk konfigurasi yang lebih persisten, Anda dapat memanfaatkan docker-compose.yml agar setiap kali container dinyalakan ulang, seluruh konfigurasi tetap konsisten:

services:
  app:
    image: alpine:latest
    command: sleep 3600
    environment:
      - APP_ENV=production
      - LOG_LEVEL=debug
    working_dir: /app

Pendekatan deklaratif dengan Compose memastikan bahwa ketika Anda menjalankan docker exec ke container tersebut, seluruh variabel dan working directory sudah sesuai harapan tanpa perlu mengetikkan ulang flag secara manual.

Contoh Penggunaan

Bagian ini menyajikan lima skenario penggunaan nyata dari perintah untuk memasuki container Docker, lengkap dengan Contoh output dan penjelasan mendalam terhadap setiap flag yang digunakan.

Skenario 1: Masuk ke Shell Container Secara Interaktif

Ini adalah kasus penggunaan paling umum, di mana Anda ingin mendapatkan akses shell penuh di dalam container yang sedang berjalan untuk eksplorasi atau debugging.

# Pertama, jalankan sebuah container
docker run -d --name web-server nginx:latest

# Masuk ke shell container
docker exec -it web-server /bin/bash

Penjelasan flag:

  • -i menjaga sesi tetap interaktif dengan mempertahankan input stream.
  • -t mengalokasikan TTY sehingga Anda mendapatkan prompt shell yang responsif dengan fitur seperti history dan auto-complete.
  • /bin/bash adalah shell yang dipilih. Pada image berbasis Alpine yang tidak memiliki Bash, gunakan /bin/sh sebagai gantinya.
# Di dalam container nginx:
root@a1b2c3d4e5f6:/# cat /etc/nginx/nginx.conf
root@a1b2c3d4e5f6:/# ls /usr/share/nginx/html/
# Output: 50x.html  index.html
root@a1b2c3d4e5f6:/# exit

Skenario 2: Eksekusi Perintah Tunggal Tanpa Masuk Shell

Terkadang Anda hanya perlu menjalankan satu perintah spesifik tanpa perlu membuka sesi shell interaktif. Ini lebih efisien dan aman untuk automasi.

docker exec web-server cat /etc/nginx/nginx.conf
# Output: konten lengkap file nginx.conf

Tanpa flag -i dan -t, perintah dieksekusi secara non-interaktif dan hasilnya langsung ditampilkan di terminal host. Pendekatan ini ideal untuk skrip CI/CD atau cron job.

Skenario 3: Debugging dengan Akses sebagai User Tertentu

Dalam lingkungan produksi, container sering berjalan sebagai user non-root. Untuk mereproduksi masalah persis seperti yang dialami aplikasi, Anda perlu mengeksekusi perintah sebagai user yang sama.

# Buat container yang berjalan sebagai user www-data
docker run -d --name secure-app -u 1000:1000 alpine:latest sleep 3600

# Masuk sebagai user yang sama
docker exec -u 1000:1000 -it secure-app /bin/sh

# Di dalam container:
/ $ whoami
# Output: 1000 (atau nama user jika dikonfigurasi)
/ $ id
# Output: uid=1000 gid=1000
/ $ touch /root/test.txt
# Output: touch: /root/test.txt: Permission denied

Penggunaan flag -u memastikan Anda mengalami persis apa yang dialami proses aplikasi, termasuk keterbatasan izin akses yang mungkin menjadi sumber bug.

Skenario 4: Menjalankan Perintah dengan Environment Variable Kustom

Ketika Anda perlu menguji perilaku aplikasi dengan konfigurasi lingkungan yang berbeda tanpa memodifikasi container secara permanen, flag -e menjadi solusi elegan.

docker exec -e DEBUG=true -e LOG_LEVEL=verbose web-server \
  /bin/sh -c 'echo "DEBUG=$DEBUG, LOG_LEVEL=$LOG_LEVEL"'
# Output: DEBUG=true, LOG_LEVEL=verbose

Flag -e hanya berlaku untuk sesi eksekusi tersebut, sehingga container tetap bersih tanpa side effect. Ini sangat berguna untuk eksperimen sementara seperti mengaktifkan mode debug di aplikasi Node.js atau mengubah threshold logging.

Skenario 5: Eksekusi di Working Directory Tertentu

Untuk container dengan struktur direktori kompleks, flag -w menghemat waktu dengan langsung menempatkan Anda di direktori yang relevan.

docker exec -w /var/log/nginx -it web-server /bin/bash

# Di dalam container, langsung berada di /var/log/nginx:
root@a1b2c3d4e5f6:/var/log/nginx# ls
# Output: access.log  error.log
root@a1b2c3d4e5f6:/var/log/nginx# tail -20 error.log

Tanpa flag -w, Anda harus melakukan cd secara manual setelah masuk ke container. Dalam skrip automasi, flag ini menghilangkan kebutuhan akan chaining perintah cd dan membuat kode lebih bersih.

Troubleshooting

Bekerja dengan docker exec tidak selalu berjalan mulus. Berikut adalah pembahasan mendalam mengenai error yang paling sering ditemui beserta solusinya, cara memeriksa log, dan tips debugging yang efektif.

Error: "No such container"

Error ini muncul ketika nama atau ID container yang Anda sebutkan tidak ditemukan oleh Docker daemon. Penyebabnya bisa beragam: container belum dibuat, sudah dihentikan dan dihapus, atau terjadi kesalahan penulisan nama.

docker exec -it my-contaner /bin/bash
# Error response from daemon: No such container: my-contaner

# Solusi: Periksa container yang tersedia
docker ps -a | grep my-container
# Pastikan nama tepat, perhatikan typo ("contaner" vs "container")

Jika container memang sudah terhapus, Anda perlu membuatnya kembali. Jika hanya berhenti, jalankan kembali:

docker start my-container
docker exec -it my-container /bin/bash

Error: "Container is not running"

Error ini terjadi ketika container sudah ada namun dalam keadaan stopped atau exited. Perintah docker exec hanya dapat dijalankan terhadap container yang berstatus running.

docker exec -it my-nginx /bin/bash
# Error response from daemon: Container my-nginx is not running

# Solusi: Cek status dan jalankan ulang
docker ps -a --filter name=my-nginx
# Jika status "Exited":
docker start my-nginx
docker exec -it my-nginx /bin/bash

Perlu dipahami bahwa container yang berhenti tetap menyimpan filesystem-nya. Jika Anda perlu mengakses file tanpa menjalankan container, gunakan docker cp sebagai alternatif:

docker cp my-nginx:/etc/nginx/nginx.conf ./nginx.conf.bak

Error: "OCI runtime exec failed: executable not found"

Error ini muncul ketika shell atau perintah yang Anda coba eksekusi tidak tersedia di dalam image container. Ini sangat umum terjadi pada image berbasis Alpine yang secara default hanya menyediakan /bin/sh, bukan /bin/bash.

docker exec -it alpine-container /bin/bash
# OCI runtime exec failed: exec: "/bin/bash": stat /bin/bash: no such file or directory

# Solusi: Gunakan /bin/sh
docker exec -it alpine-container /bin/sh

Jika Anda benar-benar membutuhkan Bash di dalam Alpine, install terlebih dahulu:

docker exec -it alpine-container /bin/sh -c "apk add --no-cache bash"
docker exec -it alpine-container /bin/bash

Cara Cek Log

Log container memberikan konteks penting sebelum dan sesudah Anda memasuki container. Perintah docker logs adalah temuan pertama yang harus digunakan:

# Log standar
docker logs my-nginx

# Log real-time (mengikuti output baru)
docker logs -f my-nginx

# Log 50 baris terakhir dengan timestamp
docker logs --tail 50 -t my-nginx

# Log dalam rentang waktu tertentu
docker logs --since "2024-01-15T10:00:00" --until "2024-01-15T12:00:00" my-nginx

Untuk pemeriksaan lebih mendalam, gunakan docker inspect untuk melihat detail konfigurasi container termasuk state, environment variable, dan mount points:

docker inspect my-nginx | jq '.[0].State'
# Output: { "Status": "running", "Running": true, "StartedAt": "2024-..." }

Debug Tips

Beberapa strategi debugging yang efektif meliputi pemeriksaan proses yang berjalan di dalam container menggunakan docker top, yang menampilkan proses dari perspektif host:

docker top my-nginx
# Output menampilkan PID, USER, COMMAND dari proses dalam container

Anda juga dapat memantau penggunaan resource secara real-time:

docker stats my-nginx
# Output: CPU %, MEM USAGE / LIMIT, MEM %, NET I/O, BLOCK I/O

Untuk kasus di mana container langsung exit setelah start, gunakan opsi --entrypoint untuk mengganti command utama dan masuk ke shell sebagai gantinya:

docker run -it --entrypoint /bin/sh my-problematic-image
# Sekarang Anda bisa menyelidiki mengapa aplikasi gagal berjalan
ls -la /app/
cat /app/config.yml
./start.sh
# Amati error yang muncul

Pendekatan ini sangat berharga ketika Dockerfile mendefinisikan ENTRYPOINT yang langsung crash, karena Anda tetap bisa memeriksa filesystem dan konfigurasi tanpa container tersebut harus berjalan sukses.

Langkah Selanjutnya

Setelah menguasai dasar-dasar memasuki container Docker, ada sejumlah area lanjutan yang patut dieksplorasi untuk memperdalam keahlian Anda dalam mengelola lingkungan berkontainer.

Resource resmi yang wajib dijadikan referensi utama adalah dokumentasi Docker resmi, khususnya halaman referensi untuk docker exec yang tersedia di https://docs.docker.com/engine/reference/commandline/exec/. Dokumentasi ini selalu diperbarui mengikuti versi terbaru dan menyertakan contoh penggunaan yang komprehensif. Selain itu, Docker Labs (https://labs.docker.com/) menyediakan tutorial interaktif yang memungkinkan Anda berlatih langsung di browser tanpa perlu menginstal apa pun di mesin lokal. Untuk diskusi dan pertanyaan spesifik, Docker Community Forums dan Stack Overflow dengan tag [docker] merupakan sumber pengetahuan komunitas yang sangat kaya.

Topik lanjutan yang sangat relevan untuk dipelajari selanjutnya meliputi beberapa hal. Pertama, Docker networking — memahami bagaimana container berkomunikasi satu sama lain dan dengan host, termasuk konsep bridge network, overlay network, dan DNS resolution internal Docker. Kedua, Docker volumes dan bind mounts — pengetahuan mendalam tentang persistensi data sangat penting karena data di dalam container bersifat ephemeral, dan kemampuan docker exec untuk memverifikasi volume mounting merupakan keterampilan praktis yang sering dibutuhkan. Ketiga, keamanan container — memahami penggunaan --read-only, --security-opt, seccomp profiles, dan AppArmor untuk membatasi apa yang dapat dilakukan proses di dalam container, termasuk implikasi keamanan dari penggunaan docker exec dengan flag --privileged. Keempat, container orchestration dengan Kubernetes — di lingkungan Kubernetes, konsep yang setara adalah kubectl exec, yang memiliki nuansa berbeda terkait namespace, pod multi-container, dan kebijakan RBAC. Kelima, rootless containers dan Podman — sebagai alternatif Docker yang berjalan tanpa akses root, Podman menawarkan perintah podman exec dengan kompatibilitas yang serupa namun dengan model keamanan yang berbeda secara fundamental.

Memahami seluruh topik di atas akan membawa Anda dari sekadar mampu memasuki container menuju kemampuan mendesain dan mengelola arsitektur berkontainer yang robust, aman, dan siap produksi. Teruslah berlatih dengan skenario nyata, karena pengalaman hands-on tetap menjadi guru terbaik dalam penguasaan teknologi kontainerisasi.