> ## Documentation Index
> Fetch the complete documentation index at: https://docs.skanesgalab.my.id/llms.txt
> Use this file to discover all available pages before exploring further.

# Operasi Lanjutan Docker (Advanced)

> Praktek tingkat lanjut: exec, inspect, stats, multi-stage build, resource limits, healthcheck, dan pembersihan sistem.

Setelah menguasai dasar-dasar siklus hidup container, langkah berikutnya adalah mempelajari teknik optimasi produksi, pemecahan masalah (*troubleshooting* mendalam), dan kontrol performa container.

***

## 1. Interaksi & Eksekusi di Dalam Container (`docker exec`)

Jika ingin masuk ke dalam terminal container yang sedang aktif untuk memeriksa file konfigurasi atau mengecek status proses:

```bash theme={null}
# Membuka sesi shell interaktif di dalam container
docker exec -it web-server /bin/bash
# (atau gunakan /bin/sh jika menggunakan distro minimalis seperti Alpine Linux)
docker exec -it web-server /bin/sh

# Menjalankan perintah tunggal tanpa masuk ke shell
docker exec web-server nginx -t
docker exec -it db-mysql mysql -u root -p
```

### Menyalin Berkas Antara Host dan Container (`docker cp`)

```bash theme={null}
# Menyalin file dari host ke dalam container
docker cp ./default.conf web-server:/etc/nginx/conf.d/default.conf

# Menyalin file dari container ke mesin host
docker cp web-server:/var/log/nginx/access.log ./access.log
```

***

## 2. Inspeksi Mendalam (`docker inspect`)

`docker inspect` menampilkan seluruh metadata internal sebuah objek (Container, Image, Volume, atau Network) dalam format JSON terstruktur.

```bash theme={null}
# Menginspeksi keseluruhan konfigurasi container
docker inspect web-server

# Mengambil informasi IP Address container saja menggunakan Go template:
docker inspect -f '{{range.NetworkSettings.Networks}}{{.IPAddress}}{{end}}' web-server

# Melihat status Healthcheck container:
docker inspect -f '{{.State.Health.Status}}' web-server

# Mengecek konfigurasi Port Binding:
docker inspect -f '{{json .NetworkSettings.Ports}}' web-server
```

***

## 3. Monitoring Penggunaan Sumber Daya (`docker stats` & `top`)

Memantau seberapa banyak CPU dan RAM yang dikonsumsi oleh container secara *live*:

```bash theme={null}
# Memantau konsumsi CPU, memori, I/O jaringan dari semua container yang aktif
docker stats

# Memantau container tertentu dalam format satu kali baca (tidak looping)
docker stats --no-stream web-server

# Melihat daftar proses aktif (PID) di dalam container dari sisi host
docker top web-server
```

***

## 4. Multi-Stage Build di Dockerfile

Dalam tahap produksi (*production*), kita tidak ingin menyertakan compiler, pustaka dev, atau source code mentah ke dalam image final karena membuat ukuran image menjadi raksasa dan rentan keamanan. Solusinya adalah teknik **Multi-Stage Build**.

Contoh untuk aplikasi Golang / Node.js:

```dockerfile theme={null}
# Stage 1: Build tahap kompilasi aplikasi
FROM golang:1.21-alpine AS builder
WORKDIR /src
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o myapp .

# Stage 2: Image produksi minimalis (sangat ringan & aman)
FROM alpine:3.18
WORKDIR /root/
# Hanya menyalin binary yang sudah jadi dari stage builder
COPY --from=builder /src/myapp .
EXPOSE 8080
CMD ["./myapp"]
```

> [!TIP]
>
> **Hasil:** Ukuran image yang semula bisa mencapai ratusan MB terpangkas menjadi hanya belasan MB!

***

## 5. Batasan Sumber Daya (Resource Limits: CPU & Memory)

Untuk mencegah salah satu container menghabiskan seluruh memori atau prosesor server (kondisi OOM - Out of Memory):

```bash theme={null}
# Membatasi memori maksimum 512MB dan 1.5 core CPU
docker run -d --name limited-app \
  --memory="512m" \
  --memory-reservation="256m" \
  --cpus="1.5" \
  nginx:alpine
```

Di dalam berkas `docker-compose.yml`:

```yaml theme={null}
services:
  api:
    image: my-api:latest
    deploy:
      resources:
        limits:
          cpus: '1.0'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 128M
```

***

## 6. Healthcheck Container

Container yang statusnya *Up* belum tentu aplikasinya siap menerima traffic (misal aplikasi web sedang mengalami crash internal/deadlock). Fitur `HEALTHCHECK` memungkinkan Docker mengecek kesehatan aplikasi secara berkala.

Contoh di `Dockerfile`:

```dockerfile theme={null}
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD curl -f http://localhost:80/ || exit 1
```

Atau di `docker-compose.yml`:

```yaml theme={null}
services:
  web:
    image: nginx:alpine
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 10s
```

***

## 7. Pembersihan Menyeluruh (`docker system prune`)

Seiring berjalannya waktu, build cache, image usang (*dangling images*), dan container yang mati akan memakan kapasitas penyimpanan disk server secara drastis.

```bash theme={null}
# Menghapus semua container yang mati, network tak terpakai, dan dangling images
docker system prune

# Pembersihan agresif: menghapus container mati, volume tak terpakai, dan SEMUA image yang tidak sedang dipakai oleh container aktif
docker system prune -a --volumes -f

# Mengecek estimasi penggunaan kapasitas harddisk oleh Docker
docker system df
```


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.