Haidhi Wiki - Recent changes [en]

Cara install OKD

SanzSkuy — Wed, 28 Oct 2026 04:17:44 GMT

Created page with "'''OKD''' adalah distribusi Kubernetes komunitas (upstream dari Red Hat OpenShift). Halaman ini mencatat langkah lengkap memasang '''OKD Single Node (SNO)''' sebagai satu VM di Proxmox VE, memakai '''Agent-based Installer''', untuk keperluan cluster dev. == Ringkasan == {| class="wikitable" ! Item !! Nilai |- | Versi OKD || <code>5.0.0-okd-scos.3</code> (stable) |- | OS node || CentOS Stream CoreOS (SCOS), ter-bake di ISO |- | Metode install || Agent-based Installer, t..."

New page

'''OKD''' adalah distribusi Kubernetes komunitas (upstream dari Red Hat OpenShift). Halaman ini mencatat langkah lengkap memasang '''OKD Single Node (SNO)''' sebagai satu VM di Proxmox VE, memakai '''Agent-based Installer''', untuk keperluan cluster dev.

== Ringkasan ==
{| class="wikitable"
! Item !! Nilai
|-
| Versi OKD || <code>5.0.0-okd-scos.3</code> (stable)
|-
| OS node || CentOS Stream CoreOS (SCOS), ter-bake di ISO
|-
| Metode install || Agent-based Installer, topologi SNO
|-
| Hypervisor || Proxmox VE, standalone node <code>node-3</code>
|-
| Bridge jaringan || <code>vmbr3</code> (LAB) → subnet <code>192.168.90.0/24</code>
|-
| Gateway || <code>192.168.90.1</code> (MikroTik)
|-
| VM bastion (DNS) || <code>192.168.90.29</code>, AlmaLinux, dnsmasq
|-
| VM OKD (node) || <code>192.168.90.30</code>, hostname <code>okd-sno</code>
|-
| Cluster / base domain || <code>okd</code> / <code>lab.local</code>
|-
| Mesin kerja || Arch Linux (edit config + generate ISO)
|}

== Memilih topologi ==
* '''SNO (1 node)''': paling hemat resource, cocok untuk dev. Tidak ada HA, dan '''tidak bisa''' dikonversi ke cluster HA setelah terpasang.
* '''Compact cluster (3 node)''': ketiga node jadi master sekaligus worker. Lebih mirip production, tetap punya quorum etcd.
* '''2 node''': OKD punya topologi ''two-node with fencing'' (butuh BMC, tidak cocok untuk VM Proxmox) dan ''two control plane + arbiter'' (tetap 3 mesin, salah satunya arbiter kecil). Untuk lab, praktis pilih SNO atau 3 node.

Dipilih '''SNO''' supaya resource host tetap lega untuk VM lain.

== Arsitektur ==
<pre>
Arch Linux (laptop) ──WireGuard──► Proxmox (vmbr0, 192.168.11.x)
│ generate ISO
▼
Proxmox vmbr3 (LAB, 192.168.90.0/24)
├── VM bastion 192.168.90.29 → dnsmasq (DNS cluster)
└── VM OKD SNO 192.168.90.30 → seluruh cluster OKD
▲
gateway MikroTik 192.168.90.1 → internet (quay.io)
</pre>

'''Kenapa butuh bastion di dalam vmbr3?''' Host Proxmox tidak punya IP di <code>vmbr3</code>, dan laptop berada di jaringan lain (lewat WireGuard). Node OKD harus bisa menjangkau DNS-nya, jadi DNS diletakkan di VM yang satu subnet dengan node.

'''Bastion''' hanyalah istilah untuk mesin pembantu yang mengurus cluster (tempat <code>oc</code>, DNS, dsb.). DNS ini harus '''tetap hidup selama cluster hidup''', bukan hanya saat install, karena node memakai nama <code>api-int</code> untuk komunikasi internal.

== Kebutuhan resource ==
{| class="wikitable"
! VM !! vCPU !! RAM !! Disk
|-
| OKD SNO || 16 || 32 GB || 150 GB
|-
| Bastion (AlmaLinux minimal) || 1–2 || 1–2 GB || 10–20 GB
|}

Catatan:
* Spesifikasi minimal SNO di dokumentasi sekitar 8 vCPU / 16 GB, tapi 32 GB lebih nyaman.
* Di Proxmox, pemakaian RAM VM OKD terlihat sekitar 27 GiB saat install. Angka itu termasuk page cache dan tanpa guest agent, jadi lebih besar dari pemakaian riil. Cek angka asli dengan <code>oc adm top node</code>.

== Langkah 1: Siapkan binary di mesin kerja ==
Binary diambil dari GitHub Releases proyek OKD: <code>https://github.com/okd-project/okd/releases</code>

* Pilih rilis '''stable''' (tanpa label ''Pre-release'' dan tanpa <code>ec</code> di namanya).
* Download <code>openshift-install-linux-<tag>.tar.gz</code> dan <code>openshift-client-linux-<tag>.tar.gz</code>.

<syntaxhighlight lang="bash">
TAG=<tag-stable>
BASE=https://github.com/okd-project/okd/releases/download/$TAG
curl -LO $BASE/openshift-install-linux-$TAG.tar.gz
curl -LO $BASE/openshift-client-linux-$TAG.tar.gz

tar xzf openshift-install-linux-$TAG.tar.gz openshift-install
tar xzf openshift-client-linux-$TAG.tar.gz oc kubectl
sudo mv openshift-install oc kubectl /usr/local/bin/

openshift-install version
oc version --client
</syntaxhighlight>

'''Penting:''' <code>oc</code> '''wajib''' ada di <code>$PATH</code>, karena <code>openshift-install</code> memanggilnya saat membuat ISO.

Binary <code>openshift-install</code> terkunci ke satu rilis, jadi versi OKD yang terpasang sama dengan versi binary.

Install juga <code>nmstate</code> (menyediakan <code>nmstatectl</code>, dipakai untuk validasi IP statis):
<syntaxhighlight lang="bash">
yay -S nmstate # Arch (AUR)
nmstatectl --version
</syntaxhighlight>

Buat SSH key kalau belum ada:
<syntaxhighlight lang="bash">
ssh-keygen -t ed25519 -N ""
cat ~/.ssh/id_ed25519.pub
</syntaxhighlight>

== Langkah 2: Buat VM bastion (AlmaLinux) ==
AlmaLinux dipilih karena stabil dan support-nya panjang. Fedora kurang cocok untuk server yang hidup lama (siklus rilis cepat); CentOS Stream lebih sering berubah.

Setelan VM di Proxmox:
* Bridge '''<code>vmbr3</code>''', NIC VirtIO.
* '''CPU type <code>host</code>''' (lihat bagian Troubleshooting: kernel panic).
* RAM minimal 2 GB saat instalasi.
* Options → '''Start at boot''' aktif.

=== Kunci IP statis ===
<syntaxhighlight lang="bash">
nmcli -t -f NAME,DEVICE con show
sudo nmcli con mod ens18 ipv4.method manual \
ipv4.addresses 192.168.90.29/24 ipv4.gateway 192.168.90.1 \
ipv4.dns "192.168.90.29"
sudo nmcli con up ens18
sudo hostnamectl set-hostname marshall-okd-bastion
</syntaxhighlight>

DNS bastion diarahkan ke '''dnsmasq miliknya sendiri''' (<code>192.168.90.29</code>), bukan ke DNS publik. Kalau tidak, bastion tidak bisa resolve <code>api.okd.lab.local</code> dan <code>wait-for</code> tidak bisa memantau install.

Pastikan IP bastion dan IP node berada '''di luar pool DHCP''' MikroTik. Cek tanpa mengubah apa pun:
<pre>
/ip pool print
/ip dhcp-server lease print
</pre>

Cek IP node masih kosong:
<syntaxhighlight lang="bash">
ping -c2 192.168.90.30 # harus gagal
ip neigh | grep 192.168.90.30 # kosong atau FAILED
</syntaxhighlight>

== Langkah 3: DNS dengan dnsmasq ==
OKD membutuhkan tiga record:

{| class="wikitable"
! Record !! Fungsi
|-
| <code>api.okd.lab.local</code> || API cluster (port 6443), dipakai <code>oc</code> dan installer
|-
| <code>api-int.okd.lab.local</code> || API internal, dipakai node dan komponen cluster
|-
| <code>*.apps.okd.lab.local</code> || Ingress: web console, OAuth, dan semua aplikasi
|}

Di SNO, ketiganya mengarah ke IP node.

<syntaxhighlight lang="bash">
sudo dnf install -y dnsmasq bind-utils
sudo tee /etc/dnsmasq.d/okd.conf <<'EOF'
listen-address=192.168.90.29
bind-interfaces
server=1.1.1.1
server=8.8.8.8
address=/api.okd.lab.local/192.168.90.30
address=/api-int.okd.lab.local/192.168.90.30
address=/apps.okd.lab.local/192.168.90.30
EOF
</syntaxhighlight>

Penjelasan:
* <code>server=</code> adalah DNS upstream untuk nama di luar cluster (quay.io, dll.). dnsmasq hanya menjadi klien ke server itu, tidak mengubah konfigurasi router.
* <code>address=/apps.okd.lab.local/...</code> otomatis mencakup semua subdomain (wildcard).
* <code>listen-address</code> + <code>bind-interfaces</code> membuat dnsmasq hanya mendengarkan di IP tersebut, sehingga tidak bentrok dengan resolver lain.

Pastikan folder <code>.d</code> terbaca:
<syntaxhighlight lang="bash">
grep -n conf-dir /etc/dnsmasq.conf
# kalau tidak ada / masih dikomentari:
echo 'conf-dir=/etc/dnsmasq.d/,*.conf' | sudo tee -a /etc/dnsmasq.conf
</syntaxhighlight>

Jalankan dan uji:
<syntaxhighlight lang="bash">
sudo dnsmasq --test
sudo systemctl enable --now dnsmasq
sudo firewall-cmd --add-service=dns --permanent && sudo firewall-cmd --reload
sudo ss -lntup | grep ':53'
dig +short api.okd.lab.local @192.168.90.29 # → 192.168.90.30
dig +short quay.io @192.168.90.29 # harus ada jawaban
getent hosts api.okd.lab.local # dari bastion sendiri
</syntaxhighlight>

== Langkah 4: install-config.yaml ==
<syntaxhighlight lang="yaml">
apiVersion: v1
baseDomain: lab.local
metadata:
name: okd
compute:
- name: worker
replicas: 0
controlPlane:
name: master
replicas: 1
networking:
networkType: OVNKubernetes
machineNetwork:
- cidr: 192.168.90.0/24
clusterNetwork:
- cidr: 10.128.0.0/14
hostPrefix: 23
serviceNetwork:
- 172.30.0.0/16
platform:
none: {}
pullSecret: '{"auths":{"fake":{"auth":"aWQ6cGFzcwo="}}}'
sshKey: 'ssh-ed25519 AAAA... (isi ~/.ssh/id_ed25519.pub)'
</syntaxhighlight>

Catatan:
* <code>platform: none</code> dipakai karena Proxmox tidak punya integrasi native.
* '''Pull secret dummy''' (<code>id:pass</code> dalam base64) cukup untuk OKD, karena image diambil dari <code>quay.io/okd</code> yang publik. Pull secret asli Red Hat hanya perlu untuk OpenShift atau image dari <code>registry.redhat.io</code>.

== Langkah 5: agent-config.yaml ==
<syntaxhighlight lang="yaml">
apiVersion: v1alpha1
kind: AgentConfig
metadata:
name: okd
rendezvousIP: 192.168.90.30
hosts:
- hostname: okd-sno
role: master
interfaces:
- name: eth0
macAddress: BC:24:11:00:00:30
networkConfig:
interfaces:
- name: eth0
type: ethernet
state: up
mac-address: BC:24:11:00:00:30
ipv4:
enabled: true
dhcp: false
address:
- ip: 192.168.90.30
prefix-length: 24
dns-resolver:
config:
server:
- 192.168.90.29
routes:
config:
- destination: 0.0.0.0/0
next-hop-address: 192.168.90.1
next-hop-interface: eth0
table-id: 254
</syntaxhighlight>

Catatan:
* '''MAC address ditentukan sendiri''', lalu dipasang manual di NIC VM. Installer mencocokkan IP statis ke VM berdasarkan MAC.
* Aturan MAC: oktet pertama harus genap di digit keduanya (unicast). Prefix <code>BC:24:11</code> adalah prefix Proxmox.
* Nama interface <code>eth0</code> hanya label; pencocokan dilakukan lewat MAC.

== Langkah 6: Generate ISO ==
ISO '''tidak didownload''', melainkan dibuat oleh <code>openshift-install</code> dari dua YAML di atas. File YAML akan '''dikonsumsi''' (dihapus) saat generate, jadi simpan backup.

<syntaxhighlight lang="bash">
cd ~/okd
mkdir -p ~/okd-backup && cp install-config.yaml agent-config.yaml ~/okd-backup/
rm -rf cluster && mkdir cluster
cp install-config.yaml agent-config.yaml cluster/
openshift-install agent create image --dir cluster --log-level=info
</syntaxhighlight>

Hasil: <code>cluster/agent.x86_64.iso</code>, plus <code>cluster/auth/</code> (kubeconfig dan password kubeadmin).

* Tidak ada progress bar saat <code>Downloading base ISO</code>; tunggu sampai prompt kembali.
* Warning <code>Failed to extract base ISO from release payload</code> tidak fatal; installer jatuh ke jalur download.
* '''Setiap perubahan IP/DNS/MAC wajib generate ulang ISO''', karena konfigurasi ter-bake di dalamnya.

Salin folder <code>cluster/</code> ke bastion supaya <code>wait-for</code> dan <code>oc</code> bisa dijalankan dari sana.

== Langkah 7: Buat VM OKD di Proxmox ==
Upload ISO lewat UI Proxmox (storage → ISO Images → Upload), lalu Create VM:

{| class="wikitable"
! Tab !! Setelan !! Alasan
|-
| General || Start at boot || Cluster ikut hidup saat host reboot
|-
| OS || ISO <code>agent.x86_64.iso</code> ||
|-
| System || Machine <code>q35</code>, BIOS SeaBIOS || q35 chipset modern (opsional, i440fx juga bisa). Kalau OVMF, matikan Secure Boot
|-
| Disks || VirtIO SCSI single, 150 GB, SSD, '''Discard''' + '''SSD emulation''' || Discard (TRIM) mengembalikan ruang thin-provisioned ke host; opsional
|-
| CPU || 1 socket, 16 core, type '''<code>host</code>''' || '''Wajib.''' SCOS butuh instruksi CPU modern; tipe default bisa memicu crash
|-
| Memory || 32768 MB, '''Ballooning off''' || '''Penting.''' Kubernetes mengasumsikan RAM tetap; balloon bisa memicu OOM/eviction
|-
| Network || Bridge <code>vmbr3</code>, VirtIO, MAC '''<code>BC:24:11:00:00:30</code>''' || Harus sama persis dengan agent-config.yaml
|-
| Options → Boot Order || <code>scsi0</code> di atas CD-ROM || Setelah install, node boot dari disk, bukan installer lagi
|}

== Langkah 8: Install dan pantau ==
Start VM. Di Console Proxmox, tanda awal yang benar:
<pre>
ens18: 192.168.90.30
Ignition: user-provided config was applied
This host (192.168.90.30) is the rendezvous host.
</pre>

Urutan yang terlihat:
# <code>Waiting for services</code> → service installer naik satu per satu.
# <code>Installation cannot proceed: Cluster status: insufficient</code> → sementara, validasi host belum selesai.
# <code>Cluster installation in progress</code>.
# <code>Writing image to disk</code> 0–100%, lalu node reboot dari disk.
# Log <code>crio-... libcrun container</code> berulang → container cluster dinyalakan (normal).
# <code>Finished bootkube.service</code> → bootstrap selesai.

Pantau dari bastion:
<syntaxhighlight lang="bash">
cd ~/okd
openshift-install agent wait-for bootstrap-complete --dir cluster --log-level=info
openshift-install agent wait-for install-complete --dir cluster --log-level=info
</syntaxhighlight>

* Pesan <code>cluster bootstrap did not complete</code> tepat setelah ''Writing image to disk: 100%'' bisa muncul karena <code>wait-for</code> kehilangan kontak saat node reboot dari ISO ke disk. Jalankan ulang <code>wait-for</code> (aman, tidak mengganggu installer).
* Install aktual memakan sekitar '''1 jam''' (cluster <code>Available</code> sekitar 09:15 dari mulai 08:11).

Cek status langsung:
<syntaxhighlight lang="bash">
export KUBECONFIG=~/okd/cluster/auth/kubeconfig
curl -k https://api.okd.lab.local:6443/version
oc get clusterversion
oc get co
</syntaxhighlight>

Install sukses bila <code>clusterversion</code> <code>Available=True</code> dan semua cluster operator <code>Available=True, Progressing=False, Degraded=False</code>.

== Langkah 9: Akses web console ==
Password:
<syntaxhighlight lang="bash">
cat ~/okd/cluster/auth/kubeadmin-password
</syntaxhighlight>

Console tidak bisa dibuka lewat <code>IP:port</code>, karena router OKD memilih tujuan berdasarkan '''nama host'''. Di mesin yang menjalankan browser, tambahkan ke <code>/etc/hosts</code>:
<pre>
192.168.90.30 api.okd.lab.local console-openshift-console.apps.okd.lab.local oauth-openshift.apps.okd.lab.local
</pre>

Buka <code>https://console-openshift-console.apps.okd.lab.local</code>, login sebagai <code>kubeadmin</code>. Peringatan sertifikat (self-signed) normal.

Mesin itu juga harus bisa menjangkau <code>192.168.90.0/24</code> (misalnya lewat route WireGuard atau <code>sshuttle</code> via bastion).

Tes router tanpa browser:
<syntaxhighlight lang="bash">
curl -kI --resolve console-openshift-console.apps.okd.lab.local:443:192.168.90.30 \
https://console-openshift-console.apps.okd.lab.local
</syntaxhighlight>

== Langkah 10: Setelah install ==
* '''Snapshot VM OKD''' selagi bersih.
* '''Lepas ISO''' dari VM OKD (CD/DVD → Do not use any media).
* '''Autostart dan urutan boot''': bastion order 1, OKD order 2, beri jeda start.
* '''Simpan <code>cluster/auth/</code>''' di tempat aman.
* '''Storage class''': cluster baru di <code>platform: none</code> belum punya storage dinamis; PVC akan Pending sampai dipasang NFS / local-path / LVMS. Cek dengan <code>oc get sc</code>.
* '''Image registry''' (dev): <syntaxhighlight lang="bash">
oc patch configs.imageregistry.operator.openshift.io cluster --type merge \
--patch '{"spec":{"managementState":"Managed","storage":{"emptyDir":{}}}}'
</syntaxhighlight> (emptyDir: isi hilang saat pod restart, hanya untuk dev.)
* '''Keamanan''': jangan publikasikan console, OAuth, dan API ke internet selama masih memakai <code>kubeadmin</code>. Ganti dengan user admin biasa lewat OAuth.

== Publish aplikasi dengan domain sendiri (rencana) ==
Alur: <code>Internet → MikroTik NAT → nginx → router OKD (192.168.90.30:80) → app</code>

Route dengan domain sendiri:
<syntaxhighlight lang="bash">
oc create route edge myapp --service=myapp \
--hostname=app.domainku.com --insecure-policy=Allow
</syntaxhighlight>

