no message

JAVA.md

+# ☕ Pengenalan kepada Java
+
+## 📘 Apa Itu Java?
+
+**Java** ialah bahasa pengaturcaraan tahap tinggi yang direka oleh Sun Microsystems (kini dimiliki oleh Oracle). Ia menggunakan paradigma **berorientasikan objek (OOP)** dan boleh dijalankan di mana-mana platform menggunakan **Java Virtual Machine (JVM)**, iaitu runtime khas untuk menjalankan aplikasi Java.
+
+Java digunakan secara meluas untuk membangunkan aplikasi web, aplikasi mudah alih (terutama Android), sistem perniagaan, permainan video, dan perisian perusahaan.
+
+> ⚙️ **Untuk sistem SKB yang dibangunkan oleh pasukan kita, Java digunakan sebagai bahasa utama bagi bahagian backend**, kerana kestabilan, keselamatan dan kemampuannya mengendalikan aplikasi berskala besar.
+
+---
+
+## 🔧 Ciri-Ciri Utama Java
+
+Bahasa Java mempunyai beberapa kelebihan penting:
+
+- ✅ **Berorientasikan Objek (OOP)** – Bina aplikasi yang modular dan mudah diurus
+- 🔁 **Platform-Independent** – Kod boleh dijalankan di mana-mana platform yang menyokong JVM
+- 🛡️ **Selamat & Terkawal** – Dengan pengurusan memori automatik
+- 🌐 **Digunakan Secara Luas** – Digunakan oleh syarikat gergasi dan komuniti global
+
+---
+
+## 🧱 Struktur Asas Program Java
+
+🔰 Ini ialah struktur minimum program Java yang sah:
+
+```java
+public class HelloWorld {
+    public static void main(String[] args) {
+        System.out.println("Hello, dunia!");
+    }
+}
+```
+
+📌 Penjelasan:
+- `class HelloWorld` – Semua kod mesti berada dalam kelas
+- `main()` – Titik masuk program
+- `System.out.println()` – Arahan untuk paparan ke skrin
+
+---
+
+
+## 🔣 Pemboleh Ubah dan Jenis Data
+
+📌 Kita gunakan **pemboleh ubah** untuk menyimpan nilai dalam memori semasa program dijalankan.
+
+```java
+int umur = 25;
+double gaji = 4500.75;
+char abjad = 'A';
+boolean isPelajar = true;
+String nama = "Ali";
+```
+
+### ✅ Jenis Data Penting dalam Java
+
+| Jenis Data | Keterangan             | Contoh                    |
+|------------|------------------------|---------------------------|
+| `int`      | Nombor bulat           | `int umur = 25;`          |
+| `double`   | Nombor perpuluhan      | `double gaji = 4500.75;`  |
+| `char`     | Satu aksara            | `char abjad = 'A';`       |
+| `boolean`  | Nilai benar/palsu      | `boolean isPelajar = true;` |
+| `String`   | Rangkaian aksara (teks)| `String nama = "Ali";`    |
+
+---
+
+### 🔄 Perbezaan: Primitif vs Bukan Primitif
+
+| Ciri              | **Primitif**                         | **Bukan Primitif**               |
+|-------------------|--------------------------------------|----------------------------------|
+| Didefinisi oleh   | Bahasa Java                          | Kelas (Class)                    |
+| Contoh            | `int`, `double`, `char`, `boolean`   | `String`, `Array`, `Object`      |
+| Boleh `null`      | ❌ Tidak boleh                       | ✅ Boleh                          |
+| Ada method        | ❌ Tiada                             | ✅ Ada                            |
+| Digunakan untuk   | Nilai asas                           | Objek dan struktur data          |
+| Penyimpanan       | Nilai terus                          | Rujukan ke objek                 |
+
+---
+
+### 🧪 Contoh Program Lengkap
+
+```java
+public class DataJenisDemo {
+    public static void main(String[] args) {
+        // Primitif
+        int umur = 25;
+        double gaji = 4500.75;
+        char abjad = 'A';
+        boolean isPelajar = true;
+
+        // Bukan Primitif
+        String nama = "Ali";
+
+        // Papar maklumat
+        System.out.println("Nama: " + nama);
+        System.out.println("Umur: " + umur + " tahun");
+        System.out.println("Gaji: RM" + gaji);
+        System.out.println("Abjad: " + abjad);
+        System.out.println("Status Pelajar: " + isPelajar);
+
+        // Demonstrasi objek
+        Integer umurObj = umur; // Autoboxing
+        System.out.println("Umur sebagai objek: " + umurObj.toString());
+    }
+}
+```
+
+---
+
+
+
+## ⚙️ Operator Aritmetik dan Logik
+
+📌 Digunakan untuk **kiraan matematik** dan **membuat keputusan logik** dalam sesuatu program.
+
+### 🧮 Operator Aritmetik
+
+Operator ini digunakan untuk melakukan operasi matematik asas:
+
+| Operator | Nama        | Contoh            | Hasil         |
+|----------|-------------|-------------------|---------------|
+| `+`      | Tambah      | `10 + 5`          | `15`          |
+| `-`      | Tolak       | `10 - 3`          | `7`           |
+| `*`      | Darab       | `4 * 5`           | `20`          |
+| `/`      | Bahagi      | `20 / 4`          | `5`           |
+| `%`      | Modulus     | `10 % 3`          | `1` (baki)    |
+
+### 🔍 Operator Perbandingan
+
+Operator ini membandingkan dua nilai dan hasilnya ialah `true` atau `false`:
+
+| Operator | Nama               | Contoh          | Hasil     |
+|----------|--------------------|-----------------|-----------|
+| `==`     | Sama dengan        | `5 == 5`        | `true`    |
+| `!=`     | Tidak sama dengan  | `5 != 3`        | `true`    |
+| `<`      | Kurang daripada    | `2 < 5`         | `true`    |
+| `>`      | Lebih daripada     | `6 > 3`         | `true`    |
+| `<=`     | Kurang atau sama   | `4 <= 4`        | `true`    |
+| `>=`     | Lebih atau sama    | `5 >= 2`        | `true`    |
+
+### 🧠 Operator Logik
+
+Digunakan untuk gabungkan syarat logik, selalunya dalam `if`:
+
+| Operator | Nama              | Contoh                         | Hasil     |
+|----------|-------------------|--------------------------------|-----------|
+| `&&`     | Dan (AND)         | `(5 > 3) && (3 < 10)`          | `true`    |
+| `||`     | Atau (OR)         | `(5 < 3) || (3 < 10)`          | `true`    |
+| `!`      | Tidak (NOT)       | `!(5 == 5)`                    | `false`   |
+
+---
+
+### 🧪 Contoh Program Lengkap
+
+```java
+public class OperatorDemo {
+    public static void main(String[] args) {
+        int a = 10 + 5; // Aritmetik
+        System.out.println("Nilai a: " + a); // 15
+
+        boolean logik = (a > 10) && (a < 20); // Logik
+        System.out.println("Adakah a di antara 10 dan 20? " + logik); // true
+
+        int baki = a % 4;
+        System.out.println("Baki apabila a dibahagi 4: " + baki); // 3
+    }
+}
+```
+
+---
+
+
+## 🔁 Kawalan Aliran
+
+📌 Digunakan untuk mengawal aliran kod berdasarkan syarat dan pengulangan.
+
+### Kawalan Bersyarat
+```java
+if (umur >= 18) {
+    System.out.println("Dewasa");
+} else {
+    System.out.println("Belum cukup umur");
+}
+```
+
+### Ulangan (Loop)
+```java
+for (int i = 0; i < 3; i++) {
+    System.out.println("Ulangan ke-" + i);
+}
+```
+
+---
+
+## 📦 Array (Senarai Statik)
+
+📌 Digunakan untuk menyimpan banyak nilai dalam satu struktur.
+
+```java
+int[] nombor = {1, 2, 3, 4};
+System.out.println(nombor[0]); // output: 1
+```
+
+---
+
+## 📚 Koleksi: ArrayList & HashMap
+
+📌 Koleksi digunakan untuk mengurus kumpulan data secara dinamik (tidak seperti array statik).
+
+### 🔸 ArrayList
+```java
+import java.util.ArrayList;
+
+ArrayList<String> senarai = new ArrayList<>();
+senarai.add("Ali");
+senarai.add("Siti");
+
+System.out.println(senarai.get(0)); // Ali
+```
+- Boleh tambah, padam dan akses elemen dengan mudah
+- Bersifat dinamik: saiz berubah ikut keperluan
+
+### 🔸 HashMap
+```java
+import java.util.HashMap;
+
+HashMap<String, Integer> skor = new HashMap<>();
+skor.put("Ali", 90);
+skor.put("Siti", 85);
+
+System.out.println(skor.get("Ali")); // 90
+```
+- Simpan data dalam pasangan `key-value`
+- Contoh: nama pelajar sebagai key, markah sebagai value
+
+---
+
+## ⚠️ Exception Handling (Pengendalian Ralat)
+
+📌 Java membolehkan anda tangani ralat semasa runtime supaya aplikasi tidak terus berhenti secara tiba-tiba.
+
+### Contoh:
+```java
+try {
+    int hasil = 10 / 0;
+} catch (ArithmeticException e) {
+    System.out.println("Ralat: Bahagi dengan sifar!");
+}
+```
+
+- `try` – kod yang berpotensi cetuskan ralat
+- `catch` – blok yang dijalankan jika berlaku ralat
+- `finally` – (opsyenal) sentiasa dijalankan
+
+---
+
+
+
+## 🧠 Asas Pemrograman Berorientasikan Objek (OOP)
+
+**OOP** (Object-Oriented Programming) ialah gaya pengaturcaraan yang menstrukturkan kod berdasarkan **kelas** dan **objek**.
+
+Objek mewakili entiti dunia sebenar dan menggabungkan **data (atribut)** serta **fungsi (method)** dalam satu unit.
+
+---
+
+### 🔎 Apa Itu Kelas & Objek?
+
+#### 🧱 Kelas
+Kelas ialah **blueprint** atau pelan untuk mencipta objek.
+
+```java
+public class Kereta {
+    String warna;
+
+    // Constructor
+    Kereta(String w) {
+        warna = w;
+    }
+
+    void hon() {
+        System.out.println("Beep!");
+    }
+}
+```
+
+#### 🚗 Objek
+Objek ialah contoh sebenar yang dicipta daripada kelas.
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Kereta k1 = new Kereta("Merah");
+        k1.hon();  // Beep!
+        System.out.println("Warna kereta: " + k1.warna);
+    }
+}
+```
+
+**Output dijangka:**
+```
+Beep!
+Warna kereta: Merah
+```
+
+---
+
+### 🔑 Empat Prinsip Utama OOP
+
+| Prinsip           | Fungsi                                                                 |
+|-------------------|------------------------------------------------------------------------|
+| ✅ **Encapsulation** | Sembunyikan data dan kawal akses melalui getter/setter                   |
+| 🔁 **Inheritance**   | Wariskan sifat/fungsi dari kelas lain                                 |
+| 🔄 **Polymorphism**  | Fungsi sama tapi hasil berbeza bergantung objek atau parameter         |
+| 🧩 **Abstraction**   | Sembunyikan detail, hanya dedah fungsi penting                         |
+
+---
+
+### ✅ Contoh Setiap Prinsip
+
+#### 🛡️ Encapsulation
+
+```java
+public class Pelajar {
+    private String nama;
+
+    public void setNama(String n) {
+        nama = n;
+    }
+
+    public String getNama() {
+        return nama;
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Pelajar p = new Pelajar();
+        p.setNama("Ali");
+        System.out.println("Nama pelajar: " + p.getNama());
+    }
+}
+```
+
+**Output dijangka:**
+```
+Nama pelajar: Ali
+```
+
+---
+
+#### 👪 Inheritance
+
+```java
+class Manusia {
+    void bercakap() {
+        System.out.println("Bercakap...");
+    }
+}
+
+class Pelajar extends Manusia {
+    void belajar() {
+        System.out.println("Belajar...");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Pelajar p = new Pelajar();
+        p.bercakap();
+        p.belajar();
+    }
+}
+```
+
+**Output dijangka:**
+```
+Bercakap...
+Belajar...
+```
+
+---
+
+#### 🌀 Polymorphism
+
+##### 1. Overriding (mengganti method parent)
+
+```java
+class Haiwan {
+    void bunyi() {
+        System.out.println("Haiwan berbunyi");
+    }
+}
+
+class Kucing extends Haiwan {
+    @Override
+    void bunyi() {
+        System.out.println("Meow");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Haiwan h = new Kucing();
+        h.bunyi();
+    }
+}
+```
+
+**Output dijangka:**
+```
+Meow
+```
+
+##### 2. Overloading (method sama nama, parameter berbeza)
+
+```java
+class Kalkulator {
+    int tambah(int a, int b) {
+        return a + b;
+    }
+
+    double tambah(double a, double b) {
+        return a + b;
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Kalkulator k = new Kalkulator();
+        System.out.println("Tambah int: " + k.tambah(2, 3));
+        System.out.println("Tambah double: " + k.tambah(2.5, 3.5));
+    }
+}
+```
+
+**Output dijangka:**
+```
+Tambah int: 5
+Tambah double: 6.0
+```
+
+---
+
+#### 🔍 Abstraction
+
+##### Menggunakan `abstract class` dengan lebih dari satu method
+
+```java
+abstract class Haiwan {
+    abstract void suara();
+    abstract void makan();
+}
+
+class Anjing extends Haiwan {
+    void suara() {
+        System.out.println("Guk guk");
+    }
+
+    void makan() {
+        System.out.println("Anjing makan tulang");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Haiwan h = new Anjing();
+        h.suara();
+        h.makan();
+    }
+}
+```
+
+**Output dijangka:**
+```
+Guk guk
+Anjing makan tulang
+```
+
+---
+
+### 🧩 Interface
+
+```java
+interface BolehTerbang {
+    void terbang();
+}
+
+class Burung implements BolehTerbang {
+    public void terbang() {
+        System.out.println("Burung terbang di langit");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        BolehTerbang b = new Burung();
+        b.terbang();
+    }
+}
+```
+
+**Output dijangka:**
+```
+Burung terbang di langit
+```
+
+---
+
+### 🎯 Kenapa OOP Penting?
+
+- 💡 Modular: Boleh bina komponen yang mudah digabung
+- 🔧 Senang selenggara dan kemas kini
+- 🔄 Guna semula kod (reuse) dengan `inheritance` dan `interface`
+- 🔐 Lebih selamat dengan `private` & `protected` data
+
+---
+
+## 📚 Logik & Struktur Kod
+
+📌 Untuk aplikasi lebih besar, anda perlu:
+- Gunakan `method` – pecah kod kepada fungsi kecil
+- Gunakan `class` – uruskan komponen aplikasi
+- Gunakan `package` – susun projek dalam modul terpisah
+
+Contoh struktur fail:
+```
+projek/
+├── model/
+│   └── Pelajar.java
+├── service/
+│   └── PelajarService.java
+└── AppUtama.java
+```
+
+
+---
+
+### 🎯 Kenapa OOP Penting?
+
+- 💡 Mudah untuk bina aplikasi besar secara modular
+- 🔧 Kod lebih tersusun dan senang diselenggara
+- 🔄 Boleh guna semula kod dengan warisan (inheritance)
+- 🔐 Lebih selamat dengan kawalan akses data
+
+## 📚 Logik & Struktur Kod
+
+📌 Untuk aplikasi lebih besar, anda perlu:
+- Gunakan `method` – pecah kod kepada fungsi kecil
+- Gunakan `class` – urus komponen aplikasi
+- Gunakan `package` – susun projek besar secara modul
+
+---
+
+## 🎓 Kesimpulan
+
+Dengan menguasai:
+
+✅ Struktur asas  
+✅ Pemboleh ubah & kawalan aliran  
+✅ Array & logik  
+✅ Prinsip OOP  
+
+...anda sudah mampu membina aplikasi konsol Java yang lengkap dan tersusun.
+
+---
+
+

README (2).md

+## 📘 Pengenalan Ringkas: Apa Itu Docker?
+
+**Docker** ialah platform sumber terbuka yang membolehkan pembangun membungkus aplikasi bersama semua kebergantungan (dependencies) ke dalam satu unit yang dipanggil **container**.
+
+### 🌟 Kelebihan Docker:
+
+- 🚀 **Cepat & Ringan** – Lebih pantas berbanding VM (Virtual Machine) dan guna sumber lebih sedikit.
+- 🔄 **Konsisten** – "It works on my machine" tidak lagi jadi masalah.
+- 🧪 **Mudah untuk Ujian** – Boleh bina & uji aplikasi dalam persekitaran yang terpencil.
+
+---
+
+## 📦 Konsep Asas Docker
+
+### 1. 🧊 Image
+- Imej ialah **template read-only** yang mengandungi segala yang diperlukan untuk menjalankan aplikasi: kod, runtime, pustaka, dan dependencies.
+- Contoh: `node:16-alpine`, `mysql:latest`
+
+### 2. 📦 Container
+- Container ialah **instance** aktif daripada image.
+- Ia adalah persekitaran yang terpencil dan ringan untuk menjalankan aplikasi.
+
+### 3. 💾 Volume
+- Volume digunakan untuk **menyimpan data** secara berterusan di luar container.
+- Ini penting untuk data seperti pangkalan data yang anda tidak mahu hilang apabila container dimusnahkan.
+
+### 4. 📝 Dockerfile
+- Fail konfigurasi yang digunakan untuk **bina image**.
+- Mengandungi arahan seperti `FROM`, `COPY`, `RUN`, `EXPOSE`, dan `CMD`.
+
+### 5. 🔗 Docker Compose
+- Alat untuk **urus berbilang container** dalam satu fail YAML (`docker-compose.yml`).
+- Memudahkan deploy aplikasi yang ada frontend, backend, dan pangkalan data sekaligus.
+- Contoh perintah:
+  ```bash
+  docker-compose up -d --build
+  ```
+
+---
+
+
+# 🚀 LATIHAN AMALI: Docker untuk Aplikasi React + Spring Boot
+
+
+
+## 1. ✅ PROSEDUR PEMASANGAN DOCKER DESKTOP (WINDOWS)
+
+1. **Akses laman rasmi Docker**  
+   👉 [https://www.docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop)
+
+2. **Muat turun pemasang** (.exe)
+
+3. **Jalankan pemasang**  
+   Klik dua kali pada fail `.exe`
+
+4. **Ikuti arahan pemasangan**  
+   ✔ Aktifkan WSL 2 (jika Windows Home)  
+   ✔ Teruskan pemasangan
+
+5. **Selesaikan pemasangan**  
+   🔄 Restart jika diminta
+
+6. **Buka Docker Desktop** dari menu Start
+
+7. **Sahkan pemasangan Docker**  
+   ```bash
+   docker --version
+   ```
+
+---
+
+## 2. 🐳 DEPLOY APLIKASI MENGGUNAKAN DOCKER
+
+### 2.1 🎯 Objektif
+
+- Fahami containerization React + Spring Boot
+- Gunakan `docker-compose` untuk deploy sistem penuh
+
+### 2.2 📦 Keperluan
+
+- Docker Desktop
+- Git & VS Code (atau mana-mana teks editor)
+
+### 2.3 📁 Struktur Folder Projek
+```
+your-project/
+├── productApp/         # React frontend
+│   ├── Dockerfile
+│   ├── .env
+│   └── nginx.conf
+├── productSvc/         # Spring Boot backend
+│   └── Dockerfile
+├── nginx.conf          # NGINX config for serving React app (optional global config)
+└── docker-compose.yml  # Compose file to run both services
+
+```
+📥 Muat turun:  
+[Download Projek ZIP](http://gitlab.cybersolution.com.my/mbdk-tot/product-management-docker/repository/master/archive.zip)
+
+🗂 Extract ke direktori:  
+`C:\Users\<nama-anda>\Documents\DockerProductApp\`
+
+---
+
+## 2.4 🌐 Deploy React App
+
+### 2.4.1 🔧 Dockerfile (React)
+
+Letak dalam `productApp/Dockerfile`
+
+```
+FROM node:16-alpine AS build
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+COPY . .
+RUN npm run build
+
+FROM nginx:stable-alpine
+COPY --from=build /app/build /usr/share/nginx/html
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]
+```
+
+### 2.4.2 ⚙️ Fail nginx.conf
+
+Letak dalam `productApp/nginx.conf`
+
+```
+server {
+    listen 80;
+    location / {
+        root /usr/share/nginx/html;
+        index index.html;
+        try_files $uri $uri/ /index.html;
+    }
+}
+```
+
+📌 **Nota:** Membolehkan React Router handle routing.
+
+### 2.4.3 ▶️ Jalankan React App dalam Docker
+
+```bash
+cd productApp
+docker build -t product-ui .
+docker run -d -p 3000:80 --name product-ui product-ui
+docker ps
+```
+
+🌍 Akses: [http://localhost:3000](http://localhost:3000)
+
+---
+
+## 2.5 ⚙️ Deploy Java Spring Boot
+
+### 2.5.1 🔧 Dockerfile (Spring Boot)
+
+Letak dalam `productSvc/Dockerfile`
+
+```
+FROM eclipse-temurin:21-jdk-alpine AS builder
+WORKDIR /app
+COPY . .
+RUN ./gradlew clean build -x test
+
+FROM eclipse-temurin:21-jdk-alpine
+WORKDIR /app
+COPY --from=builder /app/build/libs/*.jar app.jar
+EXPOSE 8080
+ENTRYPOINT ["java", "-jar", "app.jar"]
+```
+
+### 2.5.2 ▶️ Jalankan Spring Boot App
+
+```bash
+cd productSvc
+docker network create my-network
+
+docker run -d --network my-network --name mysql-db \
+  -e MYSQL_ROOT_PASSWORD=S3cret \
+  -e MYSQL_DATABASE=productmngm \
+  -p 3306:3306 mysql:latest
+
+docker build -t product-svc .
+
+docker run -d --network my-network -p 8025:8025 --name product-service \
+  -e APP_INTERNAL_PORT=8025 \
+  -e DB_ADDRESS=mysql-db \
+  -e DB_PORT=3306 \
+  -e DB_NAME=productmngm \
+  -e DB_USERNAME=root \
+  -e DB_PASSWORD=S3cret \
+  product-svc
+
+docker ps
+```
+
+🌍 Akses Swagger:  
+[http://localhost:8025/product-service/swagger-ui/index.html](http://localhost:8025/product-service/swagger-ui/index.html)
+
+---
+
+## 3. 🧩 Deploy Multi-container dengan Docker Compose + NGINX
+
+### 3.1 📜 Fail docker-compose.yml
+
+Letakkan di root projek:
+
+```yaml
+version: '3.8'
+
+services:
+  product-svc:
+    container_name: productservice
+    build: ./productSvc
+    ports:
+      - "8020:8020"
+    environment:
+      APP_INTERNAL_PORT: 8020
+      DB_ADDRESS: mysql
+      DB_PORT: 3306
+      DB_NAME: productmngm
+      DB_USERNAME: root
+      DB_PASSWORD: S3cret
+    depends_on:
+      - mysql
+    networks:
+      - my-network
+
+  mysql:
+    container_name: mysql
+    image: mysql:latest
+    restart: always
+    environment:
+      MYSQL_ROOT_PASSWORD: S3cret
+      MYSQL_DATABASE: productmngm
+    ports:
+      - "3306:3306"
+    volumes:
+      - mysql-data:/var/lib/mysql
+    networks:
+      - my-network
+
+  product-ui:
+    container_name: product-ui
+    build: ./productApp
+    ports:
+      - "8030:80"
+    networks:
+      - my-network
+
+  nginx:
+    container_name: nginx
+    image: nginx:latest
+    ports:
+      - "80:80"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf:ro
+    depends_on:
+      - product-svc
+    networks:
+      - my-network
+
+volumes:
+  mysql-data:
+
+networks:
+  my-network:
+    driver: bridge
+```
+
+### 3.2 🔄 NGINX sebagai Reverse Proxy
+
+**Reverse Proxy** = Pengantara antara pengguna dan backend
+
+🗂 Contoh `nginx.conf`:
+
+```
+events {}
+
+http {
+    server {
+        listen 80;
+
+        location /product-service/ {
+            proxy_pass http://productservice:8020/product-service/;
+        }
+
+        location /product-ui/ {
+            proxy_pass http://product-ui:80/;
+        }
+    }
+}
+```
+
+### 3.3 🚀 Jalankan Semua Sekali Guna Docker Compose
+
+```bash
+docker-compose up -d --build
+```
+
+### 3.4 ✅ Semak Semua Container Aktif
+
+```bash
+docker ps
+```
+
+### 3.5 🌍 Akses Aplikasi
+
+- Frontend: [http://localhost/product-ui](http://localhost/product-ui)
+- Backend API: [http://localhost/product-service/swagger-ui/index.html](http://localhost/product-service/swagger-ui/index.html)
\ No newline at end of file