---
title: "Cara Membatasi CPU dan RAM Container Docker"
description: "Cara memberi batas CPU dan RAM container Docker lewat docker run, docker update, dan Docker Compose, plus cara mengecek container yang mati karena OOM."
url: "https://nivelva.com/insight/cara-membatasi-cpu-ram-container-docker"
category: "Server \u0026 Infrastruktur"
tags: ["docker","docker compose","container","cpu","ram"]
author: "Theresia Candiawan"
published: "2026-11-07T04:16:00+07:00"
updated: "2026-11-07T04:16:00+07:00"
language: "id"
publisher: "Nivelva (https://nivelva.com)"
---

# Cara Membatasi CPU dan RAM Container Docker

> **Jawaban singkat:** Batasi RAM dengan --memory dan CPU dengan --cpus saat docker run, ubah container yang sudah berjalan dengan docker update, atau tulis deploy.resources.limits di Docker Compose. Tanpa batas, satu container bisa menghabiskan sumber daya seluruh server.

Batasi RAM container dengan opsi `--memory` dan CPU dengan `--cpus`, misalnya `docker run --memory=512m --cpus=1 nginx`. Di Docker Compose, batas yang sama ditulis di bagian `deploy.resources.limits`.

Kenapa ini penting? Secara bawaan, container Docker boleh memakai CPU dan RAM host tanpa batas. Satu aplikasi yang bocor memori atau satu query yang berat bisa membuat seluruh server melambat, lalu kernel mulai membunuh proses secara acak saat RAM habis. Dengan batas yang jelas, masalah di satu container tetap tinggal di container itu.

## Bagaimana cara membatasi RAM container?

Opsi utama ada tiga:

- `--memory` (atau `-m`) adalah batas keras. Container yang melewatinya akan dihentikan oleh kernel (OOM kill). Satuan yang bisa dipakai: `b`, `k`, `m`, `g`. Contoh: `--memory=512m`.
- `--memory-swap` adalah total RAM ditambah swap yang boleh dipakai. Bila nilainya sama dengan `--memory`, container tidak memakai swap sama sekali. Bila tidak diisi, Docker mengizinkan swap sebesar nilai `--memory` (total jadi dua kali lipat) bila host punya swap.
- `--memory-reservation` adalah batas lunak. Docker berusaha menekan pemakaian container ke angka ini saat host kekurangan memori. Nilainya harus lebih kecil dari `--memory`.

Contoh yang aman untuk aplikasi web kecil:

```bash
docker run -d --name app \
  --memory=512m --memory-swap=512m \
  --memory-reservation=256m \
  myapp:latest
```

Menyamakan `--memory-swap` dengan `--memory` membuat perilaku lebih mudah ditebak: begitu batas tercapai, container berhenti, bukan melambat karena sibuk bertukar ke swap.

## Bagaimana cara membatasi CPU container?

- `--cpus` membatasi berapa banyak inti CPU yang boleh dipakai. `--cpus=1.5` berarti setara satu setengah inti, dibagi ke inti mana pun.
- `--cpuset-cpus` mengunci container ke inti tertentu, misalnya `--cpuset-cpus="0,1"` atau `--cpuset-cpus="0-2"`.
- `--cpu-shares` mengatur bobot relatif (bawaan 1024). Bobot ini hanya berpengaruh saat CPU sedang rebutan. Saat CPU senggang, container dengan bobot kecil tetap boleh memakai CPU sebanyak yang tersedia.

```bash
docker run -d --name worker --cpus=1 --cpu-shares=512 myworker:latest
```

Untuk sebagian besar kasus, `--cpus` sudah cukup. `--cpuset-cpus` lebih cocok untuk server besar dengan beban khusus, dan `--cpu-shares` berguna bila kamu ingin satu layanan selalu diprioritaskan saat server sibuk.

## Batas lain yang sering terlupa

Selain CPU dan RAM, ada `--pids-limit` untuk membatasi jumlah proses di dalam container. Ini melindungi host dari aplikasi yang tidak sengaja membuat proses tanpa henti. Contoh: `--pids-limit=200`.

## Mengubah batas container yang sudah berjalan

Tidak perlu membuat ulang container. Gunakan `docker update`:

```bash
docker update --memory=1g --memory-swap=1g --cpus=2 app
```

Perubahan langsung berlaku. Ingat, `docker update` hanya mengubah container itu. Bila container dibuat ulang dari Compose atau skrip, batas lama di file konfigurasi akan dipakai lagi, jadi perbarui juga file sumbernya.

## Menulis batas di Docker Compose

Format yang direkomendasikan dokumentasi Compose adalah `deploy.resources`:

```yaml
services:
  app:
    image: myapp:latest
    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 512M
          pids: 200
        reservations:
          memory: 256M
```

Jalankan dengan `docker compose up -d`. Docker Compose versi modern menerapkan `limits` ini walau tidak memakai Swarm. Atribut lama `mem_limit` dan `cpus` di tingkat service masih dikenali, tapi jangan dicampur dengan `deploy.resources` untuk nilai yang sama agar tidak membingungkan.