nginx (TLS di nginx, teruskan header Host):
<syntaxhighlight lang="nginx">
location / {
proxy_pass http://192.168.90.30:80;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
</syntaxhighlight>

Tes sisi OKD: <code>curl -sI -H "Host: app.domainku.com" http://192.168.90.30</code>

== Troubleshooting (yang benar-benar terjadi) ==
{| class="wikitable"
! Gejala !! Penyebab !! Solusi
|-
| dnsmasq <code>start-limit-hit</code>, log: <code>failed to create listening socket for port 53: Address already in use</code> || Config di <code>/etc/dnsmasq.d/</code> tidak terbaca (Arch tidak mengaktifkan <code>conf-dir</code>), dnsmasq bind ke semua alamat dan bentrok dengan dnsmasq libvirt di <code>virbr0</code> || Tambahkan <code>conf-dir=/etc/dnsmasq.d/,*.conf</code>; gunakan <code>listen-address</code> + <code>bind-interfaces</code>
|-
| <code>exec: "nmstatectl": executable file not found in $PATH</code> || Paket nmstate belum terpasang || <code>yay -S nmstate</code>, atau jalankan installer di container Fedora
|-
| <code>exec: "oc": executable file not found in $PATH</code> || <code>oc</code> belum diekstrak/di-PATH || Ekstrak <code>openshift-client</code>, pindahkan ke <code>/usr/local/bin</code>
|-
| Node tidak bisa menjangkau DNS di laptop || Laptop (192.168.83.x, WiFi) tidak bisa dijangkau dari jaringan Proxmox (laptop masuk via WireGuard) || Pindahkan DNS ke VM bastion di <code>vmbr3</code>
|-
| Kernel panic AlmaLinux: <code>Attempted to kill init! exitcode=0x00007f00</code> || CPU type default Proxmox menyembunyikan instruksi x86-64-v2/v3 yang dibutuhkan Alma 9/10 || Ubah Processor → Type <code>host</code>
|-
| <code>wait-for</code> stuck lama di <code>Waiting for cluster install to initialize. Sleeping for 30 seconds</code> || Bastion tidak bisa resolve <code>api.okd.lab.local</code> (DNS bastion ke 1.1.1.1). Cluster sebenarnya sudah jadi || Arahkan DNS bastion ke dnsmasq-nya (<code>192.168.90.29</code>) atau tambah <code>/etc/hosts</code>. Cek dengan <code>getent hosts api.okd.lab.local</code>
|-
| Console tidak terbuka di laptop || Nama <code>*.apps</code> tidak dikenal, atau subnet 192.168.90.x tidak terjangkau || Tambah <code>/etc/hosts</code>, pastikan route ke 192.168.90.0/24
|}

Perintah debug yang berguna:
<syntaxhighlight lang="bash">
ssh core@192.168.90.30
sudo journalctl -b -f
sudo crictl ps
tail -n 60 ~/okd/cluster/.openshift_install.log
openshift-install agent wait-for bootstrap-complete --dir cluster --log-level=debug
</syntaxhighlight>

== Referensi ==
* [https://docs.okd.io/latest/installing/overview/ OKD installation overview]
* [https://docs.okd.io/4.21/installing/installing_sno/install-sno-preparing-to-install-sno.html Preparing to install OKD on a single node]
* [https://docs.okd.io/4.22/installing/installing_two_node_cluster/about-two-node-arbiter-installation.html OKD two control plane + arbiter]
* [https://okd.io/blog/2025/05/14/okd-4.19-and-4.20-release OKD 4.19 / 4.20 release (transisi ke SCOS)]
* [https://github.com/okd-project/okd/releases OKD releases (GitHub)]

DevOps

SanzSkuy — Wed, 28 Oct 2026 04:17:00 GMT

← Older revision		Revision as of 04:17, 28 October 2026
Line 5:		Line 5:
	* [[Cara buat monitoring server pake Grafana & Prometheus]]		* [[Cara buat monitoring server pake Grafana & Prometheus]]
	* [[Deploy app bare-metal]]		* [[Deploy app bare-metal]]
			* [[Cara install OKD]]

	== Microk8s ==		== Microk8s ==
	* [[Microk8s: setup awal]]		* [[Microk8s: setup awal]]
	* [[Microk8s: setup registry]]		* [[Microk8s: setup registry]]

Main Page

SanzSkuy — Mon, 26 Oct 2026 09:57:51 GMT

← Older revision		Revision as of 09:57, 26 October 2026
Line 36:		Line 36:
	* Tedja, H. A., & Onno W. Purbo. (2024). Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization. Jurnal RESTI (Rekayasa Sistem Dan Teknologi Informasi), 8(6), 779 - 787. https://doi.org/10.29207/resti.v8i6.6089		* Tedja, H. A., & Onno W. Purbo. (2024). Performance and Efficiency Comparison of U-Net and Ghost U-Net in Road Crack Segmentation with Floating Point and Quantization Optimization. Jurnal RESTI (Rekayasa Sistem Dan Teknologi Informasi), 8(6), 779 - 787. https://doi.org/10.29207/resti.v8i6.6089
	* Angkawijana Tedja, H. (2026). A Smartphone Is a Better Compute Node Than a Legacy Laptop: A Feasibility Study of an MPI × OpenCL Cluster Across x86 Laptops and an Android Phone. Zenodo. https://doi.org/10.5281/zenodo.21351608		* Angkawijana Tedja, H. (2026). A Smartphone Is a Better Compute Node Than a Legacy Laptop: A Feasibility Study of an MPI × OpenCL Cluster Across x86 Laptops and an Android Phone. Zenodo. https://doi.org/10.5281/zenodo.21351608
			* Tedja, H. A. (2025). Perbandingan Metode Vektorisasi Teks dan Algoritma Pembelajaran Mesin Klasik untuk Klasifikasi Teks Bahasa Arab. Journal of Computer and Information Systems Ampera, 7(3), 207–219. https://doi.org/10.51519/journalcisa.v7i3.793

	== CV ==		== CV ==

Mikrotik 5: Bridge VLAN Filtering

SanzSkuy — Mon, 26 Oct 2026 09:41:07 GMT

Created page with "== Tujuan == * Paham kapan cukup memakai VLAN interface di port, dan kapan butuh bridge VLAN filtering. * Paham tiga bagian bridge VLAN filtering: PVID, tabel VLAN, dan VLAN interface di atas bridge. * Bisa membuat access port, trunk ke switch, dan trunk ke server. * Bisa men-debug konfigurasi VLAN lewat CLI. == Konsep == === Router sebagai switch VLAN === * '''Part 4 (router-on-a-stick)''': VLAN diurus switch. Router hanya menerima satu kabel trunk. * '''Part 5''': ro..."

New page

== Tujuan ==
* Paham kapan cukup memakai VLAN interface di port, dan kapan butuh bridge VLAN filtering.
* Paham tiga bagian bridge VLAN filtering: PVID, tabel VLAN, dan VLAN interface di atas bridge.
* Bisa membuat access port, trunk ke switch, dan trunk ke server.
* Bisa men-debug konfigurasi VLAN lewat CLI.

== Konsep ==

=== Router sebagai switch VLAN ===
* '''Part 4 (router-on-a-stick)''': VLAN diurus switch. Router hanya menerima satu kabel trunk.
* '''Part 5''': router '''sendiri''' menjadi switch VLAN. Setiap port bisa menjadi access atau trunk, dan router sekaligus menjadi gateway setiap VLAN.

=== Kapan butuh bridge? ===
{| class="wikitable"
! Situasi !! Pakai
|-
| Satu port membawa beberapa VLAN, dan setiap VLAN hanya ada di port itu || '''VLAN interface langsung di port''' (cara Part 4, paling simpel)
|-
| Satu VLAN tersebar di '''beberapa port''' router || '''Bridge + VLAN filtering'''
|}

Port-port hanya bisa "disambung" menjadi satu segmen lewat bridge ([[Belajar MikroTik Part 3|Part 3]]). Begitu port-port berada dalam satu bridge, cara memisahkan VLAN-nya adalah bridge VLAN filtering.

Analogi: VLAN interface di port = satu pipa dibagi beberapa jalur. Bridge VLAN filtering = gedung dengan banyak pintu, setiap pintu diberi label "khusus staff" atau "khusus tamu", dan pintu berlabel sama tetap tersambung satu sama lain.

'''VLAN yang sudah dipakai di satu port tetap bisa dipakai di port lain.''' Justru itu gunanya: VLAN 10 bisa ada di <code>ether2</code> dan <code>ether3</code> sekaligus, dan semua perangkatnya tetap satu network.

=== Tiga bagian + satu saklar ===
{| class="wikitable"
! # !! Bagian !! Menu !! Fungsi
|-
| 1 || '''PVID''' || Bridge → Ports || Frame '''polos''' yang masuk dari port ini dianggap milik VLAN berapa. Ini yang membuat port menjadi access port.
|-
| 2 || '''Tabel VLAN''' || Bridge → VLANs || Untuk setiap VLAN: port mana yang menjadi anggota, dan frame yang '''keluar''' dikirim tagged atau untagged. Ini daftar VLAN yang boleh lewat trunk.
|-
| 3 || '''VLAN interface di atas bridge''' || Interfaces → VLAN || Gateway Layer 3. Bridge sendiri harus menjadi anggota '''tagged''' di setiap VLAN ("port internal" ke otak router).
|-
| 4 || '''Saklar <code>vlan-filtering</code>''' || Bridge → Bridge → tab VLAN || Selama mati, semua aturan VLAN diabaikan. '''Nyalakan paling akhir.'''
|}

'''Frame Types''' di Bridge → Ports:
* Access port: <code>admit-only-untagged-and-priority-tagged</code> (frame bertag dari PC dibuang).
* Trunk port: <code>admit-only-vlan-tagged</code>.

'''Peringatan''': mengaktifkan <code>vlan-filtering</code> saat terhubung ke router lewat port anggota bridge bisa memutus koneksi Winbox. Di router produksi, selalu nyalakan '''Safe Mode''' dulu.

<pre>
┌──────────── CHR ─────────────┐
│ vlan10 … vlan70 (gateway) │ ← Layer 3
│ │ tagged │
│ ┌─ bridge-vlan ──────┐ │ ← "switch"
│ │ ether2-4 access │ │
│ │ ether5-6 trunk │ │
│ └────────────────────┘ │
│ ether1 (WAN, di luar bridge) │
└───────────────────────────────┘
</pre>

=== Pemakaian di dunia nyata ===
Di lab PC dicolok langsung ke port router agar sederhana. Di dunia nyata, port router biasanya tersambung ke:

{| class="wikitable"
! Port !! Tipe !! Tersambung ke !! Keterangan
|-
| ether2 || access 10 || Switch ruangan staff || Switch biasa (bahkan unmanaged). Semua yang dicolok otomatis VLAN 10.
|-
| ether3 || trunk 10, 20 || Access point || Dua SSID: <code>Kantor</code> (VLAN 10) dan <code>Kantor-Tamu</code> (VLAN 20). Satu kabel, dua jaringan.
|-
| ether4 || trunk 10, 20, 30 || Server Proxmox || VM ditempatkan di VLAN mana pun lewat satu kabel.
|-
| ether5 || access 30 || Switch CCTV || Semua kamera terkurung di VLAN 30.
|}

Di kantor besar, router sering hanya memakai 1–2 port trunk ke switch inti. Switch MikroTik (CRS) dikonfigurasi dengan '''cara yang sama persis'''.

'''Homelab''': pola ini juga populer di rumah, misalnya VLAN keluarga, VLAN lab/server, VLAN IoT (smart TV, CCTV murah), dan VLAN tamu. Ingat: VLAN saja tidak mengisolasi, karena router tetap me-routing antar VLAN. Isolasi dibutuhkan lewat firewall ([[Belajar MikroTik Part 6|Part 6]]).

== Lab ==

=== Topologi ===
<pre>
[NAT]
│ ether1 (WAN)
[CHR] ── bridge-vlan
ether2 ether3 ether4 ether5 ether6
VLAN10 VLAN10 VLAN20 trunk 30+40 trunk 50+60+70
│ │ │ │ │
Staff1 Staff2 Tamu [Switch1] [Proxmox]
/ \ eth0.50/.60/.70
PC-30 PC-40
</pre>

{| class="wikitable"
! VLAN !! Subnet !! Gateway !! Lokasi
|-
| 10 || <code>172.16.10.0/24</code> || <code>.1</code> || ether2, ether3 (access)
|-
| 20 || <code>172.16.20.0/24</code> || <code>.1</code> || ether4 (access)
|-
| 30, 40 || <code>172.16.30.0/24</code>, <code>172.16.40.0/24</code> || <code>.1</code> || ether5 (trunk ke switch)
|-
| 50, 60, 70 || <code>172.16.50.0/24</code>, <code>.60.</code>, <code>.70.</code> || <code>.1</code> || ether6 (trunk ke server)
|}

PC memakai container <code>lab-ubuntu</code> (lihat [[Belajar MikroTik Lampiran: Linux Networking|lampiran Linux]]) atau VPCS.

=== 0. Persiapan ===
* Host: <code>virsh net-start default</code> dan aturan <code>DOCKER-USER</code> ([[Belajar MikroTik Part 1|Part 1]]).
* Project baru, identity, NAT masquerade di <code>ether1</code>, DNS Allow Remote Requests ([[Belajar MikroTik Part 4|Part 4]]).
* Backup: snapshot GNS3 atau <code>/export file=...</code>.

=== 1. Access port (ether2–ether4) ===
'''Bridge''': Bridge → Bridge → New, Name <code>bridge-vlan</code>, '''VLAN Filtering belum dicentang'''.

'''Ports''': Bridge → Ports → New
{| class="wikitable"
! Interface !! PVID !! Frame Types
|-
| <code>ether2</code> || 10 || admit only untagged and priority tagged
|-
| <code>ether3</code> || 10 || admit only untagged and priority tagged
|-
| <code>ether4</code> || 20 || admit only untagged and priority tagged
|}

'''Tabel VLAN''': Bridge → VLANs → New
{| class="wikitable"
! VLAN IDs !! Tagged !! Untagged
|-
| 10 || <code>bridge-vlan</code> || <code>ether2</code>, <code>ether3</code>
|-
| 20 || <code>bridge-vlan</code> || <code>ether4</code>
|}

'''Gateway''': VLAN interface di '''<code>bridge-vlan</code>''' (bukan di port fisik), IP, dan DHCP per VLAN.

'''Saklar''': Bridge → Bridge → <code>bridge-vlan</code> → tab VLAN → centang '''VLAN Filtering'''.

=== 2. Trunk ke switch (ether5, VLAN 30 + 40) ===
Switch GNS3: port 0 <code>dot1q</code> (ke <code>ether5</code>), port 1 <code>access 30</code> (PC-30), port 2 <code>access 40</code> (PC-40).

Di router:
* Bridge → Ports: <code>ether5</code>, Frame Types '''admit only VLAN tagged''', PVID dibiarkan default.
* Bridge → VLANs: VLAN 30 dan 40, Tagged <code>bridge-vlan</code> + <code>ether5</code>, Untagged kosong.
* VLAN interface <code>vlan30</code>, <code>vlan40</code> di <code>bridge-vlan</code>, IP, DHCP.

Access port menerima frame '''polos''' dan memakai PVID untuk menentukan VLAN. Trunk menerima frame '''bertag''' karena VLAN-nya sudah tertulis di tag.

=== 3. Trunk ke server (ether6, VLAN 50 + 60 + 70) ===
<syntaxhighlight lang="text">
/interface bridge port add bridge=bridge-vlan interface=ether6 frame-types=admit-only-vlan-tagged

/interface bridge vlan
add bridge=bridge-vlan vlan-ids=50 tagged=bridge-vlan,ether6
add bridge=bridge-vlan vlan-ids=60 tagged=bridge-vlan,ether6
add bridge=bridge-vlan vlan-ids=70 tagged=bridge-vlan,ether6

/interface vlan
add name=vlan50 interface=bridge-vlan vlan-id=50
add name=vlan60 interface=bridge-vlan vlan-id=60
add name=vlan70 interface=bridge-vlan vlan-id=70

/ip address
add address=172.16.50.1/24 interface=vlan50 comment=VLAN50-proxmox
add address=172.16.60.1/24 interface=vlan60 comment=VLAN60-proxmox
add address=172.16.70.1/24 interface=vlan70 comment=VLAN70-proxmox

/ip pool
add name=pool50 ranges=172.16.50.100-172.16.50.200
add name=pool60 ranges=172.16.60.100-172.16.60.200
add name=pool70 ranges=172.16.70.100-172.16.70.200

/ip dhcp-server network
add address=172.16.50.0/24 gateway=172.16.50.1 dns-server=172.16.50.1
add address=172.16.60.0/24 gateway=172.16.60.1 dns-server=172.16.60.1
add address=172.16.70.0/24 gateway=172.16.70.1 dns-server=172.16.70.1

/ip dhcp-server
add name=server50 interface=vlan50 address-pool=pool50
add name=server60 interface=vlan60 address-pool=pool60
add name=server70 interface=vlan70 address-pool=pool70
</syntaxhighlight>

'''Menambah trunk untuk VLAN yang sudah ada''' cukup menambahkan port ke kolom Tagged. Hati-hati: <code>set tagged=...</code> '''menimpa''' daftar lama, sehingga port yang sudah ada harus ditulis ulang:
<syntaxhighlight lang="text">
/interface bridge vlan set [find vlan-ids=30] tagged=bridge-vlan,ether5,ether6
</syntaxhighlight>

=== 4. Sisi server (container Linux) ===
<syntaxhighlight lang="bash">
ip link set eth0 up
for v in 50 60 70; do
ip link add link eth0 name eth0.$v type vlan id $v
ip link set eth0.$v up
dhclient -v eth0.$v
done
ip -br addr
</syntaxhighlight>

Hasil:
<pre>
eth0.50@eth0 UP 172.16.50.200/24
eth0.60@eth0 UP 172.16.60.200/24
eth0.70@eth0 UP 172.16.70.200/24
eth0 UP
</pre>

* <code>RTNETLINK answers: File exists</code> saat <code>dhclient</code> kedua/ketiga itu normal: Linux hanya memakai satu default gateway di tabel routing utama.
* Ctrl+C di tengah loop menghentikan '''seluruh''' loop. VLAN berikutnya harus dicoba manual.
* Baris <code>xid: warning ...</code> aman diabaikan.

=== Padanan di Proxmox sungguhan ===
<syntaxhighlight lang="text">
auto vmbr0
iface vmbr0 inet manual
bridge-ports eno1
bridge-stp off
bridge-fd 0
bridge-vlan-aware yes
bridge-vids 2-4094

auto vmbr0.50
iface vmbr0.50 inet static
address 172.16.50.20/24
gateway 172.16.50.1
</syntaxhighlight>
* <code>bridge-vlan-aware yes</code> = bridge Proxmox juga memakai VLAN filtering, konsepnya sama dengan <code>bridge-vlan</code> di MikroTik.
* <code>vmbr0.50</code> = IP manajemen host, statis di range server.
* Setiap VM: Bridge <code>vmbr0</code> + '''VLAN Tag''' di setting network VM.

== Verifikasi ==
* Setiap PC/VM mendapat IP sesuai VLAN-nya dan bisa <code>ping 8.8.8.8</code>.
* <code>trace</code> dalam satu VLAN langsung sampai; antar VLAN lewat gateway.
* '''Bridge → VLANs''': keanggotaan tagged/untagged sesuai rencana.
* '''Bridge → Hosts''': MAC setiap perangkat beserta port dan VLAN-nya.

Entri dinamis seperti <code>VLAN 1 ;;; added by pvid</code> di tabel VLAN itu normal: bridge sendiri punya PVID default 1.

== Masalah yang ditemui ==

=== VLAN interface berflag R tapi parameternya salah ===
Ketiga kasus di bawah sama-sama terlihat normal di <code>print</code> biasa. Flag '''R''' hanya berarti "interface hidup", bukan "konfigurasinya benar". Masalahnya baru terlihat di <code>print detail</code>.

{| class="wikitable"
! Kasus !! Temuan di <code>print detail</code> !! Penyebab !! Perbaikan
|-
| PC-30 & PC-40 tidak dapat IP || <code>vlan30</code> dan <code>vlan40</code>: <code>vlan-id=1</code> || Kolom VLAN ID terlewat, memakai default || <code>/interface vlan set vlan30 vlan-id=30</code>
|-
| PC-40 tidak dapat IP || <code>vlan40</code>: <code>use-service-tag=yes</code> || Checkbox '''Use Service Tag''' tercentang. Itu mode QinQ (penanda <code>0x88a8</code>), sedangkan switch mengirim tag biasa <code>0x8100</code>. || <code>... vlan-id=40 use-service-tag=no</code>
|-
| VLAN 50 jalan, VLAN 60 tidak || <code>vlan60</code>: <code>interface=ether1</code>, MAC sama dengan <code>ether1</code> || Dropdown Interface terpilih port WAN || <code>/interface vlan set vlan60 interface=bridge-vlan</code>
|}

Efek samping VLAN interface ber-ID 1 di atas bridge: muncul entri dinamis <code>VLAN 1 ;;; added by vlan on bridge</code> di tabel VLAN.

=== Diagnosis cepat ===
'''Kalau satu VLAN jalan dan VLAN lain tidak''' di trunk yang sama, jalur fisik dan trunk sudah benar. Fokus ke konfigurasi khusus VLAN yang gagal.

'''Menentukan layer masalah''': jalankan DHCP di client, sementara di router:
<syntaxhighlight lang="text">
/tool torch interface=vlan60
/tool sniffer quick interface=ether6
</syntaxhighlight>
* Ada traffic di <code>vlanXX</code> → paket sampai, masalah di DHCP/IP.
* Kosong → masalah di VLAN ID, interface induk, atau tabel bridge VLAN.

'''Perintah pengecekan lengkap'''
<syntaxhighlight lang="text">
/interface vlan print detail
/interface bridge print
/interface bridge port print
/interface bridge vlan print
/ip address print
/ip pool print
/ip dhcp-server print
/ip dhcp-server network print
/ip dhcp-server lease print
/log print where topics~"dhcp"
</syntaxhighlight>

== Checklist VLAN baru ==
# '''Bridge → VLANs''': VLAN ID; <code>bridge-vlan</code> + port trunk di Tagged; access port di Untagged.
# '''Interfaces → VLAN''': cek '''vlan-id''', '''interface = bridge-vlan''', '''use-service-tag = no'''.
# '''IP → Addresses''': gateway <code>.1</code>.
# '''DHCP''': gateway/DNS di Networks.
# Langsung jalankan <code>/interface vlan print detail</code>.

'''Tips''': simpan blok CLI VLAN sebagai template, ganti angkanya, lalu copy-paste. Sebagian besar kesalahan di lab ini terjadi saat mengisi form GUI.

== Latihan ==
# '''Tebak dulu''': hapus <code>ether6</code> dari Tagged di VLAN 60. Di container, <code>dhclient -r eth0.60</code> lalu <code>dhclient -v eth0.60</code>. Apa yang terjadi? Apakah VLAN 50 dan 70 ikut terdampak?
# '''IP manajemen statis''': lepas DHCP di <code>eth0.50</code>, pasang <code>172.16.50.20/24</code> dengan gateway <code>172.16.50.1</code>, sampai container bisa <code>ping 8.8.8.8</code> lewat VLAN 50.
# '''Detektif''': di '''Bridge → Hosts''', MAC container muncul berapa kali dan di VLAN apa saja? Kenapa satu MAC bisa muncul beberapa kali?
# '''Tebak dulu''': hapus <code>bridge-vlan</code> dari Tagged di VLAN 20 (biarkan <code>ether4</code> untagged). Apakah Tamu masih bisa mendapat IP? Ping gateway? Ping Staff1?

== Catatan ==
Bridge VLAN filtering sudah melampaui cakupan dasar MTCNA dan lebih dekat ke materi switching. Kesalahan di lab ini hampir semuanya salah input, bukan salah konsep. Kemampuan yang paling berguna bukan menghafal menu, tapi melacak kenapa sesuatu tidak berjalan.

== Ringkasan ==
* Satu VLAN di satu port → VLAN interface di port. Satu VLAN di banyak port → bridge VLAN filtering.
* PVID = VLAN untuk frame polos yang masuk. Tabel VLAN = keanggotaan dan tagged/untagged saat keluar.
* VLAN interface (gateway) ditempel di bridge, dan bridge harus tagged di setiap VLAN.
* Nyalakan <code>vlan-filtering</code> paling akhir, dengan Safe Mode di router produksi.
* Flag R bukan jaminan benar: biasakan <code>print detail</code>.

Networking

SanzSkuy — Mon, 26 Oct 2026 09:41:01 GMT

← Older revision		Revision as of 09:41, 26 October 2026
Line 17:		Line 17:
	* [[Mikrotik 3: Bridge]]		* [[Mikrotik 3: Bridge]]
	* [[Mikrotik 4: VLAN]]		* [[Mikrotik 4: VLAN]]
			* [[Mikrotik 5: Bridge VLAN Filtering]]

	= Cisco =		= Cisco =

Mikrotik 4: VLAN

SanzSkuy — Mon, 26 Oct 2026 06:33:34 GMT

Created page with "== Tujuan == * Paham VLAN, tag 802.1Q, access port, dan trunk port. * Bisa membuat VLAN interface dan gateway per VLAN di RouterOS. * Bisa melihat tag VLAN di Wireshark. * Paham dua kesalahan klasik: VLAN ditentukan port switch, dan trunk yang tidak sepakat di kedua ujung. == Konsep == === Masalah yang diselesaikan VLAN === Tanpa VLAN, setiap segmen butuh port router, switch, dan jalur kabel sendiri. Lima segmen (staff, tamu, CCTV, server, manajemen) berarti lima port..."

New page

== Tujuan ==
* Paham VLAN, tag 802.1Q, access port, dan trunk port.
* Bisa membuat VLAN interface dan gateway per VLAN di RouterOS.
* Bisa melihat tag VLAN di Wireshark.
* Paham dua kesalahan klasik: VLAN ditentukan port switch, dan trunk yang tidak sepakat di kedua ujung.

== Konsep ==

=== Masalah yang diselesaikan VLAN ===
Tanpa VLAN, setiap segmen butuh port router, switch, dan jalur kabel sendiri. Lima segmen (staff, tamu, CCTV, server, manajemen) berarti lima port router, lima switch, lima kabel.

'''VLAN (Virtual LAN)''' memecah satu switch fisik menjadi beberapa switch virtual yang terisolasi di Layer 2. Setiap VLAN punya nomor ('''VLAN ID''', 1–4094). Perangkat di VLAN berbeda tidak bisa saling meng-ARP, persis seperti berada di switch berbeda.

=== Tag 802.1Q ===
Satu kabel bisa membawa banyak VLAN karena setiap frame diberi '''tag''' (label) berisi VLAN ID. Standarnya '''IEEE 802.1Q'''.

<pre>
Frame biasa: [Dst MAC][Src MAC][Type][ Data ][FCS]
Frame 802.1Q: [Dst MAC][Src MAC][TAG][Type][ Data ][FCS]
└ 4 byte tambahan
</pre>

Isi tag (4 byte):
{| class="wikitable"
! Bagian !! Ukuran !! Fungsi
|-
| '''TPID''' || 16 bit || Penanda <code>0x8100</code>: "frame ini bertag 802.1Q"
|-
| '''PRI''' (PCP) || 3 bit || Prioritas untuk QoS (misalnya VoIP didahulukan)
|-
| '''DEI''' || 1 bit || Tanda boleh dibuang lebih dulu saat padat
|-
| '''VLAN ID''' || 12 bit || Nomor VLAN (212 = 4096, dipakai 1–4094)
|}

Contoh di Wireshark:
<pre>
Ethernet II, Src: 00:50:79:66:68:00, Dst: ...
802.1Q Virtual LAN, PRI: 0, DEI: 0, ID: 10 ← tag
Internet Protocol Version 4, Src: 172.16.10.x, Dst: 8.8.8.8
</pre>

=== Access port vs trunk port ===
{| class="wikitable"
! !! Access port !! Trunk port
|-
| Membawa || '''Satu''' VLAN || '''Banyak''' VLAN
|-
| Frame || '''Untagged''' || '''Tagged'''
|-
| Tersambung ke || PC, printer, CCTV || Switch lain, router, server Proxmox
|}

'''PC tidak tahu apa-apa soal VLAN.''' PC mengirim frame polos. Switch menempelkan tag saat frame masuk dari access port, dan melepas tag saat frame keluar ke access port. Tag hanya hidup di jalur trunk.

'''Native VLAN''': VLAN yang lewat trunk '''tanpa tag'''. Di switch GNS3, kolom VLAN pada port <code>dot1q</code> adalah native VLAN (default <code>1</code>).

=== Router-on-a-stick ===
Setiap VLAN adalah segmen terpisah, sehingga butuh '''subnet dan gateway sendiri'''. Router cukup tersambung ke switch dengan '''satu kabel trunk''', lalu membuat satu '''VLAN interface''' per VLAN (misalnya <code>vlan10</code>, <code>vlan20</code>). Setiap VLAN interface diberi IP gateway. Satu kabel, banyak gateway.

=== Keuntungan dan harga yang dibayar ===
'''Keuntungan'''
* Hemat port router: satu port trunk bisa membawa banyak segmen.
* Hemat switch: satu switch fisik dipakai bersama semua segmen.
* Hemat kabel antar lantai/ruangan: cukup satu trunk per switch.
* Fleksibel: memindahkan PC ke segmen lain cukup mengubah setting port switch.

'''Harga yang dibayar'''
* '''Bandwidth trunk dibagi''' semua VLAN. Traffic antar VLAN naik ke router lewat trunk lalu turun lagi lewat trunk yang sama.
* '''Single point of failure''': trunk putus = semua VLAN di switch itu putus.
* '''Butuh managed switch'''. Switch unmanaged tidak mengerti tag.
* CPU router mengerjakan semua routing antar VLAN.

'''Solusi umum''': trunk di port cepat (SFP+ 10 Gbps), '''bonding/LACP''' (beberapa kabel menjadi satu trunk dengan cadangan), atau '''switch Layer 3''' untuk routing antar VLAN di kantor besar.

=== Managed vs unmanaged switch ===
{| class="wikitable"
! !! Unmanaged !! Managed (termasuk "smart/easy smart")
|-
| Setup || Colok langsung jalan || Colok langsung jalan, tapi bisa dikonfigurasi
|-
| IP / web UI || Tidak ada || Ada (web UI, SSH/CLI, port console)
|-
| VLAN || Tidak || Ya
|-
| Fitur lain || – || Monitoring per port, port mirroring, LACP, STP, limit bandwidth
|-
| Contoh || Switch 5–8 port murah || MikroTik CRS/CSS, Cisco Catalyst, TP-Link Easy Smart/JetStream, UniFi
|}

Managed switch baru '''berperilaku seperti unmanaged''': semua port default <code>access VLAN 1</code>.

'''Jebakan di kantor'''
* Unmanaged switch di '''access port VLAN 10''' → semua perangkat di switch kecil itu masuk VLAN 10. Normal dan sering disengaja.
* Unmanaged switch di '''trunk port''' → perangkat hanya mendapat native VLAN, sementara frame bertag VLAN lain ikut diteruskan. Gejalanya: "PC di ruangan ini dapat IP dari segmen yang salah."

== Lab ==

=== Topologi ===
<pre>
[NAT]
│
ether1 (WAN, DHCP client)
│
[CHR]
ether2
║ trunk (VLAN 10 + 20)
║
[Switch1]
port1 port2 port3
VLAN10 VLAN10 VLAN20
│ │ │
Staff1 Staff2 Tamu

vlan10 → 172.16.10.1/24 (staff)
vlan20 → 172.16.20.1/24 (tamu)
</pre>

'''Konvensi alamat''': range privat <code>172.16.0.0/12</code>, dengan oktet ketiga = VLAN ID (VLAN 10 → <code>172.16.10.0/24</code>). Memudahkan saat VLAN sudah puluhan.

=== 1. Persiapan host dan project ===
<syntaxhighlight lang="bash">
sudo virsh net-start default 2>/dev/null
sudo iptables -I DOCKER-USER -i virbr0 -j ACCEPT
sudo iptables -I DOCKER-USER -o virbr0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
</syntaxhighlight>
* GNS3: '''File → New blank project''' (contoh nama: <code>fase2-vlan</code>).
* Perangkat: NAT, MikroTik CHR, Ethernet switch, 3 VPCS (beri nama Staff1, Staff2, Tamu).

=== 2. Konfigurasi switch GNS3 ===
Nyalakan '''View → Show interface labels''' untuk melihat nomor port tiap kabel, lalu klik kanan switch → '''Configure'''.

Untuk setiap port: klik barisnya di daftar '''Ports''', isi '''VLAN''' dan '''Type''', lalu klik '''Add''' (menimpa setting port dengan nomor yang sama). Akhiri dengan '''Apply → OK'''. Kalau perubahan tidak tersimpan, stop switch dulu.

{| class="wikitable"
! Port !! Ke !! VLAN !! Type
|-
| 0 || CHR <code>ether2</code> || 1 || <code>dot1q</code>
|-
| 1 || Staff1 || 10 || <code>access</code>
|-
| 2 || Staff2 || 10 || <code>access</code>
|-
| 3 || Tamu || 20 || <code>access</code>
|}

<code>dot1q</code> = trunk 802.1Q. QinQ EtherType dibiarkan <code>0x8100</code> (hanya dipakai pada type <code>qinq</code>). Sesuaikan nomor port dengan label kabel.

=== 3. Setup dasar CHR ===
Di console:
<syntaxhighlight lang="text">
/system identity set name=router-vlan
/ip address print
</syntaxhighlight>
Catat IP WAN di <code>ether1</code>, connect Winbox, lalu:
* '''IP → Firewall → NAT''': <code>srcnat</code>, Out. Interface <code>ether1</code>, <code>masquerade</code>
* '''IP → DNS''': centang '''Allow Remote Requests'''
* Tes: <code>/ping 8.8.8.8 count=3</code>

=== 4. VLAN interface dan gateway ===
{| class="wikitable"
! Winbox !! Isian !! CLI
|-
| '''Interfaces → VLAN''' → New || <code>vlan10</code>, VLAN ID <code>10</code>, Interface <code>ether2</code> || <code>/interface vlan add name=vlan10 vlan-id=10 interface=ether2</code>
|-
| '''Interfaces → VLAN''' → New || <code>vlan20</code>, VLAN ID <code>20</code>, Interface <code>ether2</code> || <code>/interface vlan add name=vlan20 vlan-id=20 interface=ether2</code>
|-
| '''IP → Addresses''' → New || <code>172.16.10.1/24</code> di <code>vlan10</code>, comment <code>VLAN10-staff</code> || <code>/ip address add address=172.16.10.1/24 interface=vlan10 comment=VLAN10-staff</code>
|-
| '''IP → Addresses''' → New || <code>172.16.20.1/24</code> di <code>vlan20</code>, comment <code>VLAN20-tamu</code> || <code>/ip address add address=172.16.20.1/24 interface=vlan20 comment=VLAN20-tamu</code>
|}

<code>ether2</code> sendiri '''tidak diberi IP'''. Ia hanya kabel trunk, sedangkan kerja Layer 3 ada di <code>vlan10</code> dan <code>vlan20</code>. Sama seperti aturan bridge: IP di interface logis, bukan di port fisik.

=== 5. DHCP per VLAN ===
Setiap VLAN butuh '''pool, network, dan server sendiri''' karena subnetnya berbeda.

'''Lewat DHCP Setup''' (jalankan untuk <code>vlan10</code>, lalu <code>vlan20</code>): wizard membuat pool otomatis. Ubah '''Addresses to Give Out''' menjadi <code>.100–.200</code> agar <code>.2–.99</code> tetap kosong untuk perangkat statis.

'''Manual''':
{| class="wikitable"
! Bagian !! VLAN 10 !! VLAN 20
|-
| Pool || <code>172.16.10.100-172.16.10.200</code> || <code>172.16.20.100-172.16.20.200</code>
|-
| Network || <code>172.16.10.0/24</code>, gateway & DNS <code>172.16.10.1</code> || <code>172.16.20.0/24</code>, gateway & DNS <code>172.16.20.1</code>
|-
| Server || Interface <code>vlan10</code> || Interface <code>vlan20</code>
|}

'''Periksa''': pool di subnet yang benar, gateway/DNS = <code>.1</code>, server menempel di <code>vlan10</code>/<code>vlan20</code> (bukan <code>ether2</code>). Rule NAT tidak perlu diubah.

== Verifikasi ==
<syntaxhighlight lang="text">
ip dhcp
show ip
ping 8.8.8.8
trace <IP PC lain>
</syntaxhighlight>
* Staff1 dan Staff2 mendapat <code>172.16.10.x</code>, Tamu mendapat <code>172.16.20.x</code>.
* <code>trace</code> Staff1 → Staff2: langsung sampai (satu VLAN, di-switch).
* <code>trace</code> Staff1 → Tamu: lewat <code>172.16.10.1</code> (beda VLAN, di-route).

Ketiganya tersambung ke '''switch fisik yang sama''', tapi VLAN memisahkan mereka di Layer 2.

Kalau PC hanya menampilkan "DDD", periksa dulu kecocokan nomor port switch dengan label kabel.

== Latihan dan pembahasan ==

=== Soal 1: melihat tag ===
'''Soal''': capture Wireshark di kabel CHR ↔ Switch1 (trunk) dan Switch1 ↔ Staff1 (access), lalu ping dari Staff1. Di mana ada tag 802.1Q? VLAN ID-nya berapa?

'''Pembahasan'''
* '''Trunk''': ada baris <code>802.1Q Virtual LAN</code> dengan '''ID 10 dan ID 20'''. Meskipun ping hanya dari Staff1 (VLAN 10), traffic Tamu (ARP, DHCP renew) juga lewat kabel yang sama. Bukti satu trunk membawa banyak VLAN.
* '''Access''': tidak ada tag, frame polos.
* Alur: Staff1 mengirim frame polos → Switch1 menempelkan tag <code>ID: 10</code> → CHR membaca tag dan menyerahkan frame ke <code>vlan10</code>. Arah balik, switch melepas tag sebelum frame sampai ke Staff1.

=== Soal 2: menambah VLAN CCTV ===
'''Soal''': buat VLAN 30 (<code>172.16.30.0/24</code>) dengan PC4 sampai bisa internetan.

'''Pembahasan'''
{| class="wikitable"
! Di mana !! Perubahan
|-
| Router || '''Interfaces → VLAN''': <code>vlan30</code>, ID <code>30</code>, di <code>ether2</code>
|-
| Router || '''IP → Addresses''': <code>172.16.30.1/24</code> di <code>vlan30</code>
|-
| Router || DHCP: pool, network (gateway/DNS <code>172.16.30.1</code>), server di <code>vlan30</code>
|-
| Router || NAT: tidak perlu diubah
|-
| Switch || Port PC4: <code>access</code> VLAN <code>30</code>
|-
| Switch || Port trunk: tidak diubah (di GNS3)
|}

* '''Jangan lupa IP gateway''' di <code>vlan30</code>. DHCP Setup bisa berjalan tanpanya, tapi PC akan mendapat gateway yang tidak ada di router.
* '''Trunk di GNS3''' otomatis membawa semua VLAN. Di banyak switch sungguhan (termasuk MikroTik), trunk harus '''didaftarkan VLAN mana saja yang boleh lewat'''. Lupa menambahkan VLAN baru ke trunk = PC di VLAN itu "DDD" terus, padahal konfigurasi lain sudah benar.
* Beri comment <code>VLAN30-cctv</code> di semua objek terkait.

=== Soal 3: memindahkan VLAN tanpa menyentuh PC ===
'''Soal''': ubah port Tamu dari access VLAN 20 menjadi access VLAN 10, tanpa mengubah PC. Lalu <code>ip dhcp -x</code> dan <code>ip dhcp</code>.

'''Hasil''': Tamu mendapat <code>172.16.10.x</code>.

'''Pembahasan''': '''VLAN sebuah PC ditentukan oleh port switch tempat ia tersambung.''' PC tidak tahu dan tidak bisa memilih.
* '''Enak''': memindahkan karyawan ke segmen lain cukup mengubah port switch.
* '''Bahaya''': siapa pun yang mencolok laptop ke port staff langsung masuk jaringan staff. Keamanan port fisik penting. Solusi lanjutannya '''802.1X''' (perangkat harus login sebelum port dibuka), yaitu fitur di menu '''Dot1X''' RouterOS.

=== Soal 4: trunk yang salah ===
'''Soal''': ubah port trunk (port 0) dari <code>dot1q</code> menjadi <code>access</code> VLAN 10.

'''Hasil''': Staff1 dan Tamu sama-sama tidak bisa internetan, tapi dengan alasan berbeda.

<pre>
Normal (dot1q): switch ══[tag 10][tag 20]══► CHR → vlan10 / vlan20 ✅
Salah (access 10): switch ───[polos, VLAN 10 saja]──► CHR → ether2 (tanpa IP) ❌
VLAN 20 → tidak dikirim sama sekali ❌
</pre>

* '''Staff1''': switch mengirim traffic VLAN 10 ke CHR '''tanpa tag'''. <code>vlan10</code> hanya menerima frame bertag 10, sehingga frame polos jatuh ke <code>ether2</code> yang tidak punya IP. ARP ke gateway tidak pernah terjawab.
* '''Tamu''': port 0 sekarang hanya anggota VLAN 10, sehingga frame VLAN 20 tidak pernah dikirim keluar. Tamu terkurung di dalam switch.

'''Pelajaran''': kedua ujung trunk harus '''sepakat'''. Kalau satu sisi mengirim bertag dan sisi lain menunggu polos (atau sebaliknya), link terlihat menyala (lampu hijau, interface Running), tapi traffic tidak tersambung. Sering terjadi saat mengganti switch atau saat ada yang "merapikan" konfigurasi.

== Kesalahan umum ==
{| class="wikitable"
! Gejala !! Penyebab !! Solusi
|-
| PC "DDD" setelah setting VLAN || Nomor port switch tidak cocok dengan kabel || Cek '''Show interface labels'''
|-
| PC dapat IP tapi tidak bisa internetan || IP gateway belum dipasang di VLAN interface || '''IP → Addresses''' di <code>vlanXX</code>
|-
| PC di VLAN baru "DDD" padahal router benar || VLAN belum didaftarkan di trunk switch || Tambahkan VLAN ke daftar trunk
|-
| Link menyala tapi semua VLAN putus || Trunk tidak sepakat (tagged vs untagged) || Samakan konfigurasi kedua ujung
|-
| PC dapat IP dari segmen yang salah || Port switch salah VLAN, atau unmanaged switch di trunk port || Periksa port dan perangkat yang tersambung
|-
| Comment tidak sesuai isi || Typo saat membuat objek || Perbaiki, karena comment adalah dokumentasi
|}

== Ringkasan ==
* VLAN memecah satu switch menjadi beberapa segmen Layer 2 terpisah.
* Tag 802.1Q (4 byte, berisi VLAN ID) hanya ada di trunk. PC selalu mengirim frame polos.
* Access = satu VLAN untagged. Trunk = banyak VLAN tagged.
* Router-on-a-stick: satu trunk, satu VLAN interface + gateway per VLAN.
* VLAN ditentukan port switch, bukan PC.
* Kedua ujung trunk harus sepakat.

Networking

SanzSkuy — Mon, 26 Oct 2026 06:33:28 GMT

← Older revision		Revision as of 06:33, 26 October 2026
Line 16:		Line 16:
	* [[Mikrotik 2: Kantor Mini]]		* [[Mikrotik 2: Kantor Mini]]
	* [[Mikrotik 3: Bridge]]		* [[Mikrotik 3: Bridge]]
			* [[Mikrotik 4: VLAN]]

	= Cisco =		= Cisco =

Mikrotik 3: Bridge

SanzSkuy — Sun, 25 Oct 2026 05:17:00 GMT

Created page with ""''bridge''' adalah cara menggabungkan beberapa port router menjadi satu segmen jaringan. == Tujuan == * Paham apa itu bridge dan kenapa port router defaultnya berdiri sendiri. * Tahu kapan memakai bridge dan kapan memisahkan segmen. * Bisa membuktikan beda '''switching''' dan '''routing''' lewat <code>trace</code>. * Bisa melacak perangkat ke port fisik lewat '''Bridge → Hosts'''. == Konsep == === Port router berdiri sendiri === Di RouterOS, '''setiap port etherne..."

New page

"''bridge''' adalah cara menggabungkan beberapa port router menjadi satu segmen jaringan.

== Tujuan ==
* Paham apa itu bridge dan kenapa port router defaultnya berdiri sendiri.
* Tahu kapan memakai bridge dan kapan memisahkan segmen.
* Bisa membuktikan beda '''switching''' dan '''routing''' lewat <code>trace</code>.
* Bisa melacak perangkat ke port fisik lewat '''Bridge → Hosts'''.

== Konsep ==

=== Port router berdiri sendiri ===
Di RouterOS, '''setiap port ethernet adalah interface terpisah'''. Tanpa bridge, <code>ether2</code> dan <code>ether3</code> adalah dua segmen yang sama sekali tidak tersambung, seperti dua switch tanpa kabel penghubung.

Konsekuensinya:
* Setiap port yang dipakai butuh '''subnet sendiri''' (seperti Part 2: <code>ether2</code> = <code>192.168.10.0/24</code>, <code>ether3</code> = <code>192.168.11.0/24</code>).
* Subnet yang sama '''tidak bisa''' dipasang di dua port (network tidak boleh tumpang tindih).
* Port tanpa IP dan bukan anggota bridge '''tidak melakukan apa-apa'''. Perangkat yang dicolok ke sana tidak mendapat apa pun.

{| class="wikitable"
! Perangkat !! Kondisi default port LAN
|-
| Router rumahan || Sudah menjadi satu switch dari pabrik
|-
| Router MikroTik fisik || Biasanya membawa '''defconf''': port LAN sudah dimasukkan ke <code>bridge</code>
|-
| CHR || Tidak ada defconf, setiap port berdiri sendiri
|}

Bridge dengan comment <code>defconf</code> di router MikroTik adalah bridge bawaan pabrik. Bridge lain biasanya dibuat oleh admin untuk memisahkan segmen.

=== Apa itu bridge ===
'''Bridge adalah switch versi software di dalam router.''' Port yang dimasukkan ke satu bridge menjadi '''satu segmen Layer 2''', seolah dicolok ke satu switch.

Konsep yang sama dipakai di tempat lain:
* <code>virbr0</code> (libvirt, [[Belajar MikroTik Part 1|Part 1]])
* <code>vmbr0</code> (Proxmox)

'''Dua aturan penting'''
# '''IP, DHCP server, dan konfigurasi Layer 3 lainnya dipasang di bridge''', bukan di port anggotanya. Port anggota hanya menjadi "colokan switch".
# Port anggota bridge mendapat flag '''S''' (slave). Flag '''RS''' = Running + Slave.

=== Bridge vs segmen terpisah ===
Analogi: bridge = satu ruangan besar, semua bisa langsung bicara. Segmen terpisah = banyak ruangan, komunikasi antar ruangan lewat resepsionis (router).

{| class="wikitable"
! !! Segmen terpisah (routed) !! Bridge (switched)
|-
| '''Konfigurasi''' || Subnet, pool, DHCP server, DHCP network per port || Satu set untuk semua port
|-
| '''Pindah colokan''' || IP ikut berubah || IP tetap
|-
| '''Discovery berbasis broadcast/multicast''' (printer, network discovery, AirPlay, Wake-on-LAN) || Tidak menyeberang subnet || Berjalan
|-
| '''Kinerja antar port''' || Di-route oleh CPU || Di perangkat fisik bisa memakai '''hardware offload''' switch chip (di CHR semuanya software)
|-
| '''Isolasi''' || Bisa diberi firewall antar segmen || Tidak ada isolasi
|-
| '''Dampak masalah''' (loop, broadcast storm, rogue DHCP) || Terbatas di satu segmen || Mengenai semua perangkat di bridge
|}

'''Kapan memakai yang mana'''
* Port LAN biasa untuk karyawan → '''bridge'''.
* Perlu memisahkan tamu, CCTV, atau server → '''segmen terpisah''' + firewall.

Di kantor biasanya '''kombinasi''': beberapa bridge, masing-masing berisi beberapa port, dan antar bridge di-route. Memisahkan segmen per port fisik itu kaku, sehingga solusi modernnya adalah '''VLAN''' ([[Belajar MikroTik Part 4|Part 4]]).

== Lab: menggabungkan ether2 + ether3 ==

=== Topologi ===
<pre>
[NAT]
│
ether1 (WAN)
│
[MikroTikCHR-1]
│ │ │
┌── bridge-lan ──┐ ether4
│ 192.168.10.1/24│ 192.168.20.1/24
ether2 ether3 │
│ │ [Switch3]
[Switch1] [Switch2] │
PC1 PC2 PC3 PC4 PC5 PC6
</pre>
* <code>ether2</code> + <code>ether3</code> digabung di <code>bridge-lan</code>, sehingga PC1–PC5 berada di satu subnet.
* <code>ether4</code> berdiri sendiri dengan subnet <code>192.168.20.0/24</code> sebagai '''pembanding''' segmen yang di-route.

=== 0. Backup dulu ===
Biasakan sebelum mengubah konfigurasi:
* GNS3: '''Edit → Manage snapshots → Create'''
* atau di terminal router:
<syntaxhighlight lang="text">
/export file=fase1-selesai
</syntaxhighlight>

=== 1. Hapus konfigurasi LAN2 lama ===
* '''IP → Addresses''': hapus <code>192.168.11.1/24</code>
* '''IP → DHCP Server → DHCP''': hapus server di <code>ether3</code>
* '''IP → DHCP Server → Networks''': hapus <code>192.168.11.0/24</code>
* '''IP → Pool''': hapus <code>pool-lan2</code>

=== 2–5. Buat bridge dan pindahkan konfigurasi ===
{| class="wikitable"
! # !! Winbox !! Isian !! CLI
|-
| 2 || '''Bridge → Bridge''' → New || Name <code>bridge-lan</code> || <code>/interface bridge add name=bridge-lan</code>
|-
| 3 || '''Bridge → Ports''' → New (dua kali) || <code>ether2</code> dan <code>ether3</code> ke <code>bridge-lan</code> || <code>/interface bridge port add bridge=bridge-lan interface=ether2</code> <code>/interface bridge port add bridge=bridge-lan interface=ether3</code>
|-
| 4 || '''IP → Addresses''' → edit <code>192.168.10.1/24</code> || Interface: <code>bridge-lan</code> || <code>/ip address set [find address="192.168.10.1/24"] interface=bridge-lan</code>
|-
| 5 || '''IP → DHCP Server → DHCP''' → edit server LAN || Interface: <code>bridge-lan</code> || <code>/ip dhcp-server set [find interface=ether2] interface=bridge-lan</code>
|}

Rule NAT tidak perlu diubah, karena tetap mencocokkan <code>out-interface=ether1</code>.

=== 6. Perbarui IP di semua PC ===
<syntaxhighlight lang="text">
ip dhcp -x
ip dhcp
show ip
</syntaxhighlight>

=== Pembanding: segmen ether4 ===
Untuk Switch3 + PC6, <code>ether4</code> dikonfigurasi seperti LAN di Part 2: IP <code>192.168.20.1/24</code>, pool, DHCP network (gateway & DNS <code>192.168.20.1</code>), dan DHCP server sendiri.

== Verifikasi ==
* PC1–PC5 mendapat IP <code>192.168.10.x</code> dari pool yang sama dengan gateway <code>192.168.10.1</code>.
* '''Interfaces''': <code>ether2</code> dan <code>ether3</code> berflag '''RS'''.
* '''Bridge → Hosts''': daftar MAC semua PC beserta port tempat mereka terhubung.
* <code>ping 8.8.8.8</code> dari PC berhasil.

== Membaca <code>trace</code> ==
<syntaxhighlight lang="text">
trace <IP tujuan> # di VPCS
/tool traceroute 8.8.8.8 # di router
</syntaxhighlight>

Setiap baris adalah satu '''hop''', yaitu perangkat Layer 3 (router) yang dilewati. Trace mengirim paket dengan '''TTL''' kecil (mulai dari 1). Setiap router mengurangi TTL satu, dan router tempat TTL habis membalas, sehingga trace bisa menyusun daftar router di sepanjang jalur.

* '''Switch dan bridge tidak mengurangi TTL''', sehingga tidak pernah muncul di hasil trace.
* Baris terakhir dengan <code>Destination port unreachable</code> itu '''normal'''. VPCS mengirim UDP ke port yang tidak dipakai, dan balasan "port tidak ada" menandakan paket sudah sampai di tujuan.

== Latihan dan pembahasan ==

=== Soal 1: bandingkan trace dengan Fase 1 ===
'''Soal''': trace dari PC1/PC4 ke PC lain di bridge, bandingkan dengan Fase 1 (Part 2) dan dengan PC6.

'''Hasil'''
<pre>
PC6 → PC1 (192.168.10.200):
1 192.168.20.1 ← router, beda subnet → di-route
2 192.168.10.200 ← tujuan

PC4 → PC1 (192.168.10.200):
1 192.168.10.200 ← langsung sampai, satu bridge → di-switch
</pre>

'''Pembahasan'''
* Di Fase 1, PC1 dan PC4 berada di subnet berbeda, sehingga ada hop tambahan lewat router.
* Sekarang PC4 dan PC1 berada di '''satu bridge = satu segmen Layer 2'''. PC4 meng-ARP PC1 secara langsung, dan CHR hanya meneruskan frame seperti switch.
* Paket '''tetap melewati CHR secara fisik''', tapi tidak muncul sebagai hop. Router yang sama bekerja sebagai '''switch''' untuk traffic di dalam bridge dan sebagai '''router''' untuk traffic antar subnet (seperti ke PC6).

=== Soal 2: detektif port ===
'''Soal''': hanya lewat '''Bridge → Hosts''', tentukan PC5 terhubung di port mana.

'''Pembahasan''': cocokkan MAC dari <code>show ip</code> di PC5 dengan tabel Hosts → '''<code>ether3</code>'''. Di kantor, ini cara tercepat mencari "PC ini dicolok di port mana" tanpa menyusuri kabel.

=== Soal 3: disable port anggota bridge ===
'''Soal''': disable <code>ether3</code> di '''Bridge → Ports'''. Apakah PC4 masih bisa ping PC5? Ping PC1?

'''Hasil''': PC4 → PC5 '''bisa''', PC4 → PC1 '''tidak bisa'''.

'''Pembahasan'''
* '''PC4 → PC5''': keduanya terhubung ke Switch2. Switch2 meneruskan frame di antara mereka sendiri tanpa butuh router atau bridge.
* '''PC4 → PC1''': <code>ether3</code> adalah satu-satunya penghubung Switch2 ke bridge. Setelah port itu mati, Switch2 menjadi "pulau" terpisah.
* '''Kenapa router tidak menolong?''' PC4 menganggap PC1 '''tetangga''' (sama-sama <code>192.168.10.x</code>), sehingga PC4 tidak pernah memakai gateway untuk menuju PC1. Ia hanya meng-ARP PC1, dan ARP itu tidak sampai ke mana pun. '''Di dalam satu subnet, kalau jalur Layer 2 putus, router tidak bisa menjadi jalur alternatif.'''
* Gateway (<code>192.168.10.1</code>) dan internet juga tidak terjangkau dari PC4 dan PC5.

'''Pelajaran di kantor''': gejala '''"satu ruangan tidak bisa apa-apa, tapi PC di ruangan itu masih bisa saling berbagi file"''' hampir pasti masalah '''uplink''' switch ruangan tersebut: kabel uplink, port di router/switch inti, atau port yang ter-disable.

Jangan lupa enable kembali <code>ether3</code>.

== Masalah yang ditemui ==

=== Gateway DHCP berisi alamat network ===
'''Gejala''': DHCP Networks berisi gateway <code>192.168.10.0</code> dan DNS kosong setelah menjalankan '''DHCP Setup'''.

'''Penyebab''': isian gateway di wizard salah. <code>.0</code> adalah alamat network, bukan alamat perangkat.

'''Solusi''': '''IP → DHCP Server → Networks''' → gateway & DNS <code>192.168.10.1</code>. Selalu periksa hasil wizard.

=== Static lease hilang setelah DHCP Setup ===
'''Gejala''': lease PC1 kembali bertanda '''D''' (dynamic), nama server menjadi <code>server1</code> dan pool menjadi <code>pool1</code>.

'''Penyebab''': lease terikat ke DHCP server. Server lama diganti oleh wizard, sehingga static lease ikut hilang.

'''Solusi''': buat ulang static lease. '''Pelajaran''': wizard bisa menimpa konfigurasi lama tanpa peringatan, jadi backup sebelum menjalankannya.

=== IP WAN berubah ===
'''Gejala''': IP <code>ether1</code> berubah dari <code>192.168.122.212</code> menjadi <code>192.168.122.61</code>.

'''Penyebab''': CHR/lab di-restart dan mendapat lease baru dari dnsmasq <code>virbr0</code>. Flag '''D''' pada alamat WAN memang akan selalu ada karena dibuat oleh DHCP client.

'''Dampak''': NAT tetap berjalan karena masquerade otomatis memakai IP yang sedang menempel. Winbox harus connect ulang ke IP baru. Ini contoh nyata kenapa masquerade cocok untuk WAN dinamis.

=== VPCS hanya menampilkan "DDD" ===
'''Gejala'''
<pre>
PC1> ip dhcp
DDD
Can't find dhcp server
</pre>

'''Arti''': VPCS mencetak satu huruf per langkah DORA. '''D''' = Discover terkirim. "DDD" berarti tiga Discover terkirim '''tanpa Offer''' yang kembali.

'''Langkah diagnosis'''
# Periksa konfigurasi DHCP Networks (gateway & DNS).
# '''Log''' router: cari pesan dari <code>dhcp</code>.
# '''IP → DHCP Server → DHCP''': pastikan server tidak berflag '''X''' (disabled) atau '''I''' (invalid).
# '''Tools → Torch''' di <code>bridge-lan</code>: kalau muncul traffic <code>0.0.0.0 → 255.255.255.255</code> (port 68 → 67), Discover sampai di router dan masalahnya di konfigurasi. Kalau kosong, masalahnya di jalur kabel/bridge.
# '''Bridge → Hosts''': apakah MAC PC terlihat.
# Di VPCS: <code>ip dhcp -d</code> untuk melihat detail paket.

'''Penyebab di lab ini''': GNS3 "nyangkut" (koneksi virtual antar node tidak terbentuk ulang dengan benar setelah topologi diubah). Selesai setelah GNS3 di-restart.

'''Urutan perbaikan kalau GNS3 berperilaku aneh''' (setelah konfigurasi dipastikan benar):
# Stop/start node yang bermasalah, termasuk switch.
# Hapus dan sambungkan ulang kabel.
# Restart GNS3.

== Sisipan: bridge di dunia virtualisasi (Proxmox) ==
Server Proxmox di LAN bisa menghasilkan banyak IP dari VM-VM-nya. Cara VM terlihat di jaringan tergantung modelnya.

{| class="wikitable"
! Model !! Cara kerja !! Kelebihan !! Kekurangan
|-
| '''Bridged''' (default, <code>vmbr0</code>) || Bridge menyatukan NIC fisik dan NIC virtual VM. Setiap VM punya MAC sendiri dan terlihat seperti PC terpisah. || VM dapat IP dari DHCP router, bisa diakses langsung dari LAN || Setiap VM memakan IP subnet kantor
|-
| '''NAT''' || Host menjadi router mini dan me-masquerade VM (sama seperti <code>virbr0</code>) || Hemat IP, VM terisolasi || VM tidak bisa diakses langsung, perlu port forwarding
|-
| '''Subnet/VLAN khusus''' || VM di segmen sendiri, di-route oleh router || Rapi, bisa diberi firewall || Butuh VLAN (Part 4)
|}

'''Manajemen IP'''
* '''Rencanakan pembagian IP''', contoh untuk <code>/24</code>:
{| class="wikitable"
! Range !! Untuk
|-
| <code>.1</code> || Gateway
|-
| <code>.2–.19</code> || Perangkat jaringan (switch, AP)
|-
| <code>.20–.79</code> || Server & VM (statis)
|-
| <code>.80–.99</code> || Printer, CCTV
|-
| <code>.100–.250</code> || Pool DHCP
|}
* '''Server/VM memakai IP tetap''': manual di dalam VM atau static lease. MAC VM Proxmox tersimpan permanen di konfigurasi VM, sehingga static lease bekerja baik.
* '''Hati-hati saat clone''': clone biasanya mendapat MAC baru, sehingga static lease tidak ikut. IP statis yang di-hardcode di template akan ikut ter-clone dan menyebabkan IP conflict.
* '''Catat semuanya (IPAM)''': spreadsheet, atau tools seperti '''NetBox''' / '''phpIPAM'''.
* '''Pantau ukuran subnet''': <code>/24</code> hanya 254 host. Kolom '''Available''' di menu Pool menunjukkan sisa IP.

Di host Proxmox, cek <code>/etc/network/interfaces</code>:
* <code>vmbr0</code> dengan <code>bridge-ports eno1</code> → bridged.
* <code>bridge-vlan-aware yes</code> → VM dipisah dengan VLAN.

== Ringkasan ==
* Port RouterOS defaultnya berdiri sendiri, dan bridge menggabungkannya menjadi satu segmen Layer 2.
* Konfigurasi Layer 3 (IP, DHCP) dipasang di '''bridge''', bukan di port anggota.
* Di dalam bridge = '''switching''' (tidak ada hop). Antar subnet = '''routing''' (ada hop lewat gateway).
* Dalam satu subnet, jalur Layer 2 yang putus tidak bisa ditolong router.
* Wizard praktis, tapi periksa hasilnya dan backup sebelum menjalankannya.

Networking

SanzSkuy — Sun, 25 Oct 2026 05:16:52 GMT

← Older revision		Revision as of 05:16, 25 October 2026
Line 15:		Line 15:
	* [[Mikrotik 1: Install GNS3 Arch Linux]]		* [[Mikrotik 1: Install GNS3 Arch Linux]]
	* [[Mikrotik 2: Kantor Mini]]		* [[Mikrotik 2: Kantor Mini]]
			* [[Mikrotik 3: Bridge]]

	= Cisco =		= Cisco =

Mikrotik 2: Kantor Mini

SanzSkuy — Fri, 23 Oct 2026 07:38:21 GMT

Show changes

Mikrotik 2: Kantor Mini

SanzSkuy — Fri, 23 Oct 2026 03:16:24 GMT

Created page with "Fase 1 dari roadmap: membangun '''"kantor mini"''', yaitu satu router MikroTik sebagai gateway, beberapa PC yang mendapat IP otomatis, dan semuanya bisa internetan. Konfigurasi dilakukan lewat '''Winbox 4''', dengan padanan CLI di setiap langkah. __TOC__ == Tujuan == * Paham peran IP address, gateway, DHCP, DNS, dan NAT di jaringan kantor. * Paham beda '''switching''' (Layer 2) dan '''routing''' (Layer 3). * Bisa membaca kondisi router: siapa yang tersambung, dapat IP..."

New page

Fase 1 dari roadmap: membangun '''"kantor mini"''', yaitu satu router MikroTik sebagai gateway, beberapa PC yang mendapat IP otomatis, dan semuanya bisa internetan. Konfigurasi dilakukan lewat '''Winbox 4''', dengan padanan CLI di setiap langkah.

__TOC__

== Tujuan ==
* Paham peran IP address, gateway, DHCP, DNS, dan NAT di jaringan kantor.
* Paham beda '''switching''' (Layer 2) dan '''routing''' (Layer 3).
* Bisa membaca kondisi router: siapa yang tersambung, dapat IP apa, lewat mana.

== Topologi ==
<pre>
[NAT]
│
ether1 (WAN, DHCP client)
192.168.122.212/24
│
[MikroTikCHR-1]
ether2 / \ ether3
192.168.10.1/24 192.168.11.1/24
│ │
[Switch1] [Switch2]
/ | \ / \
PC1 PC2 PC3 PC4 PC5
</pre>

* '''NAT node''' dari [[Belajar MikroTik Part 1|Part 1]] tetap di <code>ether1</code>.
* '''Ethernet switch''' dan '''VPCS''' adalah perangkat bawaan GNS3 (kategori Switches dan End devices).

'''Pengingat''': setelah reboot host, jalankan ulang aturan <code>DOCKER-USER</code> dari Part 1, kalau tidak traffic lab tidak bisa keluar ke internet.

== Konsep dasar ==

=== IP address, subnet, dan alamat spesial ===
<code>/24</code> berarti 24 bit pertama adalah bagian '''network''', 8 bit terakhir bagian '''host'''.

<pre>
192.168.10. | 00000000 → .0 semua bit host 0 = alamat network
192.168.10. | 00000001 → .1 host pertama
192.168.10. | 11111110 → .254 host terakhir
192.168.10. | 11111111 → .255 semua bit host 1 = broadcast
</pre>

{| class="wikitable"
! Alamat !! Fungsi !! Bisa dipakai perangkat?
|-
| <code>192.168.10.0</code> || Network address (identitas subnet) || Tidak
|-
| <code>192.168.10.1</code> – <code>.254</code> || Alamat host (254 host) || Ya
|-
| <code>192.168.10.255</code> || Broadcast (ke semua di subnet) || Tidak
|}

'''Kapan menulis <code>.1/24</code> dan kapan <code>.0/24</code>?'''
* '''IP → Addresses''' menjawab "IP gua apa?" → alamat host, misalnya <code>192.168.10.1/24</code>. Kolom Network dihitung otomatis.
* '''Route, DHCP Network, firewall''' menjawab "network yang mana?" → alamat network, misalnya <code>192.168.10.0/24</code>.

'''Range IP privat''' (tidak dikenal di internet): <code>10.0.0.0/8</code>, <code>172.16.0.0/12</code> (172.16–172.31), <code>192.168.0.0/16</code>.

=== Gateway ===
Gateway adalah "pintu keluar" PC. Tujuan di luar subnet sendiri dikirim ke gateway.

'''Aturan emas''': gateway '''harus berada di subnet yang sama''' dengan PC. Biasanya berupa IP router di interface tersebut. Gateway di <code>.1</code> hanya kebiasaan, bukan aturan.

=== ARP ===
Di dalam satu segmen, frame Ethernet dikirim berdasarkan '''MAC address''', bukan IP. '''ARP''' menerjemahkan '''IP → MAC''' di dalam satu segmen.

# '''Request (broadcast)''': "Siapa yang punya <code>192.168.10.1</code>? Kasih tahu <code>192.168.10.100</code>."
# '''Reply (unicast)''': "Itu gua, MAC gua <code>0C:B3:C6:FB:00:01</code>."
# Hasilnya disimpan di '''tabel ARP''' (cache) dan kedaluwarsa setelah beberapa waktu.

'''Poin penting''': saat PC ping <code>8.8.8.8</code>, yang di-ARP adalah '''gateway''', bukan <code>8.8.8.8</code>. Di setiap lompatan, '''IP tujuan tetap sama''', tapi '''MAC tujuan berganti'''. Inilah beda Layer 2 (antar tetangga) dan Layer 3 (ujung ke ujung).

Switch juga punya tabel MAC, tapi isinya "MAC ini ada di port mana". Switch tidak peduli IP.

=== DHCP ===
PC yang baru tersambung belum punya IP, gateway, maupun DNS. DHCP membagikannya secara otomatis lewat proses '''DORA''':
# '''Discover''': PC broadcast "ada DHCP server?"
# '''Offer''': server menawarkan IP + gateway + DNS
# '''Request''': PC menerima tawaran
# '''Ack''': server mengonfirmasi dan mencatat lease

Di RouterOS, DHCP dipecah menjadi tiga bagian:
{| class="wikitable"
! Bagian !! Menjawab !! Alasan dipisah
|-
| '''Pool''' || IP mana yang boleh dibagikan? || Pool dipakai ulang oleh fitur lain (VPN, PPPoE, Hotspot)
|-
| '''Network''' || Info apa yang diberikan (gateway, DNS)? || Satu server bisa melayani banyak subnet (lewat relay)
|-
| '''Server''' || Siapa yang melayani, di interface mana? || Mengikat semuanya ke satu segmen
|}

* '''Lease time''' (default 30 menit): lama IP "disewakan". PC memperpanjang sebelum habis, dan IP kembali ke pool kalau PC pergi.
* '''Kenapa pool mulai dari <code>.100</code>''': <code>.2–.99</code> disisakan untuk perangkat ber-IP tetap (server, printer, access point, CCTV).

'''Di mana DHCP server diletakkan?''' Broadcast DHCP '''tidak menyeberang router''', jadi DHCP server harus berada di segmen yang sama dengan client, atau memakai '''DHCP relay''' yang meneruskan permintaan ke server di network lain.

{| class="wikitable"
! Skenario !! Lokasi DHCP server
|-
| Rumah || Modem/router ISP
|-
| Kantor kecil-menengah || Router MikroTik, satu server per segmen/VLAN
|-
| Kantor besar || Server khusus (Windows Server, Kea, dnsmasq) + DHCP relay di router
|}

Di lab ini CHR berperan ganda: '''client''' di sisi WAN (dapat IP dari dnsmasq libvirt) dan '''server''' di sisi LAN.

'''Satu segmen = satu DHCP server.''' Dua server di segmen yang sama membuat PC bisa mendapat konfigurasi yang salah. Kasus klasiknya '''rogue DHCP''': router Wi-Fi rumahan yang dicolok ke jaringan kantor.

=== DNS ===
PC diarahkan ke router (<code>192.168.10.1</code>) sebagai DNS server. Router meneruskan pertanyaan ke '''Dynamic Servers''' (<code>192.168.122.1</code>, didapat dari DHCP di WAN) dan menyimpan jawabannya di cache.

* '''Allow Remote Requests''' harus dicentang, karena defaultnya DNS router hanya untuk dirinya sendiri.
* Keuntungan lewat router: cache, kontrol terpusat (nama lokal, blokir domain), dan ganti DNS upstream cukup di satu tempat.

=== NAT (masquerade) ===
IP privat tidak bisa dibalas oleh internet. '''Masquerade''' mengganti '''IP sumber''' paket yang keluar lewat WAN menjadi IP router, lalu mencatat pemetaannya di '''connection tracking''' supaya balasan bisa dikembalikan ke PC yang benar.

* '''Chain <code>srcnat</code>''': yang diubah alamat sumber, diproses setelah keputusan routing.
* '''Out. Interface <code>ether1</code>''': hanya traffic ke arah WAN yang di-NAT.
* '''<code>masquerade</code> vs <code>src-nat</code>''': masquerade otomatis memakai IP yang sedang menempel di interface, cocok untuk IP WAN dinamis. <code>src-nat</code> dipakai kalau IP publik statis.

'''Kenapa NAT ada di menu Firewall?''' Firewall RouterOS adalah mesin pemroses paket dengan beberapa tabel (Filter, NAT, Mangle, Raw), persis seperti <code>iptables</code> di Linux:
<syntaxhighlight lang="bash">
# padanan rule masquerade di Linux
iptables -t nat -A POSTROUTING -o ether1 -j MASQUERADE
</syntaxhighlight>

'''Fakta menarik''': <code>virbr0</code> + dnsmasq dari libvirt (Part 1) melakukan hal yang sama persis dengan router di lab ini: IP gateway, DHCP, DNS, dan masquerade. Lab ini juga '''double NAT''': paket di-masquerade CHR, lalu di-NAT lagi oleh <code>virbr0</code>. Banyak kantor sungguhan juga begini (router kantor di belakang modem ISP).

=== Perjalanan satu ping ===
<pre>
PC1 (192.168.10.100) ping 8.8.8.8
│ "bukan tetangga → kirim ke gateway" (ARP gateway → dapat MAC router)
▼
CHR ether2 ── routing: 0.0.0.0/0 via 192.168.122.1 ── keluar ether1
│ srcnat masquerade: src 192.168.10.100 → 192.168.122.212
▼
virbr0 (host) ── masquerade lagi: src → IP host
▼
Internet ── balasan kembali, setiap NAT membalik alamatnya ── PC1 ✅
</pre>

== Konfigurasi LAN pertama ==

=== Konek Winbox ===
Isi '''Connect To''' dengan IP WAN CHR (contoh <code>192.168.122.212</code>), login <code>admin</code>. Konek lewat MAC di tab '''Neighbors''' belum tentu berhasil melalui <code>virbr0</code>, jadi pakai IP.

=== Langkah-langkah ===
{| class="wikitable"
! # !! Winbox !! Isian !! CLI
|-
| 1 || '''IP → Addresses''' → New || Address <code>192.168.10.1/24</code>, Interface <code>ether2</code>, Comment <code>LAN</code> || <code>/ip address add address=192.168.10.1/24 interface=ether2 comment=LAN</code>
|-
| 2 || '''IP → Pool''' → New || Name <code>pool-lan</code>, Addresses <code>192.168.10.100-192.168.10.200</code> || <code>/ip pool add name=pool-lan ranges=192.168.10.100-192.168.10.200</code>
|-
| 3 || '''IP → DHCP Server''' → tab '''Networks''' → New || Address <code>192.168.10.0/24</code>, Gateway <code>192.168.10.1</code>, DNS <code>192.168.10.1</code> || <code>/ip dhcp-server network add address=192.168.10.0/24 gateway=192.168.10.1 dns-server=192.168.10.1</code>
|-
| 4 || '''IP → DHCP Server''' → tab '''DHCP''' → New || Name <code>dhcp-lan</code>, Interface <code>ether2</code>, Address Pool <code>pool-lan</code> || <code>/ip dhcp-server add name=dhcp-lan interface=ether2 address-pool=pool-lan disabled=no</code>
|-
| 5 || '''IP → DNS''' || Centang '''Allow Remote Requests''' || <code>/ip dns set allow-remote-requests=yes</code>
|-
| 6 || '''IP → Firewall''' → tab '''NAT''' → New || General: Chain <code>srcnat</code>, Out. Interface <code>ether1</code>; Action: <code>masquerade</code> || <code>/ip firewall nat add chain=srcnat out-interface=ether1 action=masquerade comment="NAT ke internet"</code>
|}

'''Catatan langkah 1''': entri <code>192.168.122.x</code> di <code>ether1</code> dengan flag '''D''' (Dynamic) adalah IP WAN dari DHCP client. Jangan dihapus. Router memang punya '''satu IP di setiap network''' yang ia sambungkan, dan network di interface berbeda '''tidak boleh tumpang tindih'''.

'''Peringatan keamanan''': CHR ini belum punya firewall filter, dan <code>allow-remote-requests=yes</code> membuat DNS router bisa ditanya dari sisi WAN. Aman di lab, tapi di router sungguhan harus diblok (Fase 3).

=== Trik Winbox ===
* Tombol '''DHCP Setup''' mengerjakan langkah 2–4 sekaligus. Pakai setelah paham cara manualnya.
* '''Terminal''' tersedia di dalam Winbox. Jalankan <code>/ip firewall nat export</code> untuk melihat padanan CLI dari apa yang diklik di GUI.
* '''Safe Mode''': kalau koneksi putus karena salah setting, perubahan otomatis dibatalkan. Biasakan menyalakannya.

== Verifikasi ==
Di VPCS:
<syntaxhighlight lang="text">
ip dhcp
show ip
ping 192.168.10.1
ping 8.8.8.8
ping google.com
trace 8.8.8.8
show arp
</syntaxhighlight>
<code>trace</code> menampilkan hop lewat <code>192.168.10.1</code> lalu <code>192.168.122.1</code>, jadi double NAT terlihat langsung.

=== Melihat perangkat yang tersambung ===
{| class="wikitable"
! Menu !! Menampilkan !! Keterbatasan
|-
| '''IP → DHCP Server → Leases''' || IP, MAC, hostname, status (<code>bound</code>) || Hanya perangkat yang memakai DHCP
|-
| '''IP → ARP''' || Perangkat yang baru-baru ini berkomunikasi, termasuk IP statis || Perangkat yang diam bisa tidak muncul
|-
| '''Bridge → Hosts''' || MAC per port fisik || Hanya untuk port anggota bridge
|-
| '''IP → Neighbors''' || Perangkat jaringan (MNDP/LLDP/CDP) || PC biasa umumnya tidak muncul
|-
| '''Tools → IP Scan''' || Scan aktif satu range || Harus dijalankan manual
|}

Kombinasi di kantor: '''Leases''' (perangkat siapa), '''ARP''' (siapa yang aktif), '''Bridge Hosts''' (colok di port mana).

Melihat paket ARP secara langsung: klik kanan kabel di GNS3 → '''Start capture''', lalu di PC jalankan <code>clear arp</code> dan <code>ping 192.168.10.1</code>.

== LAN kedua dan routing antar subnet ==

=== Konfigurasi ===
{| class="wikitable"
! Bagian !! Isian
|-
| IP → Addresses || <code>192.168.11.1/24</code> di <code>ether3</code> (beri comment, misalnya <code>LAN2</code>)
|-
| IP → Pool || <code>pool-lan2</code>: <code>192.168.11.100-192.168.11.200</code>
|-
| DHCP → Networks || <code>192.168.11.0/24</code>, gateway & DNS <code>192.168.11.1</code>
|-
| DHCP → DHCP || Server baru di <code>ether3</code> dengan <code>pool-lan2</code>
|-
| NAT || '''Tidak perlu diubah''': rule mencocokkan <code>out-interface=ether1</code>, jadi semua subnet yang keluar ke WAN otomatis di-masquerade
|}

=== Kenapa PC1 bisa ping PC4? ===
# PC1 melihat <code>192.168.11.x</code> bukan tetangga → kirim ke gateway <code>192.168.10.1</code>.
# Router sudah mengenal kedua network sebagai '''connected route''' (lihat '''IP → Routes'''):
<pre>
DAC 192.168.10.0/24 → ether2
DAC 192.168.11.0/24 → ether3
DAd 0.0.0.0/0 → 192.168.122.1 (dari DHCP client)
</pre>
:<code>D</code> = dynamic, <code>A</code> = active, <code>C</code> = connected.
# Router meng-ARP PC4 di sisi <code>ether3</code> lalu meneruskan paket.
# '''Tidak kena NAT''', karena traffic keluar lewat <code>ether3</code>, bukan <code>ether1</code>. PC4 melihat IP asli PC1.
# '''Tidak ada yang memblokir''', karena belum ada firewall filter.

=== Switching vs routing ===
{| class="wikitable"
! Tes !! Hasil <code>trace</code> !! Yang bekerja
|-
| PC1 → PC2 (satu switch) || Langsung sampai || '''Switch''' (Layer 2). Router tidak terlibat.
|-
| PC1 → PC4 (beda subnet) || Satu hop lewat <code>192.168.10.1</code> || '''Router''' (Layer 3)
|}

'''Implikasi di kantor''': memisahkan subnet '''tidak sama dengan isolasi'''. Secara default router menyambungkan semua subnet. Untuk memisahkan misalnya Wi-Fi tamu atau CCTV dari jaringan karyawan, dibutuhkan '''firewall filter di chain <code>forward</code>''' (Fase 3).

== Kesalahan umum ==
{| class="wikitable"
! Gejala !! Penyebab !! Solusi
|-
| PC dapat IP tapi tidak bisa internetan setelah ganti subnet || Gateway/DNS di DHCP Network masih memakai alamat subnet lama. PC tidak bisa meng-ARP gateway yang bukan tetangganya. || Gateway & DNS = IP router di subnet baru
|-
| Router punya dua IP di satu interface setelah ganti subnet || Menambah entri baru tanpa menghapus yang lama || Edit entri yang ada (double-click)
|-
| PC masih memakai IP lama || Lease lama belum diperbarui || Jalankan <code>ip dhcp</code> lagi di VPCS
|-
| Satu segmen mendadak dapat gateway aneh || Rogue DHCP (dua DHCP server di satu segmen) || Cari dan cabut DHCP server liar
|-
| Router bingung meneruskan paket || Dua interface memakai subnet yang tumpang tindih || Pakai subnet berbeda di setiap interface
|-
| <code>failure: dhcp-client on that interface already exists</code> || Appliance CHR sudah membawa DHCP client di <code>ether1</code> || Normal, abaikan
|-
| Parameter ditolak || <code>disable=no</code> || Yang benar <code>disabled=no</code>
|}

== Latihan ==
# '''Pindah subnet''': ubah LAN pertama menjadi <code>10.10.10.0/24</code> (gateway <code>.1</code>, pool <code>.50–.99</code>). Ada empat isian yang harus ikut berubah. Apakah rule NAT perlu diubah?
# '''Static lease''': buat PC1 selalu mendapat <code>192.168.10.10</code>, sementara PC lain tetap acak dari pool.
#* Bolehkah static lease memakai IP di luar pool? Kenapa justru bisa jadi ide bagus?
#* Bagaimana membuat PC1 memakai IP barunya?
#* Apa yang bisa terjadi kalau static lease memakai IP di dalam pool yang sedang dipakai PC lain?
# '''Sengaja dirusak''': disable rule NAT. Tebak dulu: <code>/ping 8.8.8.8</code> dari router masih jalan? Dari PC1? Tes, lalu jelaskan kenapa hasilnya berbeda.

== Selanjutnya ==
Part 3: bridge dan VLAN, yaitu cara satu router melayani banyak segmen lewat satu kabel.

== Referensi ==
* [https://help.mikrotik.com/docs/spaces/ROS/pages/24805500/DHCP MikroTik Docs: DHCP]
* [https://help.mikrotik.com/docs/spaces/ROS/pages/37748767/DNS MikroTik Docs: DNS]
* [https://help.mikrotik.com/docs/spaces/ROS/pages/3211299/NAT MikroTik Docs: NAT]
* [https://help.mikrotik.com/docs/spaces/ROS/pages/328088/IP+Addressing MikroTik Docs: IP Addressing]

[[Category:Networking]]

Networking

SanzSkuy — Fri, 23 Oct 2026 03:16:10 GMT

← Older revision		Revision as of 03:16, 23 October 2026
Line 14:		Line 14:
	= Mikrotik =		= Mikrotik =
	* [[Mikrotik 1: Install GNS3 Arch Linux]]		* [[Mikrotik 1: Install GNS3 Arch Linux]]
			* [[Mikrotik 2: Kantor Mini]]

	= Cisco =		= Cisco =

Mikrotik 1: Install GNS3 Arch Linux

SanzSkuy — Thu, 22 Oct 2026 09:32:58 GMT

Created page with "Halaman ini mencatat setup lab MikroTik virtual pakai '''GNS3''' di '''Arch Linux''', dari install sampai router pertama bisa nge-ping internet. Semua error yang muncul selama setup juga dicatat, lengkap dengan penyebab dan solusinya. __TOC__ == Tujuan == * Punya lab MikroTik tanpa beli hardware. * Router virtual bisa diakses dari host (WebFig) dan bisa keluar ke internet. * Paham istilah dasar: CHR, appliance, template, libvirt, <code>virbr0</code>. == Konsep dan ist..."

New page

Halaman ini mencatat setup lab MikroTik virtual pakai '''GNS3''' di '''Arch Linux''', dari install sampai router pertama bisa nge-ping internet. Semua error yang muncul selama setup juga dicatat, lengkap dengan penyebab dan solusinya.

__TOC__

== Tujuan ==
* Punya lab MikroTik tanpa beli hardware.
* Router virtual bisa diakses dari host (WebFig) dan bisa keluar ke internet.
* Paham istilah dasar: CHR, appliance, template, libvirt, <code>virbr0</code>.

== Konsep dan istilah ==

=== RouterOS dan CHR ===
'''RouterOS''' adalah sistem operasi router MikroTik. '''CHR (Cloud Hosted Router)''' adalah RouterOS versi x86 yang dijalankan sebagai VM.

* Fiturnya sama dengan RouterOS di router fisik: bridge, NAT, firewall, VLAN, OSPF, BGP, VPN.
* Ringan: cukup RAM beberapa ratus MB per router, jadi bisa jalan banyak router sekaligus.
* Lisensi gratis dibatasi upload '''1 Mbps per interface''', tapi semua fitur tetap jalan. Cukup buat belajar.

=== Tools konfigurasi ===
{| class="wikitable"
! Tool !! Keterangan
|-
| '''WebFig''' || Antarmuka web bawaan RouterOS. Tanpa install, cukup buka IP router di browser. Hanya bisa konek lewat IP.
|-
| '''Winbox 4''' || Aplikasi native (Windows, macOS, Linux). Bisa konek lewat '''MAC address''', berguna kalau router belum punya IP.
|-
| '''CLI''' || Lewat console/telnet/SSH. Paling lengkap, dan yang dipakai di halaman ini.
|}

=== GNS3: appliance vs template ===
* '''Template''': perangkat yang siap di-drag ke canvas.
* '''Appliance''': file resep (<code>.gns3a</code>) yang otomatis membuat template, lengkap dengan setting RAM, adapter, console, serta nama file dan checksum image yang dibutuhkan.
* GNS3 '''tidak membawa image''' vendor. Image CHR tetap diambil dari mikrotik.com.

Di katalog appliance ada banyak model MikroTik (CCR, RB, CRS, dll). Buat belajar, cukup pakai '''MikroTik CHR'''.

=== libvirt dan virbr0 ===
* '''libvirt''': lapisan manajemen virtualisasi di Linux (daemon <code>libvirtd</code>, tool <code>virsh</code>). Mengatur VM, storage, dan network virtual.
* '''virbr0''' (''virtual bridge''): switch virtual di host yang dibuat oleh network <code>default</code> libvirt. Fungsinya:
** gateway lab (<code>192.168.122.1</code>),
** DHCP via dnsmasq (range <code>192.168.122.x</code>),
** NAT supaya lab bisa keluar lewat internet host.

Node '''NAT''' di GNS3 memakai <code>virbr0</code> ini.

<pre>
CHR (GNS3) ── NAT node ── virbr0 (host) ── internet
│
Browser/Winbox di host
</pre>

'''Efek ke host''': koneksi internet asli tidak berubah. libvirt hanya menambah aturan NAT untuk <code>192.168.122.0/24</code>, menyalakan <code>ip_forward</code>, dan menjalankan dnsmasq khusus <code>virbr0</code>. Pastikan subnet ini tidak bentrok dengan jaringan asli.

== Instalasi ==

=== 1. Upgrade sistem ===
<syntaxhighlight lang="bash">
sudo pacman -Syu
</syntaxhighlight>
Wajib, untuk menghindari partial upgrade (lihat [[#Masalah 1: partial upgrade QEMU|Masalah 1]]).

=== 2. Dependensi ===
<syntaxhighlight lang="bash">
paru -S --needed qemu docker vpcs dynamips libvirt ubridge inetutils
</syntaxhighlight>
* <code>--needed</code> melewati paket yang sudah terinstall.
* Kalau <code>qemu-full</code> sudah ada, <code>qemu</code> tidak perlu dipasang lagi.
* <code>vpcs</code>, <code>dynamips</code>, <code>ubridge</code> dari AUR.
* <code>inetutils</code> menyediakan <code>telnet</code> untuk console.

=== 3. GNS3 ===
<syntaxhighlight lang="bash">
paru -S gns3-server gns3-gui
</syntaxhighlight>

=== 4. Group user dan service ===
<syntaxhighlight lang="bash">
for g in ubridge libvirt kvm docker wireshark; do
getent group $g >/dev/null && sudo gpasswd -a $USER $g || echo "group $g belum ada"
done

sudo systemctl enable --now libvirtd docker
reboot
</syntaxhighlight>
Group <code>wireshark</code> baru ada setelah <code>sudo pacman -S wireshark-qt</code>. Setelah reboot, cek dengan <code>groups</code>.

=== 5. Network default libvirt ===
<syntaxhighlight lang="bash">
sudo virsh net-list --all
# kalau "default" belum ada:
sudo virsh net-define /usr/share/libvirt/networks/default.xml
sudo virsh net-start default
sudo virsh net-autostart default
ip a show virbr0
</syntaxhighlight>
Pakai <code>sudo</code> supaya <code>virsh</code> konek ke koneksi ''system'', bukan ''session''.

=== 6. Console terminal ===
GNS3 default memakai <code>xterm</code>. Pilih salah satu:
* <code>sudo pacman -S xterm</code>, atau
* ganti di '''Edit → Preferences → General → Console applications''', contoh:
<syntaxhighlight lang="text">
kitty --title "%d" telnet %h %p
alacritty -t "%d" -e telnet %h %p
konsole -p tabtitle=%d -e telnet %h %p
</syntaxhighlight>
(<code>%h</code> = host, <code>%p</code> = port, <code>%d</code> = nama node)

=== 7. Template MikroTik CHR ===
# Jalankan <code>gns3</code>, pilih '''Run appliances on my local computer'''.
# '''File → New template → Install an appliance from the GNS3 server'''.
# Cari '''MikroTik CHR''', klik '''Install'''.
# Lihat '''nama file dan versi''' yang diminta wizard (contoh: <code>chr-7.22.1.img</code>).
# Download '''Raw disk image''' versi yang sama dari mikrotik.com, lalu unzip:
<syntaxhighlight lang="bash">
unzip chr-7.22.1.img.zip
md5sum chr-7.22.1.img # harus sama dengan checksum di wizard
</syntaxhighlight>
# '''Import''' file <code>.img</code> (bukan <code>.zip</code>), lalu Finish.

Template muncul di panel '''Routers'''.

== Hello World ==

=== Router pertama ===
# Drag '''MikroTik CHR''' ke canvas, klik kanan → '''Start'''.
# Double-click node untuk membuka console.
# Login <code>admin</code>, password kosong. Jawab <code>n</code> untuk lisensi, lalu set password baru.

<syntaxhighlight lang="text">
/system identity set name=hello-world
/system resource print
/interface print
</syntaxhighlight>
Prompt berubah jadi <code>[admin@hello-world] ></code>. Hello world selesai.

=== Sambung ke internet ===
# Drag node '''NAT''' ke canvas, sambungkan ke <code>ether1</code> CHR.
# Di console CHR:
<syntaxhighlight lang="text">
/ip dhcp-client print
/ip address print
/ip route print
/ping 192.168.122.1
/ping 8.8.8.8
</syntaxhighlight>
Appliance CHR sudah membawa DHCP client di <code>ether1</code>, jadi menambah lagi akan memunculkan <code>failure: dhcp-client on that interface already exists</code>. Itu normal. (Kalau perlu menambah manual, parameternya <code>disabled=no</code>, bukan <code>disable=no</code>.)

=== Buka WebFig ===
<syntaxhighlight lang="bash">
ping -c 3 192.168.122.212 # ganti dengan IP CHR
</syntaxhighlight>
Lalu buka <code>http://192.168.122.212</code> di browser host. Kalau tidak terbuka, cek <code>/ip service print</code> dan pastikan <code>www</code> tidak disabled.

== Masalah yang ditemui ==

=== Masalah 1: partial upgrade QEMU ===
'''Gejala'''
<pre>
error: failed to prepare transaction (could not satisfy dependencies)
:: installing qemu-common (11.1.2-1) breaks dependency 'qemu-common=11.1.1-1' required by qemu-audio-alsa
...
</pre>
'''Penyebab''': repo sudah punya QEMU 11.1.2, sistem masih 11.1.1. Menginstall <code>qemu</code> menarik <code>qemu-common</code> baru, sedangkan puluhan paket QEMU lain masih mengunci versi lama. Arch tidak mendukung partial upgrade.

'''Solusi''': <code>sudo pacman -Syu</code>, lalu ulangi install dependensi tanpa <code>qemu</code> (sudah ada lewat <code>qemu-full</code>).

=== Masalah 2: gns3server crash, <code>No module named 'langchain'</code> ===
'''Gejala'''
<pre>
CRITICAL gns3server.server:331 Critical error while running the server: No module named 'langchain'
File ".../gns3server/agent/gns3_copilot/gns3_client/gns3_project_info.py", line 39, in <module>
from langchain.tools import BaseTool
ModuleNotFoundError: No module named 'langchain'
</pre>
'''Penyebab''': GNS3 versi baru (3.x alpha di AUR) meng-import modul fitur AI copilot/MCP tanpa pengaman, padahal dependensinya opsional dan tidak ikut terinstall. Pola serupa dilaporkan untuk modul <code>mcp</code> di [https://github.com/GNS3/gns3-server/issues/2794 GNS3 issue #2794].

'''Solusi''':
* Install dependensi yang kurang (<code>python-langchain</code>, <code>python-langchain-core</code>, <code>python-mcp</code>, dari repo atau AUR), lalu jalankan <code>gns3server</code> dan ulangi sampai tidak ada <code>ModuleNotFoundError</code> lagi.
* Alternatif: bungkus import tersebut dengan <code>try/except ModuleNotFoundError</code> (hilang saat update), atau pakai versi stabil.

=== Masalah 3: import image CHR gagal ===
'''Gejala'''
<pre>
Cannot install MikroTik CHR version 7.22.1: File chr-7.22.1.img with checksum a67290634f489071eae2fd99dcadba86 not found
The file is compressed with 'zip', it must be uncompressed first
Could not upload image chr-7.22.1.img: File '/home/haidhi/GNS3/images/QEMU/chr-7.22.1.img' already exists
</pre>
'''Penyebab''':
* Yang di-import file <code>.zip</code>, bukan <code>.img</code> hasil unzip.
* Sudah ada file dengan nama sama dari percobaan sebelumnya, sehingga GNS3 menolak menimpa.
* Wizard appliance mencocokkan '''nama file dan checksum''' secara persis.

'''Solusi'''
<syntaxhighlight lang="bash">
file ~/GNS3/images/QEMU/chr-7.22.1.img
md5sum ~/GNS3/images/QEMU/chr-7.22.1.img
# kalau salah:
rm ~/GNS3/images/QEMU/chr-7.22.1.img*
unzip chr-7.22.1.img.zip && md5sum chr-7.22.1.img
</syntaxhighlight>
Lalu ulangi wizard dan import file <code>.img</code>. Kalau versi yang diminta sudah tidak tersedia, buat template QEMU manual (lihat [[#Catatan: template manual|catatan]]).

=== Masalah 4: console tidak terbuka, <code>xterm</code> tidak ada ===
'''Gejala'''
<pre>
Could not start Telnet console with command 'xterm -T "MikroTikCHR-1" -e "telnet localhost 5000"': [Errno 2] No such file or directory: 'xterm'
</pre>
'''Penyebab''': GNS3 default memakai <code>xterm</code>, yang tidak terinstall di Arch.

'''Solusi''': install <code>xterm</code> atau ganti console command (lihat [[#6. Console terminal|langkah 6]]).

=== Masalah 5: <code>NAT interface virbr0 is missing</code> ===
'''Gejala'''
<pre>
Error while creating node from template: NAT interface virbr0 is missing, please install libvirt
</pre>
'''Penyebab''': <code>libvirtd</code> sudah jalan, tapi network <code>default</code> belum dinyalakan, sehingga <code>virbr0</code> belum ada. Daemon hidup ≠ network hidup.

'''Solusi''': [[#5. Network default libvirt|langkah 5]]. Kalau <code>net-start</code> gagal, cek apakah <code>dnsmasq</code> dan <code>iptables-nft</code>/nftables sudah terpasang.

Catatan: baris log <code>Libvirt doesn't support VirtualBox API version ...</code> tidak berbahaya.

'''Kenapa <code>virbr0</code> statusnya DOWN?'''
<pre>
virbr0: <NO-CARRIER,BROADCAST,MULTICAST,UP> ... state DOWN
</pre>
<code>NO-CARRIER</code> berarti belum ada perangkat yang tersambung ke bridge. Begitu node NAT di GNS3 aktif, statusnya berubah jadi UP. Normal.

=== Masalah 6: CHR dapat IP, tapi ping internet timeout ===
'''Gejala'''
<pre>
0 D 192.168.122.212/24 192.168.122.0 ether1 main
/ping 8.8.8.8
sent=9 received=0 packet-loss=100%
</pre>
DHCP jalan (IP didapat), tapi traffic keluar tidak tembus.

'''Penyebab''': Docker mengatur policy chain <code>FORWARD</code> menjadi <code>DROP</code>, sehingga traffic dari <code>virbr0</code> dibuang sebelum di-NAT keluar.

'''Diagnosis'''
<syntaxhighlight lang="bash">
sysctl net.ipv4.ip_forward # harus 1
sudo iptables -S FORWARD | head # cari: -P FORWARD DROP
</syntaxhighlight>

'''Solusi''': izinkan traffic <code>virbr0</code> di chain <code>DOCKER-USER</code> (chain yang memang disediakan Docker untuk aturan user):
<syntaxhighlight lang="bash">
sudo iptables -I DOCKER-USER -i virbr0 -j ACCEPT
sudo iptables -I DOCKER-USER -o virbr0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
</syntaxhighlight>
* Aturan pertama: izinkan traffic yang masuk dari lab.
* Aturan kedua: izinkan balasan yang kembali ke lab.

Aturan ini '''hilang setelah reboot''' atau restart Docker. Jalankan ulang sebelum nge-lab, atau buat permanen nanti.

== Catatan: template manual ==
Kalau tidak memakai appliance:
<syntaxhighlight lang="bash">
qemu-img convert -f raw -O qcow2 chr-*.img chr.qcow2
</syntaxhighlight>
'''Edit → Preferences → QEMU → QEMU VMs → New''':
* Binary: <code>qemu-system-x86_64</code>, RAM: 256 MB, disk: <code>chr.qcow2</code>
* Console: <code>telnet</code>
* Adapter: 4+, tipe <code>virtio-net-pci</code> (ganti <code>e1000</code> kalau interface tidak muncul)
* Advanced: centang '''Use as a linked base VM'''

== Ringkasan ==
{| class="wikitable"
! Masalah !! Penyebab !! Solusi
|-
| Dependency QEMU rusak || Partial upgrade || <code>pacman -Syu</code>
|-
| <code>No module named 'langchain'</code> || Dependensi opsional GNS3 alpha tidak terinstall || Install modul yang kurang
|-
| Image CHR tidak ditemukan || Import <code>.zip</code> / file lama tertinggal / checksum beda || Hapus file lama, unzip, import <code>.img</code>
|-
| <code>xterm</code> tidak ada || Console default GNS3 || Install xterm / ganti console command
|-
| <code>virbr0 is missing</code> || Network <code>default</code> belum start || <code>virsh net-start default</code>
|-
| Ping internet timeout || Docker <code>FORWARD DROP</code> || Aturan <code>DOCKER-USER</code> untuk <code>virbr0</code>
|}

Networking

SanzSkuy — Thu, 22 Oct 2026 09:32:46 GMT

← Older revision		Revision as of 09:32, 22 October 2026
Line 11:		Line 11:
	* [[Media Koneksi Ethernet (Layer 1)]]		* [[Media Koneksi Ethernet (Layer 1)]]
	* [[Perangkat Jaringan: Hub, Switch, dan Router]]		* [[Perangkat Jaringan: Hub, Switch, dan Router]]

			= Mikrotik =
			* [[Mikrotik 1: Install GNS3 Arch Linux]]

	= Cisco =		= Cisco =
Line 16:		Line 19:
	* [[Perintah Dasar Cisco IOS]]		* [[Perintah Dasar Cisco IOS]]

	= Lab =		== Cisco Lab ==
	* [[Lab 0.1 - Basic Device Hardening]]		* [[Lab 0.1 - Basic Device Hardening]]

CCNA

SanzSkuy — Thu, 22 Oct 2026 09:31:24 GMT

SanzSkuy moved page CCNA to Networking without leaving a redirect

New page

= Networking =
* [[Model OSI]]
* [[Lapisan Transport (TCP dan UDP)]]
* [[Kelas Alamat IP]]
* [[Subnetting 1]]
* [[VLSM]]
* [[Magic Number Method & Subnetting Jaringan Besar]]
* [[Subnetting: Contoh Oktet ke-3 vs ke-4]]
* [[Private IP Address (RFC 1918)]]
* [[Ethernet & Layer 2 (Data Link)]]
* [[Media Koneksi Ethernet (Layer 1)]]
* [[Perangkat Jaringan: Hub, Switch, dan Router]]

= Cisco =
* [[Cisco IOS]]
* [[Perintah Dasar Cisco IOS]]

= Lab =
* [[Lab 0.1 - Basic Device Hardening]]

Deploy app bare-metal

SanzSkuy — Tue, 20 Oct 2026 06:42:08 GMT

Created page with "Catatan tentang cara deploy aplikasi (Python FastAPI, Rust Actix, Node frontend) langsung di server Ubuntu (contoh: <code>marshall-3</code>) tanpa Docker, memakai '''uv''', '''systemd''', dan '''Ansible'''. Fokus utama catatan ini adalah sisi '''sysadmin''': layout direktori, model user dan permission, hardening service, dan otomasi. == Gambaran besar == Docker memberi tiga hal: '''isolasi''', '''reproducibility''', dan '''packaging'''. Di bare metal, ketiganya tetap b..."

New page

Catatan tentang cara deploy aplikasi (Python FastAPI, Rust Actix, Node frontend) langsung di server Ubuntu (contoh: <code>marshall-3</code>) tanpa Docker, memakai '''uv''', '''systemd''', dan '''Ansible'''. Fokus utama catatan ini adalah sisi '''sysadmin''': layout direktori, model user dan permission, hardening service, dan otomasi.

== Gambaran besar ==

Docker memberi tiga hal: '''isolasi''', '''reproducibility''', dan '''packaging'''. Di bare metal, ketiganya tetap bisa didapat dengan alat bawaan Linux:

{| class="wikitable"
! Kebutuhan !! Di Docker !! Di bare metal
|-
| Isolasi proses || namespace, cgroup || user terpisah per app + hardening systemd (juga pakai namespace & cgroup)
|-
| Dependency terkunci || image || lock file (<code>uv.lock</code>, <code>Cargo.lock</code>, <code>package-lock.json</code>) + venv per release
|-
| Restart otomatis || <code>restart: unless-stopped</code> || <code>Restart=on-failure</code> di unit systemd
|-
| Log || <code>docker logs</code> || <code>journalctl -u nama-app</code>
|-
| Rollback || tag image lama || folder release lama + symlink
|-
| Deploy berulang || compose / CI || Ansible
|}

'''Kapan bare metal masuk akal:''' sedikit server, workload GPU, tim kecil, atau binary tunggal (Rust/Go).
'''Kapan Docker lebih unggul:''' banyak server, scaling horizontal, atau dependency sistem yang bentrok antar app (misalnya versi CUDA berbeda per app, karena di bare metal semua app berbagi satu driver NVIDIA).

== Layout direktori (FHS) ==

Setiap app memakai lokasi standar ''Filesystem Hierarchy Standard'', supaya jelas mana kode, mana config, mana data:

{| class="wikitable"
! Path !! Isi !! Kenapa di sini
|-
| <code>/opt/<app>/releases/<versi>/</code> || kode + <code>.venv</code> / <code>target</code> / <code>dist</code> || <code>/opt</code> untuk software tambahan yang bukan dari paket OS
|-
| <code>/opt/<app>/current</code> || symlink ke release aktif || service selalu menunjuk ke sini; ganti versi = ganti symlink
|-
| <code>/etc/<app>/<app>.env</code> || environment variable & secret || <code>/etc</code> untuk konfigurasi milik host, terpisah dari kode
|-
| <code>/var/lib/<app>/</code> || data, cache model, upload, cache uv/cargo/npm || <code>/var/lib</code> untuk state yang ditulis aplikasi saat jalan
|-
| <code>/opt/uv/python/</code> || interpreter Python bersama || dipakai semua app, bukan milik satu user
|-
| <code>/etc/systemd/system/<app>.service</code> || unit service || lokasi unit buatan admin (bukan dari paket)
|}

Pemisahan ini penting untuk permission: '''kode''' boleh read-only saat runtime, '''config''' hanya root yang boleh ubah, dan '''hanya folder data''' yang boleh ditulis aplikasi.

== Model user & permission ==

=== Satu app, satu system user ===

<syntaxhighlight lang="bash">
sudo useradd --system --home-dir /var/lib/transcribe-api \
--shell /usr/sbin/nologin transcribe
</syntaxhighlight>

* <code>--system</code>: UID diambil dari rentang system (di Ubuntu di bawah 1000), tidak muncul di layar login, dan tidak dibuatkan mailbox atau aging password.
* <code>--shell /usr/sbin/nologin</code>: user tidak bisa login interaktif. Kalau proses app dibobol, penyerang tidak otomatis dapat shell login.
* '''Kenapa per app?''' Kalau satu app bocor, app lain dan file-nya tidak ikut terbaca. Ini prinsip ''least privilege''.

Perintah berguna:
<syntaxhighlight lang="bash">
id transcribe # UID, GID, dan group tambahan
getent passwd transcribe # home & shell
getent group | grep transcribe
sudo -u transcribe -H bash -c 'whoami; echo $HOME' # tes sebagai user app
</syntaxhighlight>

'''Salah nama user?''' Rename tanpa bikin ulang:
<syntaxhighlight lang="bash">
sudo usermod -l transcribe -d /var/lib/transcribe-api appuser # ganti login & home
sudo groupmod -n transcribe appuser # ganti nama group
</syntaxhighlight>
Karena UID/GID tidak berubah, ownership file otomatis ikut. <code>usermod -d</code> akan gagal kalau user sedang dipakai proses yang jalan, jadi stop service-nya dulu.

Error <code>chown: invalid group: 'root:appuser'</code> artinya group tersebut sudah tidak ada (sudah di-rename atau dihapus). Cek dengan <code>getent group</code>.

=== Tabel ownership & mode ===

{| class="wikitable"
! Path !! Owner:Group !! Mode !! Artinya
|-
| <code>/opt/<app></code> || root:root || <code>0755</code> || hanya root yang bisa membuat/mengganti symlink <code>current</code>
|-
| <code>/opt/<app>/releases</code> || app:app || <code>0755</code> || user app meng-clone dan build release di sini
|-
| <code>/etc/<app></code> || root:app || <code>0750</code> || app boleh masuk & baca, user lain tidak bisa melihat isinya
|-
| <code>/etc/<app>/<app>.env</code> || root:app || <code>0640</code> || root tulis, app baca, lainnya tidak bisa apa-apa
|-
| <code>/var/lib/<app></code> || app:app || <code>0750</code> || satu-satunya tempat app boleh menulis
|-
| <code>/var/lib/<app>/.ssh</code> || app:app || <code>0700</code> || deploy key; SSH menolak key yang permission-nya terlalu terbuka
|-
| <code>/opt/uv/python</code> || root:root || <code>a+rX</code> || semua user boleh baca & eksekusi interpreter, tidak boleh ubah
|}

=== Membaca mode oktal ===

Tiap digit = '''owner''', '''group''', '''others'''. Nilainya jumlah dari <code>r=4</code>, <code>w=2</code>, <code>x=1</code>.

{| class="wikitable"
! Mode !! Owner !! Group !! Others !! Dipakai untuk
|-
| <code>0755</code> || rwx || r-x || r-x || folder publik, binary
|-
| <code>0750</code> || rwx || r-x || --- || folder privat yang boleh dibaca group
|-
| <code>0700</code> || rwx || --- || --- || folder sangat privat (<code>.ssh</code>)
|-
| <code>0640</code> || rw- || r-- || --- || file secret yang dibaca group
|-
| <code>0600</code> || rw- || --- || --- || private key
|}

Untuk '''folder''', bit <code>x</code> artinya "boleh masuk (traverse)", bukan "eksekusi". Tanpa <code>x</code> di folder induk, file di dalamnya tidak bisa diakses walaupun file-nya sendiri <code>r</code>.

<code>chmod -R a+rX</code> (huruf X besar) memberi <code>x</code> hanya ke folder dan file yang sudah executable. Ini cara aman membuka akses baca satu pohon direktori tanpa membuat semua file teks jadi executable.

=== Kenapa env file <code>root:app 0640</code>? ===

* App perlu '''membaca''' secret (DATABASE_URL, SECRET_KEY), tapi tidak perlu '''mengubahnya'''.
* Kalau app dibobol, penyerang tidak bisa mengganti config agar persisten.
* User lain di server tidak bisa membaca secret sama sekali.
* Jangan simpan secret di <code>.env</code> dalam folder kode: gampang ikut ter-commit, dan ikut terbaca siapa pun yang bisa membaca kode.

=== Toolchain bersama & masalah home directory ===

uv bisa meng-install Python sendiri. Defaultnya ke <code>~/.local/share/uv/python</code>. Masalahnya:

* venv '''hanya symlink''' ke interpreter. Kalau interpreter ada di home user A, user B tidak bisa memakainya.
* Unit systemd dengan <code>ProtectHome=true</code> membuat <code>/home</code>, <code>/root</code>, dan <code>/run/user</code> tidak terlihat. Interpreter di home = service gagal start.

Solusinya taruh di lokasi bersama dan buka akses baca:
<syntaxhighlight lang="bash">
export UV_PYTHON_INSTALL_DIR=/opt/uv/python
sudo -E uv python install 3.13
sudo chmod -R a+rX /opt/uv/python
</syntaxhighlight>

Pola yang sama untuk Rust: <code>RUSTUP_HOME=/opt/rust/rustup</code>, <code>CARGO_HOME=/opt/rust/cargo</code>, lalu <code>a+rX</code>. Cache per app (registry cargo, cache uv, cache npm) ditaruh di <code>/var/lib/<app></code> yang memang writable.

=== Akses GPU ===

Device NVIDIA ada di <code>/dev/nvidia*</code>:
<syntaxhighlight lang="bash">
ls -l /dev/nvidia*
</syntaxhighlight>
Kalau mode-nya <code>crw-rw-rw-</code>, semua user bisa memakai GPU. Kalau hanya group <code>video</code>/<code>render</code>, tambahkan user app ke group tersebut (<code>usermod -aG video transcribe</code>) dan tulis <code>SupplementaryGroups=video</code> di unit. Opsi <code>-a</code> wajib; tanpa itu, group tambahan lain akan terhapus.

=== sudo yang sempit ===

Kalau deploy dijalankan sebagai user app dan perlu restart service, beri izin '''hanya''' untuk perintah itu:

<syntaxhighlight lang="bash">
echo 'transcribe ALL=(root) NOPASSWD: /usr/bin/systemctl restart transcribe-api, /usr/bin/systemctl restart transcribe-api-worker' \
| sudo tee /etc/sudoers.d/transcribe-api
sudo chmod 0440 /etc/sudoers.d/transcribe-api
sudo visudo -cf /etc/sudoers.d/transcribe-api # validasi sintaks!
</syntaxhighlight>

* Selalu validasi dengan <code>visudo -c</code>. File sudoers yang rusak bisa mengunci <code>sudo</code> untuk semua orang.
* Path harus absolut dan persis sama. Di Ubuntu modern <code>/bin</code> adalah symlink ke <code>/usr/bin</code>, tapi sudo membandingkan string path, jadi cek dengan <code>command -v systemctl</code>.
* Jangan beri <code>NOPASSWD: ALL</code> ke user app. Itu sama saja memberi root.

Kalau deploy dijalankan lewat Ansible dengan user admin + <code>become</code>, aturan sudoers untuk user app '''tidak diperlukan sama sekali'''.

=== Siapa yang boleh menulis kode? ===

Di setup ini user app yang meng-clone dan build release, jadi kode bisa ditulis oleh user app. Ini sederhana tapi berarti app yang dibobol bisa mengubah kodenya sendiri. Alternatif yang lebih ketat:

* Buat user <code>deployer</code> terpisah yang meng-clone & build semua release.
* User app hanya punya akses baca + eksekusi ke <code>/opt/<app></code>.
* Bonus: cache uv bisa dipakai bersama antar app, sehingga hardlink menghemat disk (berguna untuk paket besar seperti torch).

Pada level ini, <code>ProtectSystem=strict</code> sudah menahan sebagian besar risiko: saat runtime seluruh filesystem read-only bagi proses app, kecuali <code>ReadWritePaths</code>.

== systemd ==

=== Anatomi unit ===

<syntaxhighlight lang="ini">
[Unit]
Description=Transcribe API
After=network-online.target redis-server.service
Wants=network-online.target redis-server.service

[Service]
Type=simple
User=transcribe
Group=transcribe
SupplementaryGroups=video
WorkingDirectory=/opt/transcribe-api/current
Environment=HOME=/var/lib/transcribe-api
Environment=PORT=6969
EnvironmentFile=-/etc/transcribe-api/transcribe-api.env
ExecStart=/opt/transcribe-api/current/.venv/bin/python -m uvicorn main:app --host 127.0.0.1 --port 6969
Restart=on-failure
RestartSec=5

NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
PrivateTmp=true
ReadWritePaths=/var/lib/transcribe-api

[Install]
WantedBy=multi-user.target
</syntaxhighlight>

Catatan per baris:
* <code>After=</code> mengatur '''urutan''', <code>Wants=</code>/<code>Requires=</code> mengatur '''ketergantungan'''. Hanya <code>After=</code> tidak membuat Redis ikut dijalankan.
* <code>EnvironmentFile=-...</code>: tanda <code>-</code> artinya "jangan gagal kalau file tidak ada". Variabel dari file '''meng-override''' <code>Environment=</code>.
* Format env file systemd: <code>KEY=value</code> per baris, '''tanpa''' <code>export</code>.
* <code>ExecStart</code> harus path absolut. Panggil binary venv langsung, bukan <code>uv run</code>, karena <code>uv run</code> bisa mencoba sync dependency saat start.
* Worker sebaiknya <code>Restart=always</code> dan <code>TimeoutStopSec=120</code> supaya job yang sedang jalan sempat selesai saat restart (systemd mengirim SIGTERM dulu, baru SIGKILL setelah timeout).

=== Directive hardening ===

{| class="wikitable"
! Directive !! Efek
|-
| <code>NoNewPrivileges=true</code> || proses dan turunannya tidak bisa naik hak akses (setuid, file capabilities tidak berlaku)
|-
| <code>ProtectSystem=strict</code> || seluruh filesystem read-only bagi service
|-
| <code>ReadWritePaths=</code> || pengecualian: path yang tetap boleh ditulis
|-
| <code>ProtectHome=true</code> || <code>/home</code>, <code>/root</code>, <code>/run/user</code> tidak terlihat
|-
| <code>PrivateTmp=true</code> || <code>/tmp</code> privat per service, tidak berbagi dengan proses lain
|}

Ukur tingkat keamanan unit:
<syntaxhighlight lang="bash">
systemd-analyze security transcribe-api
</syntaxhighlight>
Output-nya memberi skor dan daftar directive lain yang bisa ditambahkan (misalnya <code>ProtectKernelTunables</code>, <code>RestrictAddressFamilies</code>). Tambahkan bertahap dan tes, karena hardening yang terlalu ketat bisa mematahkan app (misalnya akses GPU butuh device yang tidak diblokir <code>PrivateDevices</code>).

=== Operasional harian ===

<syntaxhighlight lang="bash">
sudo systemctl daemon-reload # wajib setelah edit file unit
sudo systemctl enable --now transcribe-api # aktif saat boot + jalan sekarang
systemctl status transcribe-api transcribe-api-worker
journalctl -u transcribe-api -u transcribe-api-worker -f # follow log
journalctl -u transcribe-api --since "1 hour ago" -p err # hanya error
systemctl cat transcribe-api # lihat unit final yang dipakai
</syntaxhighlight>

=== Exit code systemd yang sering muncul ===

{| class="wikitable"
! Status !! Penyebab umum
|-
| <code>status=203/EXEC</code> || path di <code>ExecStart</code> salah, file tidak executable, atau venv rusak (interpreter yang di-symlink tidak bisa diakses)
|-
| <code>status=217/USER</code> || user di <code>User=</code> tidak ada
|-
| <code>status=200/CHDIR</code> || <code>WorkingDirectory</code> tidak ada atau tidak bisa dimasuki user app
|-
| <code>status=226/NAMESPACE</code> || path di <code>ReadWritePaths</code> belum dibuat
|-
| <code>Permission denied</code> di log app || app menulis di luar <code>ReadWritePaths</code> (cache model, file upload); arahkan ke <code>/var/lib/<app></code>
|}

== Pola release + symlink ==

<pre>
/opt/transcribe-api/
├── releases/
│ ├── 3f2a9c1d7e0b/
│ └── 9be41c0a22f1/
└── current -> releases/3f2a9c1d7e0b
</pre>

Alur deploy:
# Clone versi baru ke <code>releases/<sha></code>.
# Build (<code>uv sync --locked --no-dev</code>, <code>cargo build --release --locked</code>, <code>npm ci && npm run build</code>).
# Jalankan migrasi database kalau ada.
# Arahkan <code>current</code> ke release baru, restart service.
# Health check. Gagal → arahkan kembali ke release lama.

'''Soal atomik:''' <code>ln -sfn</code> sebenarnya menghapus symlink lalu membuat ulang, sehingga ada jeda sangat singkat tanpa <code>current</code>. Cara yang benar-benar atomik:
<syntaxhighlight lang="bash">
ln -s /opt/app/releases/NEW /opt/app/current.tmp
mv -T /opt/app/current.tmp /opt/app/current # rename(2) atomik
</syntaxhighlight>

'''Venv tidak bisa dipindah.''' Path absolut tertanam di script dalam <code>.venv/bin</code>, jadi selalu build venv langsung di folder release, jangan build di tempat lain lalu di-copy.

== Python dengan uv ==

* <code>uv sync --locked</code> gagal kalau <code>uv.lock</code> tidak sinkron dengan <code>pyproject.toml</code>. Ini yang diinginkan di produksi: server tidak pernah mengubah lock file.
* <code>--no-dev</code> melewati dependency development/test.
* <code>UV_PYTHON_DOWNLOADS=never</code> mencegah uv diam-diam mengunduh Python saat build.
* Update dependency dilakukan di laptop: <code>uv lock --upgrade</code>, commit, lalu deploy.
* Cache uv memakai hardlink ke venv selama berada di filesystem yang sama, sehingga deploy berikutnya cepat dan hemat disk.

== Redis lokal ==

<syntaxhighlight lang="bash">
sudo apt install -y redis-server
sudo sed -i 's/^appendonly no/appendonly yes/' /etc/redis/redis.conf # persistence
grep -E '^(bind|appendonly)' /etc/redis/redis.conf # bind 127.0.0.1 -::1
sudo systemctl enable --now redis-server
redis-cli ping
</syntaxhighlight>
Redis tanpa password '''wajib''' hanya listen di localhost. Di Docker, hostname-nya <code>redis</code>; di bare metal jadi <code>redis://127.0.0.1:6379/0</code>.

== Jaringan ==

* <code>--host 127.0.0.1</code>: app hanya bisa diakses dari server itu sendiri (cocok kalau nginx ada di server yang sama).
* <code>--host 0.0.0.0</code>: app bisa diakses dari luar. Wajib dibarengi firewall.
* Kalau nginx publik ada di VM proxy terpisah, buka port app '''hanya untuk IP VM proxy''':

<syntaxhighlight lang="bash">
sudo ufw allow OpenSSH
sudo ufw allow from 192.168.88.10 to any port 6969 proto tcp comment 'transcribe-api'
sudo ufw enable
sudo ufw status numbered
</syntaxhighlight>

Ubuntu memakai '''AppArmor''', bukan SELinux seperti AlmaLinux/RHEL. Untuk app di <code>/opt</code> biasanya tidak perlu konfigurasi tambahan.

== Otomasi dengan Ansible ==

=== Kenapa Ansible ===
* '''Agentless''': cukup SSH + Python di server.
* '''Idempotent''': dijalankan berkali-kali hasilnya sama; hanya yang berubah yang diubah.
* Semua langkah manual di atas terdokumentasi sebagai kode, sehingga server bisa dibangun ulang kapan saja.

=== Struktur project ===

<pre>
ansible-apps/
├── inventory.ini daftar server
├── apps.yml daftar app (repo, port, worker)
├── deploy.yml playbook utama
├── group_vars/all/main.yml setting global
├── group_vars/all/vault.yml secret terenkripsi
├── scripts/new-app.sh tambah app interaktif
└── roles/
├── base/ paket dasar
├── redis/
├── python_toolchain/ uv + Python di /opt/uv/python
├── rust_toolchain/ rustup di /opt/rust
├── node_toolchain/ NodeSource
└── app/ clone, deteksi tipe, build, systemd/nginx, health check, rollback
</pre>

=== Entry app ===

<syntaxhighlight lang="yaml">
apps:
- name: transcribe-api
repo: git@github.com:org/transcribe-api.git
version: main
port: 6969
user: transcribe
worker: true # bikin service transcribe-api-worker
redis: true
apt_packages: [ffmpeg]
extra_groups: [video]
health_path: /health
</syntaxhighlight>

Tipe app dideteksi dari isi repo: <code>pyproject.toml</code> → Python, <code>Cargo.toml</code> → Rust, <code>package.json</code> → Node (Vite/React jadi static di-serve nginx, Next/Nuxt jadi service).

=== Perintah ===

<syntaxhighlight lang="bash">
ansible-playbook deploy.yml # semua app
ansible-playbook deploy.yml -e only=transcribe-api # satu app
ansible-playbook deploy.yml -e only=core-api -e rev=v1.2.0 # versi tertentu / rollback
ansible-playbook deploy.yml --syntax-check
ansible-vault encrypt group_vars/all/vault.yml
</syntaxhighlight>

=== Konsep Ansible yang terkait permission ===

* <code>become: true</code>: task dijalankan sebagai root lewat sudo.
* <code>become_user: transcribe</code>: task dijalankan sebagai user app (clone, build), sehingga file yang dihasilkan langsung dimiliki user yang benar tanpa <code>chown</code> belakangan.
* Paket <code>acl</code> wajib terpasang. Saat <code>become_user</code> ke user non-root, Ansible menulis file modul sementara lalu memakai ACL (<code>setfacl</code>) agar user tujuan bisa membacanya.
* Modul <code>file</code> dengan <code>owner</code>, <code>group</code>, <code>mode</code> menggantikan rangkaian <code>mkdir</code>/<code>chown</code>/<code>chmod</code> dan idempotent.
* Secret di '''ansible-vault''', dirender ke env file lewat modul <code>template</code> dengan mode <code>0640</code>.

=== Deploy key untuk repo private ===

* Satu key per app, disimpan di <code>/var/lib/<app>/.ssh/id_ed25519</code> (mode <code>0600</code>, folder <code>0700</code>).
* Didaftarkan sebagai '''Deploy Key read-only''' di repo. Kalau server bocor, yang terekspos hanya akses baca ke satu repo, bukan akun GitHub pribadi.
* <code>StrictHostKeyChecking=accept-new</code>: host key disimpan saat pertama kali, dan koneksi ditolak kalau host key berubah (proteksi MITM).

== Troubleshooting ==

{| class="wikitable"
! Gejala !! Penyebab !! Solusi
|-
| <code>chown: invalid group</code> || group sudah di-rename/dihapus || <code>getent group</code>, pakai nama baru
|-
| <code>useradd</code> menghasilkan shell aneh || sisa <code>\</code> line-continuation ikut diketik dalam satu baris || cek <code>getent passwd</code>, bikin ulang user
|-
| Service <code>203/EXEC</code> padahal file ada || venv menunjuk ke Python di home user lain || install Python di <code>/opt/uv/python</code>, buat ulang venv
|-
| Model Whisper gagal diunduh || cache di luar <code>ReadWritePaths</code> || set <code>WHISPER_CACHE_DIR</code> / <code>HF_HOME</code> ke <code>/var/lib/<app></code>
|-
| <code>libcudnn</code> / <code>libcublas</code> not found || di Docker library datang dari image || install paket pip <code>nvidia-cudnn-cu12</code> / <code>nvidia-cublas-cu12</code> atau CUDA toolkit di host
|-
| Worker restart terus || error di job pertama atau Redis belum jalan || <code>journalctl -u app-worker -n 100</code>, <code>redis-cli ping</code>
|-
| Ansible gagal <code>become_user</code> || paket <code>acl</code> belum terpasang || <code>apt install acl</code>
|}

== Checklist server baru ==

* [ ] User admin pakai SSH key, login password dimatikan
* [ ] <code>ufw</code> aktif, hanya SSH + port yang perlu
* [ ] Driver NVIDIA terpasang, <code>nvidia-smi</code> jalan (kalau ada GPU)
* [ ] <code>unattended-upgrades</code> aktif untuk patch keamanan
* [ ] Jalankan <code>ansible-playbook deploy.yml</code>
* [ ] <code>systemd-analyze security <app></code> untuk tiap service
* [ ] Backup data di <code>/var/lib/<app></code> dan database, '''tes restore'''

== Lihat juga ==
* [https://docs.astral.sh/uv/ Dokumentasi uv]
* [https://www.freedesktop.org/software/systemd/man/latest/systemd.exec.html systemd.exec (directive hardening)]
* [https://refspecs.linuxfoundation.org/FHS_3.0/fhs/index.html Filesystem Hierarchy Standard 3.0]
* [https://docs.ansible.com/ Dokumentasi Ansible]

DevOps

SanzSkuy — Tue, 20 Oct 2026 06:41:50 GMT

← Older revision		Revision as of 06:41, 20 October 2026
Line 4:		Line 4:
	* [[Postgres master & slave]]		* [[Postgres master & slave]]
	* [[Cara buat monitoring server pake Grafana & Prometheus]]		* [[Cara buat monitoring server pake Grafana & Prometheus]]
			* [[Deploy app bare-metal]]

	== Microk8s ==		== Microk8s ==
	* [[Microk8s: setup awal]]		* [[Microk8s: setup awal]]
	* [[Microk8s: setup registry]]		* [[Microk8s: setup registry]]

Main Page

SanzSkuy — Mon, 19 Oct 2026 01:47:44 GMT

← Older revision		Revision as of 01:47, 19 October 2026
Line 48:		Line 48:
	* [[High-performance computing]]		* [[High-performance computing]]
	* [[Programming, Software Engineering, etc]]		* [[Programming, Software Engineering, etc]]
	* [[Aerospace Engineering]]
	* [[Istilah Penting]]

	<br>		<br>

SRAM & DRAM

SanzSkuy — Mon, 12 Oct 2026 04:01:04 GMT

Created page with "== Pendahuluan == Pada model sederhana, sistem komputer terdiri dari '''CPU''' dan '''memory system''' yang berupa array linear byte, dengan waktu akses konstan untuk setiap lokasi. Model ini efektif sampai batas tertentu, tetapi '''tidak mencerminkan cara kerja sistem modern'''. Dalam praktiknya, memory system adalah '''hierarki perangkat penyimpanan''' dengan kapasitas, biaya, dan waktu akses yang berbeda-beda. === Level hierarki (atas ke bawah) === # '''Register C..."

New page

== Pendahuluan ==

Pada model sederhana, sistem komputer terdiri dari '''CPU''' dan '''memory system''' yang berupa array linear byte, dengan waktu akses konstan untuk setiap lokasi. Model ini efektif sampai batas tertentu, tetapi '''tidak mencerminkan cara kerja sistem modern'''.

Dalam praktiknya, memory system adalah '''hierarki perangkat penyimpanan''' dengan kapasitas, biaya, dan waktu akses yang berbeda-beda.

=== Level hierarki (atas ke bawah) ===

# '''Register CPU''': menyimpan data yang paling sering dipakai
# '''Cache memory (SRAM)''': kecil dan cepat, menjadi ''staging area'' untuk subset data/instruksi di main memory
# '''Main memory (DRAM)''': lebih besar tetapi lambat, menjadi staging area untuk data di disk
# '''Disk''': sangat besar dan sangat lambat, bisa menjadi staging area untuk data di disk/tape mesin lain lewat jaringan

Semakin ke bawah: '''makin besar, makin murah per bit, makin lambat'''.

=== Kenapa hierarki ini bekerja? ===

Program yang ditulis dengan baik cenderung mengakses level atas lebih sering daripada level di bawahnya. Akibatnya level bawah boleh lambat (sehingga besar dan murah). Efek akhirnya: '''kapasitas dan biaya seperti storage paling bawah, tetapi kecepatan seperti storage paling atas'''.

=== Waktu akses ===

{| class="wikitable"
! Lokasi data !! Waktu akses
|-
| Register || 0 cycle
|-
| Cache || 4 sampai 75 cycle
|-
| Main memory || ratusan cycle
|-
| Disk || puluhan juta cycle
|}

=== Locality ===

Ide sentral bab ini. Program dengan '''good locality''':
* mengakses data yang '''sama''' berulang-ulang ('''temporal locality'''), atau
* mengakses data yang '''berdekatan''' ('''spatial locality''')

Program dengan locality bagus lebih banyak dilayani level atas, sehingga lebih cepat. Contoh: pada sistem Core i7, beberapa kernel perkalian matriks dengan jumlah operasi aritmetika yang sama bisa berbeda kecepatan hampir '''40x''' hanya karena locality-nya.

=== Roadmap bab ===

* Teknologi penyimpanan dasar: SRAM, DRAM, ROM, rotating disk, SSD
* Organisasi menjadi hierarki, dengan fokus pada '''cache''' (paling berdampak ke performa aplikasi)
* Menganalisis dan memperbaiki locality program C
* '''Memory mountain''': karakterisasi performa hierarki memori sebagai fungsi dari locality

== 6.1 Storage Technologies ==

Kemajuan teknologi komputer sangat dipengaruhi kemajuan teknologi storage. IBM PC-XT (1982) memiliki disk 10 MB. Pada 2015, mesin tipikal punya kapasitas disk sekitar 300.000x lebih besar, dan kapasitas naik 2x tiap dua tahun.

=== 6.1.1 Random Access Memory (RAM) ===

RAM terdiri dari dua varian:

* '''SRAM''' (Static RAM): lebih cepat dan jauh lebih mahal. Dipakai untuk '''cache memory''' (di dalam maupun di luar chip CPU).
* '''DRAM''' (Dynamic RAM): lebih lambat dan murah. Dipakai untuk '''main memory''' dan '''frame buffer''' sistem grafis.

==== Static RAM (SRAM) ====

* Menyimpan tiap bit dalam sel '''bistable''' yang terdiri dari '''6 transistor'''.
* Sirkuit punya dua konfigurasi tegangan stabil (dua ''state''). State lain bersifat tidak stabil dan akan bergerak cepat ke salah satu state stabil.
* Analogi: '''inverted pendulum''' (pendulum terbalik)
** Miring penuh ke kiri: stabil
** Miring penuh ke kanan: stabil
** Tegak lurus: '''metastable'''. Secara teori bisa bertahan, tetapi gangguan sekecil apa pun membuatnya jatuh dan tidak kembali ke posisi tegak.
* Selama ada daya (power), nilai SRAM bertahan tanpa batas. Gangguan seperti noise listrik akan hilang dengan sendirinya: sirkuit kembali ke nilai stabil.

==== Perbandingan SRAM vs DRAM (Figure 6.2) ====

{| class="wikitable"
! !! Transistor per bit !! Waktu akses relatif !! Persistent? !! Sensitive? !! Biaya relatif !! Pemakaian
|-
| '''SRAM''' || 6 || 1x || Ya || Tidak || 1.000x || Cache memory
|-
| '''DRAM''' || 1 || 10x || Tidak || Ya || 1x || Main memory, frame buffer
|}

Catatan istilah:
* '''Biaya''' = biaya per bit penyimpanan. Sebagian besar ditentukan oleh luas area silikon, sehingga SRAM (6 transistor/bit) jauh lebih mahal daripada DRAM (1 transistor/bit).
* '''Persistent''' = nilai bertahan selama chip dialiri daya, tanpa perlu di-refresh. Bukan berarti data bertahan saat listrik mati (SRAM dan DRAM keduanya ''volatile'').
* '''Sensitive''' = rentan terhadap gangguan (noise). DRAM menyimpan bit sebagai muatan di kapasitor yang bocor pelan-pelan, sehingga perlu di-refresh berkala.

==== Conventional DRAMs ====

Sel (bit) dalam chip DRAM dibagi menjadi '''d supercell''', masing-masing terdiri dari '''w sel DRAM'''.

* Chip '''d × w''' menyimpan total '''d·w bit'''.
* Supercell disusun sebagai array persegi panjang dengan '''r baris''' dan '''c kolom''', dengan '''r·c = d'''.
* Alamat supercell berbentuk '''(i, j)''': i = baris, j = kolom.

''Catatan terminologi'': komunitas storage tidak punya nama baku untuk elemen array DRAM. Arsitek komputer menyebutnya "cell", perancang sirkuit menyebutnya "word". Buku ini memakai istilah netral '''supercell'''.

===== Contoh: DRAM 16 × 8 (Figure 6.3) =====

* d = 16 supercell, w = 8 bit per supercell, total '''128 bit'''
* r = 4 baris, c = 4 kolom
* Supercell berwarna pada alamat '''(2, 1)'''

Informasi keluar-masuk chip lewat '''pin''' (konektor eksternal), dan tiap pin membawa sinyal 1 bit:
* '''Pin data''': 8 pin, mentransfer 1 byte sekaligus
* '''Pin addr''': 2 pin, membawa alamat baris atau kolom (2 bit)
* (Pin kontrol tidak ditampilkan)

Chip DRAM dihubungkan ke '''memory controller''', yaitu sirkuit yang dapat mentransfer w bit sekaligus ke/dari chip, lalu terhubung ke CPU.

===== Membaca supercell (i, j) =====

Dilakukan dalam dua langkah (Figure 6.4):

# '''RAS (Row Access Strobe)''': controller mengirim alamat baris '''i'''. DRAM menyalin '''seluruh isi baris i''' ke '''internal row buffer'''.
# '''CAS (Column Access Strobe)''': controller mengirim alamat kolom '''j'''. DRAM mengambil supercell (i, j) dari row buffer, lalu mengirim w bit-nya ke controller.

RAS dan CAS '''berbagi pin addr yang sama''', sehingga alamat harus dikirim berurutan.

Contoh membaca supercell (2, 1) pada chip 16 × 8:
# Controller kirim '''RAS = 2''', maka seluruh baris 2 disalin ke row buffer
# Controller kirim '''CAS = 1''', maka 8 bit di supercell (2, 1) dikirim ke controller

===== Internal row buffer =====

Penyimpanan kecil di dalam chip DRAM yang muat '''satu baris penuh''' supercell. Fungsinya sebagai tempat penampung baris yang sedang diakses. Supercell yang diminta dipilih dari row buffer, bukan langsung dari array utama.

===== Kenapa array 2D, bukan linear? =====

* '''Keuntungan''': jumlah pin addr berkurang. Contoh: 16 supercell linear (alamat 0 sampai 15) butuh 4 pin addr, sedangkan susunan 4 × 4 cukup 2 pin.
* '''Kerugian''': alamat dikirim dalam dua tahap (RAS lalu CAS), sehingga '''waktu akses bertambah'''.

== Rumus Ringkas ==

{| class="wikitable"
! Yang ditanya !! Rumus
|-
| Total bit || d × w
|-
| Jumlah pin data || w
|-
| Jumlah pin addr || log2(max(r, c))
|-
| Supercell disalin saat RAS || c (satu baris penuh)
|-
| Ukuran row buffer || c × w bit
|}

== Contoh Soal ==

=== Contoh 1: DRAM 64 × 4 (8 baris × 8 kolom) ===

* Total bit = 64 × 4 = '''256 bit'''
* Pin data = '''4'''
* Pin addr: 8 baris butuh 3 bit, maka '''3 pin'''
* Baca (5, 3): RAS = 5 (baris 5 ke row buffer), lalu CAS = 3 (kirim 4 bit)

=== Contoh 2: DRAM 256 × 8 (16 × 16) ===

* Total bit = 256 × 8 = '''2048 bit'''
* Pin data = '''8'''
* Pin addr = log216 = '''4 pin''' (jika linear: log2256 = 8 pin)

=== Contoh 3: DRAM 64 × 16 (8 × 8) ===

* Total bit = '''1024 bit'''
* Pin data = '''16''' (ditentukan oleh w, bukan selalu 8)
* Pin addr = '''3'''
* Baca (6, 2): RAS = 6 (8 supercell masuk row buffer), lalu CAS = 2 (kirim 16 bit)

=== Contoh 4: DRAM 128 × 4 (16 baris × 8 kolom) ===

* Total bit = '''512 bit'''
* Pin data = '''4'''
* Pin addr = '''4''' (baris butuh 4 bit, kolom butuh 3 bit, ambil yang terbesar karena pin dibagi)
* Supercell disalin saat RAS = '''8''' (row buffer = 8 × 4 = 32 bit)

== Poin Penting ==

* Hierarki memori bekerja karena '''locality'''.
* SRAM: cepat, stabil, mahal, untuk cache. DRAM: lambat, sensitif, murah, untuk main memory.
* Pin data ditentukan oleh '''w''', pin addr ditentukan oleh '''dimensi terbesar''' array.
* Pembacaan DRAM: '''RAS (baris ke row buffer) lalu CAS (kolom dari row buffer)'''.

Linux & Operating System

SanzSkuy — Mon, 12 Oct 2026 04:00:49 GMT

← Older revision		Revision as of 04:00, 12 October 2026
Line 20:		Line 20:
	=== temp ===		=== temp ===
	* [[Intro Compiler & Machine Abstraction]]		* [[Intro Compiler & Machine Abstraction]]
			* [[SRAM & DRAM]]

	== gem5 ==		== gem5 ==

Gem5: hello world

SanzSkuy — Sun, 11 Oct 2026 08:43:05 GMT

Created page with "'''gem5''' adalah simulator arsitektur komputer open-source yang dipakai untuk riset dan pembelajaran. Dengan gem5, sebuah komputer virtual (CPU, cache, bus, memori) dirakit lewat script Python, lalu sebuah program dijalankan di atasnya dan gem5 melaporkan statistik detail seperti jumlah cycle, jumlah instruksi, dan cache miss. Catatan ini mencakup pemasangan gem5 sampai menjalankan program "Hello World" pertama. == Persiapan == Catatan ini memakai Linux (Ubuntu/Debia..."

New page

'''gem5''' adalah simulator arsitektur komputer open-source yang dipakai untuk riset dan pembelajaran. Dengan gem5, sebuah komputer virtual (CPU, cache, bus, memori) dirakit lewat script Python, lalu sebuah program dijalankan di atasnya dan gem5 melaporkan statistik detail seperti jumlah cycle, jumlah instruksi, dan cache miss.

Catatan ini mencakup pemasangan gem5 sampai menjalankan program "Hello World" pertama.

== Persiapan ==

Catatan ini memakai Linux (Ubuntu/Debian). Paket yang dibutuhkan (mengikuti dokumentasi gem5; cek [https://www.gem5.org/documentation/general_docs/building dokumentasi resmi] kalau versinya berbeda):

<syntaxhighlight lang="bash">
sudo apt install build-essential scons python3-dev git pre-commit \
zlib1g zlib1g-dev libprotobuf-dev protobuf-compiler libprotoc-dev \
libgoogle-perftools-dev libboost-all-dev libhdf5-serial-dev \
python3-pydot python3-venv python3-tk mypy m4 libcapstone-dev \
libpng-dev libelf-dev pkg-config wget cmake doxygen
</syntaxhighlight>

== Clone dan build ==

<syntaxhighlight lang="bash">
git clone https://github.com/gem5/gem5
cd gem5
scons build/ALL/gem5.opt -j <JUMLAH CPU>
</syntaxhighlight>

Keterangan:
* <code>build/ALL</code> artinya build mencakup semua ISA (x86, ARM, RISC-V, dan lainnya). Alternatifnya <code>build/X86/gem5.opt</code> kalau hanya butuh x86, build-nya lebih ringan.
* <code>gem5.opt</code> adalah varian dengan optimasi dan debug info secukupnya. Untuk debugging dengan gdb, pakai <code>gem5.debug</code> (lebih lambat, build lebih lama).
* <code>-j</code> menentukan jumlah proses paralel. Isi dengan hasil <code>nproc</code>. Build pertama memakan waktu lama dan banyak RAM; kalau RAM kurang, kecilkan nilai <code>-j</code>.

== Hello World pertama ==

gem5 menyertakan script contoh untuk menjalankan program sederhana:

<syntaxhighlight lang="bash">
build/ALL/gem5.opt configs/learning_gem5/part1/simple.py
</syntaxhighlight>

Script ini merakit satu CPU sederhana dengan memori, lalu menjalankan program "Hello World" di dalamnya (mode ''Syscall Emulation''). Kalau berhasil, di terminal muncul tulisan <code>Hello world!</code> dan baris penutup yang menyebut tick terakhir simulasi. Angka tick bisa berbeda antarversi gem5.

=== Isi folder <code>m5out/</code> ===

Setiap simulasi menghasilkan folder <code>m5out/</code> di direktori tempat gem5 dijalankan:

{| class="wikitable"
! File !! Isi
|-
| <code>stats.txt</code> || Semua statistik simulasi (cycle, instruksi, cache miss, dan lainnya)
|-
| <code>config.ini</code> / <code>config.json</code> || Konfigurasi sistem yang disimulasikan, lengkap dengan semua parameter
|-
| <code>config.dot.svg</code> || Diagram blok sistem
|}

Nilai yang pertama kali layak dilihat di <code>stats.txt</code>: <code>simSeconds</code>, <code>simInsts</code>, dan <code>system.cpu.numCycles</code>.

== Merakit sistem sendiri ==

Script berikut melakukan hal yang sama dengan <code>simple.py</code>, tetapi ditulis manual agar terlihat tiap komponennya.

<syntaxhighlight lang="python">
import m5
from m5.objects import *
from gem5.resources.resource import obtain_resource

system = System()
system.clk_domain = SrcClockDomain()
system.clk_domain.clock = "1GHz"
system.clk_domain.voltage_domain = VoltageDomain()

system.mem_mode = "timing"
system.mem_ranges = [AddrRange("512MB")]

system.cpu = X86TimingSimpleCPU()

system.membus = SystemXBar()

# Tanpa cache: CPU langsung ke membus
system.cpu.icache_port = system.membus.cpu_side_ports
system.cpu.dcache_port = system.membus.cpu_side_ports

# Khusus x86: interrupt controller disambung manual
system.cpu.createInterruptController()
system.cpu.interrupts[0].pio = system.membus.mem_side_ports
system.cpu.interrupts[0].int_requestor = system.membus.cpu_side_ports
system.cpu.interrupts[0].int_responder = system.membus.mem_side_ports

system.system_port = system.membus.cpu_side_ports

system.mem_ctrl = MemCtrl()
system.mem_ctrl.dram = DDR3_1600_8x8()
system.mem_ctrl.dram.range = system.mem_ranges[0]
system.mem_ctrl.port = system.membus.mem_side_ports

# Workload: program Hello World (SE mode)
binary = obtain_resource("x86-hello64-static").get_local_path()
system.workload = SEWorkload.init_compatible(binary)

process = Process()
process.cmd = [binary]
system.cpu.workload = process
system.cpu.createThreads()

root = Root(full_system=False, system=system)
m5.instantiate()

print("Beginning simulation!")
exit_event = m5.simulate()
print(f"Exiting @ tick {m5.curTick()} because {exit_event.getCause()}")
</syntaxhighlight>

Jalankan dengan:

<syntaxhighlight lang="bash">
build/ALL/gem5.opt my_simple.py
</syntaxhighlight>

Catatan: kalau resource <code>x86-hello64-static</code> tidak ditemukan di versi gem5 yang dipakai, ganti <code>binary</code> dengan path ke binary hello di source tree (<code>tests/test-progs/hello/bin/x86/linux/hello</code>).

=== Komponen yang dirakit ===

{| class="wikitable"
! Komponen !! Fungsi
|-
| <code>System</code> + <code>clk_domain</code> || Kerangka sistem dan clock (1 GHz)
|-
| <code>mem_mode = "timing"</code> || Akses memori dimodelkan dengan latency
|-
| <code>X86TimingSimpleCPU</code> || Satu core x86 sederhana yang menunggu respons memori
|-
| <code>SystemXBar</code> (<code>membus</code>) || Bus penghubung. <code>cpu_side_ports</code> untuk pihak yang meminta data (CPU), <code>mem_side_ports</code> untuk pihak yang menyediakan data (memori, device)
|-
| <code>interrupts[0]</code> || Interrupt controller x86, wajib disambung manual
|-
| <code>system_port</code> || Jalur khusus gem5 (misalnya untuk memuat binary ke memori sebelum simulasi)
|-
| <code>MemCtrl</code> + <code>DDR3_1600_8x8</code> || Memory controller dan DRAM
|}

== Tips: Makefile ==

Agar tidak mengetik path panjang berulang kali:

<syntaxhighlight lang="make">
GEM5 ?= /home/haidhi/gem5/build/ALL/gem5.opt
SCRIPT ?= simple.py
OUTDIR ?= m5out
FLAGS ?= Exec

.PHONY: run stats debug clean

run:
$(GEM5) --outdir=$(OUTDIR) $(SCRIPT)

stats:
@grep -E "simSeconds|simInsts|numCycles|hostSeconds" $(OUTDIR)/stats.txt

debug:
$(GEM5) --debug-flags=$(FLAGS) --debug-file=debug.out --outdir=$(OUTDIR) $(SCRIPT)

clean:
rm -rf $(OUTDIR)
</syntaxhighlight>

Baris perintah di Makefile harus diawali karakter '''tab''', bukan spasi.

== Masalah umum ==

* '''<code>No module named '_m5'</code>''': script gem5 tidak bisa dijalankan dengan <code>python3 script.py</code>. Modul <code>_m5</code> ditanam di dalam binary, jadi script harus dijalankan lewat <code>gem5.opt</code>.
* '''Garis bawah merah di VSCode untuk <code>System</code>, <code>SrcClockDomain</code>, dll''': modul <code>m5.objects</code> dibangkitkan saat build dan source-nya di-embed ke binary, sehingga IDE tidak menemukannya. Script tetap berjalan normal. Garis bawahnya bisa dimatikan lewat setting <code>python.analysis.diagnosticSeverityOverrides</code> atau komentar <code># pyright: reportUndefinedVariable=false</code> di baris atas script.
* '''Build gagal karena kehabisan memori''': kecilkan nilai <code>-j</code>.

Linux & Operating System

SanzSkuy — Sun, 11 Oct 2026 08:42:36 GMT

← Older revision		Revision as of 08:42, 11 October 2026
Line 21:		Line 21:
	* [[Intro Compiler & Machine Abstraction]]		* [[Intro Compiler & Machine Abstraction]]

			== gem5 ==
			* [[gem5: hello world]]

	== LLVM ==		== LLVM ==
	* [[llvm: cara install]]		* [[llvm: cara install]]

Accessing Information

SanzSkuy — Fri, 09 Oct 2026 06:46:15 GMT

← Older revision		Revision as of 06:46, 9 October 2026
Line 22:		Line 22:
	\|<------------------- %rax (64 bit) ------------------->\|		\|<------------------- %rax (64 bit) ------------------->\|
	\|<------ %eax (32 bit) ----->\|		\|<------ %eax (32 bit) ----->\|
	\|<- %ax (16) ->\|		\|<- %ax (16) ->\|
	\|%al(8)\|		\|%al(8)\|
	</pre>		</pre>

Accessing Information

SanzSkuy — Fri, 09 Oct 2026 06:45:45 GMT

Created page with "CPU x86-64 punya '''16 general-purpose register''' berukuran 64-bit. Register ini menyimpan data integer dan pointer. == Sejarah penamaan == Penamaan register berlapis karena evolusi instruction set: {| class="wikitable" ! Generasi !! Lebar !! Nama register !! Catatan |- | 8086 || 16-bit || <code>%ax</code>, <code>%bx</code>, <code>%cx</code>, <code>%dx</code>, <code>%si</code>, <code>%di</code>, <code>%bp</code>, <code>%sp</code> || Nama mencerminkan fungsi (accumulat..."

New page

CPU x86-64 punya '''16 general-purpose register''' berukuran 64-bit. Register ini menyimpan data integer dan pointer.

== Sejarah penamaan ==
Penamaan register berlapis karena evolusi instruction set:

{| class="wikitable"
! Generasi !! Lebar !! Nama register !! Catatan
|-
| 8086 || 16-bit || <code>%ax</code>, <code>%bx</code>, <code>%cx</code>, <code>%dx</code>, <code>%si</code>, <code>%di</code>, <code>%bp</code>, <code>%sp</code> || Nama mencerminkan fungsi (accumulator, counter, source/destination index, stack pointer)
|-
| IA32 || 32-bit || <code>%eax</code> … <code>%ebp</code> || Prefix <code>e</code> = ''extended''
|-
| x86-64 || 64-bit || <code>%rax</code> … <code>%rbp</code> || Prefix <code>r</code>
|-
| x86-64 (baru) || 64-bit || <code>%r8</code> … <code>%r15</code> || Konvensi baru, suffix <code>d</code>/<code>w</code>/<code>b</code> untuk 32/16/8-bit
|}

== Sub-register (nested boxes) ==
<code>%rax</code>, <code>%eax</code>, <code>%ax</code>, <code>%al</code> '''bukan''' empat register berbeda, melainkan satu register fisik yang diakses dengan lebar berbeda:

<pre>
|<------------------- %rax (64 bit) ------------------->|
|<------ %eax (32 bit) ----->|
|<- %ax (16) ->|
|%al(8)|
</pre>

* Operasi byte → least significant byte
* Operasi 16-bit → 2 byte terbawah
* Operasi 32-bit → 4 byte terbawah
* Operasi 64-bit → seluruh register

== Aturan sisa byte saat menulis ke register ==
Ketika instruksi menghasilkan nilai kurang dari 8 byte ke register:

{| class="wikitable"
! Ukuran tulis !! Efek ke byte sisanya
|-
| 1 byte / 2 byte || '''Tidak berubah'''
|-
| 4 byte || 4 byte atas '''di-nol-kan'''
|}

Contoh, dengan <code>%rax = 0x1122334455667788</code>:

<syntaxhighlight lang="gas">
movb $0xAA, %al # %rax = 0x11223344556677AA (sisanya utuh)
movw $0xAAAA, %ax # %rax = 0x112233445566AAAA (sisanya utuh)
movl $0xAAAA, %eax # %rax = 0x000000000000AAAA (4 byte atas = 0)
</syntaxhighlight>

'''Kenapa?''' Aturan zero-upper diadopsi saat ekspansi IA32 → x86-64 supaya hasil tulisan tidak bergantung pada isi lama register (menghindari ''partial register dependency''), sehingga eksekusi out-of-order lebih lancar. Compiler memanfaatkannya, misalnya <code>mov $0x0,%eax</code> untuk <code>return 0</code>.

== Peran register (System V ABI) ==
{| class="wikitable"
! Register !! Peran
|-
| <code>%rax</code> || Return value
|-
| <code>%rdi</code>, <code>%rsi</code>, <code>%rdx</code>, <code>%rcx</code>, <code>%r8</code>, <code>%r9</code> || Argumen ke-1 sampai ke-6 (urut)
|-
| <code>%rsp</code> || Stack pointer (spesial, dipakai otomatis oleh <code>push</code>/<code>pop</code>/<code>call</code>/<code>ret</code>)
|-
| <code>%rbx</code>, <code>%rbp</code>, <code>%r12</code>–<code>%r15</code> || '''Callee saved''': fungsi yang dipanggil wajib mengembalikan nilainya
|-
| <code>%r10</code>, <code>%r11</code> (+ register argumen & <code>%rax</code>) || '''Caller saved''': boleh dirusak oleh fungsi yang dipanggil
|}

Jembatan keledai urutan argumen: '''"Diane's Silk Dress Costs $89"''' → <code>di</code>, <code>si</code>, <code>dx</code>, <code>cx</code>, <code>8</code>, <code>9</code>.

=== Contoh: <code>multstore</code> ===
<syntaxhighlight lang="gas">
push %rbx # rbx callee-saved → simpan nilai lama
mov %rdx,%rbx # rdx = argumen ke-3 (dest), amankan di rbx
call mult2 # x, y masih di rdi & rsi
mov %rax,(%rbx) # *dest = hasil mult2 (rax)
pop %rbx # pulihkan rbx
ret
</syntaxhighlight>
<code>dest</code> dipindah ke <code>%rbx</code> karena <code>%rdx</code> caller-saved (bisa dirusak <code>mult2</code>), sedangkan <code>%rbx</code> dijamin selamat melewati <code>call</code>.

= 3.4.1 Operand Specifiers =

== Tiga jenis operand ==
{| class="wikitable"
! Jenis !! Contoh !! Arti
|-
| Immediate || <code>$-577</code>, <code>$0x1F</code> || Konstanta, nilai tertanam di instruksi
|-
| Register || <code>%rax</code>, <code>%al</code> || Isi register, notasi <code>R[ra]</code>
|-
| Memory || <code>0x104</code>, <code>(%rax)</code>, <code>8(%rax)</code> || Isi memori di ''effective address'', notasi <code>M[Addr]</code>
|}

'''Perhatian:''' <code>$0x10</code> = angka 16, sedangkan <code>0x10</code> (tanpa <code>$</code>) = isi memori di alamat 16.

== <code>%rax</code> vs <code>(%rax)</code> ==
* <code>%rax</code> → isi register itu sendiri (seperti <code>p</code> di C)
* <code>(%rax)</code> → isi register dipakai sebagai alamat, lalu baca memori di alamat itu (seperti <code>*p</code> di C)

Kurung <code>( )</code> di AT&T = dereference. Di AT&T, register '''wajib''' pakai <code>%</code>; <code>rax</code> tanpa <code>%</code> akan dianggap nama simbol.

{| class="wikitable"
! Maksud !! AT&T (gcc, CS:APP) !! Intel (NASM, MASM)
|-
| Isi register || <code>%rax</code> || <code>rax</code>
|-
| Isi memori di alamat rax || <code>(%rax)</code> || <code>[rax]</code>
|-
| Konstanta || <code>$5</code> || <code>5</code>
|}

== Bentuk umum memory reference ==
<pre>
Imm(rb, ri, s) → alamat = Imm + R[rb] + R[ri] · s
</pre>
* <code>Imm</code>: displacement konstanta
* <code>rb</code>: base register (64-bit)
* <code>ri</code>: index register (64-bit)
* <code>s</code>: skala, hanya '''1, 2, 4, atau 8''' (ukuran <code>char</code>, <code>short</code>, <code>int</code>, <code>long</code>/pointer)

Semua mode lain adalah kasus khusus dengan komponen yang dihilangkan:

{| class="wikitable"
! Form !! Effective address !! Nama
|-
| <code>Imm</code> || <code>Imm</code> || Absolute
|-
| <code>(rb)</code> || <code>R[rb]</code> || Indirect
|-
| <code>Imm(rb)</code> || <code>Imm + R[rb]</code> || Base + displacement
|-
| <code>(rb,ri)</code> || <code>R[rb] + R[ri]</code> || Indexed
|-
| <code>Imm(rb,ri)</code> || <code>Imm + R[rb] + R[ri]</code> || Indexed
|-
| <code>(,ri,s)</code> || <code>R[ri]·s</code> || Scaled indexed
|-
| <code>Imm(,ri,s)</code> || <code>Imm + R[ri]·s</code> || Scaled indexed
|-
| <code>(rb,ri,s)</code> || <code>R[rb] + R[ri]·s</code> || Scaled indexed
|-
| <code>Imm(rb,ri,s)</code> || <code>Imm + R[rb] + R[ri]·s</code> || Scaled indexed
|}

Tambahan x86-64 yang tidak ada di tabel: '''RIP-relative''', misalnya <code>lea 0x0(%rip),%rdi</code>, alamat dihitung relatif terhadap instruksi berikutnya (dipakai untuk data global/string literal).

== Kegunaan: akses array dan struct ==
<syntaxhighlight lang="c">
long a[100];
x = a[i];
</syntaxhighlight>
Dengan <code>a</code> di <code>%rdx</code> dan <code>i</code> di <code>%rcx</code>:
<syntaxhighlight lang="gas">
movq (%rdx,%rcx,8), %rax # alamat = a + i*8
</syntaxhighlight>
Satu instruksi tanpa perkalian terpisah. Untuk <code>arr[i].field</code>, offset field masuk ke <code>Imm</code>.

== Cara menghitung nilai operand ==
Untuk memory operand selalu dua langkah:
# Hitung alamat: <code>Imm + R[rb] + R[ri]·s</code>
# Baca isi memori di alamat tersebut

'''Jebakan umum:'''
* Displacement tanpa <code>0x</code> adalah '''desimal''': <code>260</code> = <code>0x104</code>, <code>16</code> = <code>0x10</code>
* Koma di depan (<code>0xFC(,%rcx,4)</code>) berarti '''tanpa base register'''
* Perhatikan carry saat menjumlah hex: <code>0xFC + 4 = 0x100</code>
* Jangan berhenti di alamat; jawaban adalah '''isi''' memorinya

=== Contoh (Practice Problem 3.1) ===
Data: <code>%rax = 0x100</code>, <code>%rcx = 0x1</code>, <code>%rdx = 0x3</code>; memori <code>0x100→0xFF</code>, <code>0x104→0xAB</code>, <code>0x108→0x13</code>, <code>0x10C→0x11</code>.

{| class="wikitable"
! Operand !! Jenis !! Alamat !! Nilai
|-
| <code>%rax</code> || Register || — || <code>0x100</code>
|-
| <code>0x104</code> || Absolute || <code>0x104</code> || <code>0xAB</code>
|-
| <code>$0x108</code> || Immediate || — || <code>0x108</code>
|-
| <code>(%rax)</code> || Indirect || <code>0x100</code> || <code>0xFF</code>
|-
| <code>4(%rax)</code> || Base + displacement || <code>4 + 0x100 = 0x104</code> || <code>0xAB</code>
|-
| <code>9(%rax,%rdx)</code> || Indexed || <code>9 + 0x100 + 3 = 0x10C</code> || <code>0x11</code>
|-
| <code>260(%rcx,%rdx)</code> || Indexed || <code>0x104 + 1 + 3 = 0x108</code> || <code>0x13</code>
|-
| <code>0xFC(,%rcx,4)</code> || Scaled indexed || <code>0xFC + 1·4 = 0x100</code> || <code>0xFF</code>
|-
| <code>(%rax,%rdx,4)</code> || Scaled indexed || <code>0x100 + 3·4 = 0x10C</code> || <code>0x11</code>
|}

Linux & Operating System

SanzSkuy — Fri, 09 Oct 2026 06:45:18 GMT

← Older revision		Revision as of 06:45, 9 October 2026
Line 16:		Line 16:
	=== Representing and Manipulating Information ===		=== Representing and Manipulating Information ===
	* [[CS:APP 2 Intro]]		* [[CS:APP 2 Intro]]
			* [[Accessing Information]]

	=== temp ===		=== temp ===

Main Page

SanzSkuy — Fri, 09 Oct 2026 01:50:09 GMT

← Older revision		Revision as of 01:50, 9 October 2026
Line 31:		Line 31:
	* Widya Robotics — AI Engineer, Internship ''(February 2024 – June 2024)''		* Widya Robotics — AI Engineer, Internship ''(February 2024 – June 2024)''
	* Exylotech, Jakarta — Data Scientist, Internship ''(November 2022 – April 2023)''		* Exylotech, Jakarta — Data Scientist, Internship ''(November 2022 – April 2023)''
	* Riyadhussholihiin Islamic Boarding School, Pandeglang — ~~Tahfidz~~ Teacher ''(July 2020 - July 2021)''		* Riyadhussholihiin Islamic Boarding School, Pandeglang — Teacher ''(July 2020 - July 2021)''

	== Publication ==		== Publication ==

Intro Compiler & Machine Abstraction

SanzSkuy — Tue, 06 Oct 2026 07:07:14 GMT

Created page with "{{Catatan|Catatan ini merangkum dua topik yang saling berkaitan: '''optimisasi compiler''' dan '''abstraksi level mesin''' (ISA, virtual address, processor state x86-64). Materi mengikuti alur pembukaan Bab 3 CS:APP.}} == Compiler Optimization == '''Optimisasi''' adalah proses compiler mengubah kode sumber menjadi bentuk yang lebih cepat, lebih kecil, atau lebih hemat sumber daya, '''tanpa mengubah perilaku program yang teramati dari luar'''. Programmer menulis kode y..."

New page

{{Catatan|Catatan ini merangkum dua topik yang saling berkaitan: '''optimisasi compiler''' dan '''abstraksi level mesin''' (ISA, virtual address, processor state x86-64). Materi mengikuti alur pembukaan Bab 3 CS:APP.}}

== Compiler Optimization ==

'''Optimisasi''' adalah proses compiler mengubah kode sumber menjadi bentuk yang lebih cepat, lebih kecil, atau lebih hemat sumber daya, '''tanpa mengubah perilaku program yang teramati dari luar'''.

Programmer menulis kode yang mudah dibaca manusia; compiler menerjemahkannya menjadi kode mesin yang efisien.

=== Aturan dasar: ''as-if rule'' ===

Compiler boleh melakukan transformasi apa pun selama program berperilaku '''seolah-olah''' tidak diubah. Output akhir harus tetap sama.

{{Warning|''Undefined behavior'' (UB) di C/C++ dapat menghasilkan perilaku yang tampak aneh justru karena aturan ini. Compiler berasumsi UB '''tidak pernah terjadi''', lalu melakukan optimisasi berdasarkan asumsi tersebut. Kode yang "kelihatannya benar" bisa dihapus atau diubah total.}}

=== Jenis-jenis optimisasi ===

; Constant folding
: Ekspresi konstan dihitung saat kompilasi. <code>x = 2 * 3 + 4</code> menjadi <code>x = 10</code>.
; Dead code elimination
: Kode yang tidak pernah dieksekusi, atau yang hasilnya tidak pernah dipakai, dibuang.
; Inlining
: Pemanggilan fungsi kecil diganti langsung dengan isi fungsinya, menghilangkan overhead ''call''.
; Loop unrolling
: Badan loop "dibentangkan" untuk mengurangi overhead pengecekan kondisi dan lompatan.
; Common subexpression elimination
: Ekspresi yang dihitung berulang cukup dihitung satu kali.
; Vectorization (SIMD)
: Beberapa operasi data diproses sekaligus dalam satu instruksi, memanfaatkan ''vector register''.
; Register allocation
: Variabel yang sering dipakai ditempatkan di register CPU, bukan di memori.

{{Tip|Register x86-64 hanya ada '''16 buah'''. Keterbatasan inilah yang membuat ''register allocation'' menjadi salah satu masalah tersulit dalam desain compiler. Variabel yang tidak kebagian register harus di-''spill'' ke stack, dan itu jauh lebih lambat.}}

=== Flag optimisasi ===

{| class="wikitable"
! Flag !! Keterangan
|-
| <code>-O0</code> || Tanpa optimisasi. Paling nyaman untuk ''debugging'' karena kode mesin masih memetakan rapi ke kode sumber.
|-
| <code>-O1</code> || Optimisasi dasar.
|-
| <code>-O2</code> || Standar untuk produksi.
|-
| <code>-O3</code> || Lebih agresif, termasuk vectorization dan inlining yang lebih luas.
|-
| <code>-Os</code> || Mengutamakan ukuran biner yang kecil.
|}

Di Rust, mode optimisasi diaktifkan dengan <code>cargo build --release</code>.

{{Tip|Saat ''debugging'', gunakan <code>-O0</code>. Pada level optimisasi tinggi, variabel bisa hilang dari ''debugger'', urutan eksekusi berubah, dan ''breakpoint'' tidak mendarat di tempat yang diharapkan.}}

== Abstraksi dalam Sistem Komputer ==

'''Abstraksi''' adalah menyembunyikan detail implementasi di balik model yang lebih sederhana. Untuk pemrograman level mesin, ada dua abstraksi yang paling penting.

=== 1. Instruction Set Architecture (ISA) ===

ISA adalah "kontrak" antara perangkat keras dan perangkat lunak. ISA mendefinisikan:

* '''Processor state''' — apa saja yang disimpan prosesor (register, program counter, condition flag)
* '''Format instruksi''' — bagaimana instruksi dikodekan
* '''Efek tiap instruksi''' terhadap state tersebut

Sebagian besar ISA, termasuk '''x86-64''', mendeskripsikan perilaku program '''seolah-olah''' setiap instruksi dieksekusi berurutan: satu instruksi selesai sebelum instruksi berikutnya dimulai.

==== Kenyataan di perangkat keras ====

Prosesor nyata jauh lebih rumit dan mengeksekusi banyak instruksi secara '''konkuren''':

* '''Pipelining''' — beberapa tahap instruksi tumpang tindih
* '''Superscalar''' — beberapa instruksi dieksekusi bersamaan
* '''Out-of-order execution''' — urutan eksekusi disusun ulang sesuai kesiapan data
* '''Speculative execution''' — prosesor menebak hasil percabangan sebelum diketahui

Prosesor menggunakan '''pengaman''' (''dependency checking'', ''reorder buffer'', ''in-order commit'') untuk memastikan hasil akhirnya tetap identik dengan model sekuensial yang dijanjikan ISA.

{{Catatan|Pola yang sama muncul di dua lapisan berbeda. Compiler boleh mengubah urutan kode (''as-if rule''), hardware boleh mengubah urutan eksekusi — keduanya sah '''selama perilaku yang teramati tidak berubah'''.}}

=== 2. Virtual Address ===

Alamat memori yang dipakai program level mesin adalah '''alamat virtual''', yang menyajikan memori sebagai '''satu array byte yang sangat besar dan berurutan'''.

Implementasi sebenarnya jauh lebih kompleks:

* Hierarki perangkat keras: register → cache L1/L2/L3 → DRAM → disk
* Perangkat lunak sistem operasi: ''page table'', MMU, TLB, penanganan ''page fault'', ''swapping''

Sistem operasi mengelola ruang alamat virtual dan menerjemahkan alamat virtual menjadi alamat fisik.

==== Ukuran ruang alamat x86-64 ====

* Alamat direpresentasikan sebagai word '''64-bit'''
* Pada implementasi saat ini, '''16 bit teratas harus bernilai nol'''
* Ruang alamat efektif = 248 byte ≈ '''64 terabyte'''
* Program biasa hanya memakai beberapa megabyte sampai beberapa gigabyte

{{Warning|Pada satu waktu, hanya sebagian kecil rentang alamat virtual yang dianggap '''valid'''. Akses ke alamat yang tidak valid inilah yang memunculkan ''segmentation fault''.}}

=== Abstraksi yang bocor (''leaky abstraction'') ===

Kedua abstraksi di atas membuat assembly bisa dipelajari sama sekali. Namun abstraksi tersebut '''bocor''' dalam beberapa situasi:

* '''Performa''' — ISA menjanjikan urutan, tetapi ''cache miss'' dan ''branch misprediction'' tetap memengaruhi kecepatan nyata
* '''Konkurensi''' — model sekuensial tidak lagi cukup ketika beberapa thread berinteraksi, sehingga diperlukan ''memory barrier'' dan operasi atomik
* '''Keamanan''' — Spectre dan Meltdown adalah kasus di mana pengaman ternyata tidak sempurna: ''speculative execution'' meninggalkan jejak di cache yang bisa dibaca penyerang

== Representasi Level Mesin ==

Compiler mengerjakan bagian terberat: menerjemahkan model eksekusi C yang relatif abstrak menjadi instruksi prosesor yang sangat elementer.

'''Assembly''' dan '''machine code''' pada dasarnya sama; perbedaannya hanya representasi. Assembly berbentuk teks yang bisa dibaca manusia, machine code berbentuk biner. Hubungan keduanya nyaris satu-ke-satu.

=== Processor state yang terlihat ===

Bagian-bagian state prosesor berikut tersembunyi dari programmer C, tetapi terlihat jelas di level mesin.

==== Program counter (<code>%rip</code>) ====

Menyimpan '''alamat memori instruksi berikutnya''' yang akan dieksekusi. Di C, posisi eksekusi adalah konsep implisit; di level mesin, ini register konkret yang dapat diubah lewat instruksi lompat dan pemanggilan fungsi.

==== Integer register file ====

16 lokasi bernama, masing-masing menyimpan nilai '''64-bit'''. Isinya dapat berupa alamat (setara pointer di C) atau data integer.

{| class="wikitable"
! Register !! Peran umum (System V AMD64 ABI)
|-
| <code>%rax</code> || Nilai kembalian fungsi
|-
| <code>%rbx</code> || ''Callee-saved''
|-
| <code>%rcx</code> || Argumen ke-4
|-
| <code>%rdx</code> || Argumen ke-3
|-
| <code>%rsi</code> || Argumen ke-2
|-
| <code>%rdi</code> || Argumen ke-1
|-
| <code>%rbp</code> || ''Callee-saved'' / ''frame pointer''
|-
| <code>%rsp</code> || ''Stack pointer''
|-
| <code>%r8</code> || Argumen ke-5
|-
| <code>%r9</code> || Argumen ke-6
|-
| <code>%r10</code>, <code>%r11</code> || ''Caller-saved'', data sementara
|-
| <code>%r12</code>–<code>%r15</code> || ''Callee-saved''
|}

Sebagian register melacak bagian penting dari state program, sebagian lain menampung data sementara seperti argumen, variabel lokal, dan nilai kembalian.

==== Condition code register ====

Menyimpan informasi status hasil operasi aritmetika atau logika '''yang terakhir dieksekusi''' (''zero flag'', ''sign flag'', ''carry'', ''overflow'').

Register inilah yang dipakai untuk mengimplementasikan perubahan alur kontrol bersyarat seperti <code>if</code> dan <code>while</code>:

# Instruksi pembanding dieksekusi → flag berubah
# Instruksi lompat bersyarat membaca flag → alur program bercabang

{{Catatan|Satu pernyataan <code>if</code> di C selalu "dicicil" menjadi minimal dua langkah terpisah di level mesin: penetapan flag, lalu pembacaan flag.}}

==== Vector register ====

Setiap register dapat menampung '''satu atau lebih''' nilai integer atau floating-point sekaligus. Inilah dasar perangkat keras untuk SIMD dan ''vectorization''.

=== Memori: tipe data adalah ilusi ===

C menyediakan model di mana objek dengan tipe berbeda dideklarasikan dan dialokasikan di memori. Kode mesin memandang memori '''semata-mata sebagai array byte besar yang dapat dialamati'''.

Konsekuensinya:

* Tipe agregat seperti ''array'' dan ''struct'' direpresentasikan sebagai '''kumpulan byte yang bersebelahan'''
* Assembly '''tidak membedakan''' integer ''signed'' dan ''unsigned''
* Assembly tidak membedakan jenis pointer satu sama lain
* Assembly bahkan '''tidak membedakan pointer dari integer'''

{{Warning|Yang membedakan ''signed'' dan ''unsigned'' bukan datanya, melainkan '''instruksi mana yang dipilih''' untuk mengolahnya. Pola bit-nya identik. Inilah sebabnya kesalahan tipe data di C bisa lolos tanpa gejala sampai jauh di kemudian hari.}}

{{Tip|Hal ini juga menjelaskan mengapa ''casting'' pointer di C praktis "gratis" di level mesin — tidak ada data yang berubah, hanya cara compiler memperlakukannya.}}

=== Isi program memory ===

Ruang memori program berisi:

* Kode mesin yang dapat dieksekusi
* Informasi yang dibutuhkan sistem operasi
* '''Run-time stack''' untuk mengelola pemanggilan dan pengembalian prosedur
* Blok memori yang dialokasikan pengguna, misalnya melalui <code>malloc</code>

Seluruhnya dialamati menggunakan alamat virtual.

=== Satu instruksi = satu operasi elementer ===

Satu instruksi mesin hanya melakukan operasi yang sangat sederhana, misalnya:

* Menjumlahkan dua angka yang tersimpan di register
* Memindahkan data antara memori dan register
* Melompat ke alamat instruksi lain secara bersyarat

Compiler harus '''menyusun rangkaian''' instruksi semacam itu untuk mengimplementasikan konstruksi program seperti evaluasi ekspresi aritmetika, loop, serta pemanggilan dan pengembalian prosedur.

{{Catatan|Inilah gambaran besarnya. C menyediakan objek bertipe, variabel bernama, dan struktur kontrol. Mesin hanya punya 16 register, array byte, flag, dan instruksi sederhana. '''Jarak antara keduanya diisi oleh compiler''' — dan membaca hasil pengisian jarak itulah inti dari Bab 3 CS:APP.}}

Linux & Operating System

SanzSkuy — Tue, 06 Oct 2026 07:07:07 GMT

← Older revision		Revision as of 07:07, 6 October 2026
Line 16:		Line 16:
	=== Representing and Manipulating Information ===		=== Representing and Manipulating Information ===
	* [[CS:APP 2 Intro]]		* [[CS:APP 2 Intro]]

			=== temp ===
			* [[Intro Compiler & Machine Abstraction]]


	== LLVM ==		== LLVM ==
	* [[llvm: cara install]]		* [[llvm: cara install]]