Bagian `reservations` memesan sumber daya minimum. Bila menulis `reservations.cpus` atau `reservations.memory` lebih besar dari yang tersedia di host, container bisa gagal dijalankan, jadi isi dengan angka yang realistis.

## Ringkasan opsi

| Kebutuhan | docker run / update | Docker Compose |
|:--|:--|:--|
| Batas keras RAM | `--memory=512m` | `deploy.resources.limits.memory: 512M` |
| Matikan swap container | `--memory-swap=512m` (sama dengan memory) | `memswap_limit: 512M` |
| Batas lunak RAM | `--memory-reservation=256m` | `deploy.resources.reservations.memory: 256M` |
| Batas inti CPU | `--cpus=1.5` | `deploy.resources.limits.cpus: "1.5"` |
| Kunci ke inti tertentu | `--cpuset-cpus="0,1"` | `cpuset: "0,1"` |
| Bobot CPU relatif | `--cpu-shares=512` | `cpu_shares: 512` |
| Batas jumlah proses | `--pids-limit=200` | `deploy.resources.limits.pids: 200` |

## Bagaimana mengecek apakah batas bekerja?

Pantau pemakaian langsung:

```bash
docker stats
```

Kolom `MEM USAGE / LIMIT` menampilkan pemakaian dan batasnya. Bila batas tidak tampil sesuai harapan, cek nilai yang tersimpan:

```bash
docker inspect app --format '{{.HostConfig.Memory}} {{.HostConfig.NanoCpus}}'
```

Nilai `Memory` dalam byte, sedangkan `NanoCpus` dalam satuan sepermiliar inti (1 inti = 1000000000).

Container yang tiba-tiba berhenti dengan kode keluar 137 sering kali dibunuh karena melewati batas memori. Pastikan dengan:

```bash
docker inspect app --format '{{.State.OOMKilled}} {{.State.ExitCode}}'
```

Bila hasilnya `true 137`, naikkan batas memori atau kurangi pemakaian memori aplikasi. Kode 137 juga bisa muncul karena sebab lain (misalnya proses dihentikan paksa), jadi cek kolom `OOMKilled` terlebih dulu.

> **Sesuaikan setelan memori aplikasi:**
>
> Beberapa runtime punya batas memori sendiri. Misalnya Node.js dengan opsi `--max-old-space-size`, atau PHP dengan `memory_limit`. Setel nilainya sedikit di bawah batas container agar aplikasi memberi error yang jelas, bukan langsung dibunuh kernel.

## Berapa angka batas yang wajar?

Tidak ada angka universal. Cara paling jujur adalah mengamati dulu. Jalankan aplikasi tanpa batas ketat selama beberapa hari dengan beban normal, catat puncak pemakaian di `docker stats` atau alat monitoring, lalu beri batas sekitar puncak itu ditambah ruang cadangan. Total batas semua container sebaiknya tidak melebihi RAM host dikurangi kebutuhan sistem operasi.

Kalau batas yang wajar ternyata sudah melewati kapasitas server, itu tanda server perlu ditambah. Panduan [memilih spesifikasi VPS](https://nivelva.com/insight/memilih-spesifikasi-vps) membantu menghitung ulang kebutuhannya. Untuk kesalahan lain yang sering terjadi saat menjalankan container, baca [kesalahan umum Docker di produksi](https://nivelva.com/insight/kesalahan-docker-di-produksi), dan bila Docker belum terpasang, mulai dari [cara install Docker dan Docker Compose di Ubuntu](https://nivelva.com/insight/install-docker-compose-ubuntu).

## Pertanyaan yang sering diajukan

### Apakah container tanpa batas bisa membuat server crash?

Bisa membuat server sangat lambat atau tidak responsif. Saat RAM host habis, kernel akan membunuh proses untuk membebaskan memori, dan proses yang dibunuh belum tentu proses yang bermasalah.

### Kenapa muncul peringatan kernel tidak mendukung swap limit?

Peringatan itu muncul di host yang belum mengaktifkan akuntansi memori swap di cgroup. Distro modern dengan cgroup v2 umumnya sudah mendukung. Bila masih muncul, batas memori tetap berlaku, hanya batas swap yang diabaikan.

### Apakah --cpus=0.5 membuat aplikasi lebih lambat?

Ya, bila aplikasi butuh lebih dari setengah inti. Container akan dibatasi (throttled) begitu jatahnya habis dalam setiap periode penjadwalan, sehingga waktu respons bisa naik saat beban tinggi.

## Sumber

- <https://docs.docker.com/engine/containers/resource_constraints/>
- <https://docs.docker.com/reference/compose-file/deploy/>
- <https://docs.docker.com/reference/cli/docker/container/update/>

---

Diterbitkan oleh Nivelva Insight (https://nivelva.com/insight/). Artikel ini: https://nivelva.com/insight/cara-membatasi-cpu-ram-container-docker
Kontak Nivelva: WhatsApp https://wa.me/6285111245007, email hello@nivelva.com