Pada tutorial kali ini, kita akan belajar bagaimana melakukan Dockerize aplikasi Next JS dengan mode Standalone.

&nbsp;
### Apa itu mode standalone?

\
Mode standalone adalah proses build next js dimana akan mengoptimalkan hasil build dengan membuang node_modules dan hanya menggunakan library yang dibutuhkan saja dan di convert menjadi static file.

\
Dengan menggunakan standalone ukuran aplikasi akan menjadi lebih kecil sampai 80%

\
Jika kita ingin menjalankan aplikasi Next JS kita sebagai container maka menggunakan mode standalone akan sangat membantu mengurangi size dari container.

&nbsp;
### Install Next JS

\
Kita akan menginstall Next JS terlebih dahulu, jalankan perintah dibawah dan buat nama project misalnya "next-standalone"

&nbsp;
```shell
npx create-next-app@latest

```

\
Lalu masuk kedalam folder "next-standalone" kemudian edit file **next.config.js** tambahkan output

&nbsp;
```javascript
/** @type {import('next').NextConfig} */
const nextConfig = {
    output: 'standalone',
};

export default nextConfig;

```

\
Kemudian buat file Dockerfile

```shell
FROM node:18-alpine AS base

 
FROM base AS builder
RUN apk add --no-cache libc6-compat
RUN apk update
# Set working directory
WORKDIR /app
COPY . .
 
# Add lockfile and package.json's of isolated subworkspace
FROM base AS installer
RUN apk add --no-cache libc6-compat
RUN apk update
WORKDIR /app
 
# First install the dependencies (as they change less often)
COPY .gitignore .gitignore
COPY --from=builder /app/package.json .
RUN yarn install
 
# Build the project
COPY --from=builder /app/ .
RUN yarn build
 
FROM base AS runner
WORKDIR /app
 
 
# Don't run production as root
RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs
USER nextjs
 
COPY --from=installer /app/next.config.mjs .
COPY --from=installer /app/package.json .
# COPY --from=installer /app/.env.production .
 
# Automatically leverage output traces to reduce image size
# https://nextjs.org/docs/advanced-features/output-file-tracing
COPY --from=installer --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=installer --chown=nextjs:nodejs /app/.next/static ./.next/static
COPY --from=installer --chown=nextjs:nodejs /app/public ./public

EXPOSE 3000

CMD node server.js 
```

\
Kemudian jalankan perintah


```shell
docker build -t next-standalone .
```

\
Setelah berhasil, kemudian testing dengan menjalankan perintah

```shell
docker run -it --rm -p 3000:3000 next-standalone
```

\
Kemudian akses broswer http://localhost:3000

![next.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/next_fecc7b40c4.png)

\
Berikut ini perbandingan ukuran container jika tanpa mode standalalone dan menggunakan mode standalone:


```shell
| No Standalone  |  With Standalone Mode |
| 500MB  |  100MB |
```

\
Ukuran diatas hanya perbandingan next js tanpa menggunakan library tambahan seperti Chakra UI, Taildwind CSS

Dockerize aplikasi Next JS dengan Mode Standalone dengan ukuran yang lebih kecil

large_next.png

medium_next.png

small_next.png

thumbnail_next.png

next.png

Next jS Dockerize for Production With Standalone Mode

Pertama install Next JS terlebih dahulu.

Jalankan perintah

```
npx create-next-app@latest
```

\
Lalu isi nama project dengan nama misalnya "next-https"

\
Kemudian masuk kedalam project lalu jalankan perintah

```
yarn dev
```

\
Lalu buka browser untuk memastikan

\
![h7XmUpL.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/h7_Xm_Up_L_bd293ddbe6.png)


\
Untuk menjalankan dengan HTTPS caranya cukup mudah, jalankan perintah

```
yarn dev --experimental-https
```

\
Kemudian buka browser dan gunakan https

\
![80JWiiW.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/80_J_Wii_W_725dcc2b82.png)

Pada tutorial kali ini saya akan membagikan cara mudah menjalankan Next JS dilocalhost dengan Https

medium_MeHEBzF.png

small_MeHEBzF.png

thumbnail_MeHEBzF.png

MeHEBzF.png

Menjalankan Next JS dengan HTTPS di Localhost

## **Apa itu binary tree?**

Binary tree adalah struktur data berhierarki dalam ilmu komputer dan struktur data, yang terdiri dari simpul-simpul atau node-node yang diatur dalam suatu hierarki. Setiap node dalam binary tree memiliki setidaknya dua cabang atau anak-anak, yang dikenal sebagai sub-pohon kiri dan sub-pohon kanan.

\
**Contoh penggunaan binary tree**

&nbsp;
Pada contoh ini kita akan membuat struktur data Menu dimana ada **parent** dan **child** yang saling berelasi satu sama lain.

\
Kita akan menggunakan bahasa pemrograman golang untuk membuat struktur binary tree dari Flat akan diubah menjadi struktur tree.


\
Buat struct untuk Menu

```go
type Menu struct {
	ID       int
	ParentID int
	MenuName string `json:"menu_name"`
	MenuPath string `json:"menu_path"`
	Children []*Menu
}
}
```

\
Source yang akan kita gunakan adalah

```go
menus := []*Menu{
		{
			ID:       1,
			ParentID: 0,
			MenuName: "Home 1",
		},
		{
			ID:       2,
			ParentID: 1,
			MenuName: "Home 2",
		},
		{
			ID:       3,
			ParentID: 2,
			MenuName: "Home 3",
		},
		{
			ID:       4,
			ParentID: 0,
			MenuName: "Dashboard 1",
		},
		{
			ID:       5,
			ParentID: 4,
			MenuName: "Dashboard 2",
		},
		{
			ID:       6,
			ParentID: 5,
			MenuName: "Dashboard 3",
		},
		{
			ID:       7,
			ParentID: 6,
			MenuName: "Dashboard 4",
		},
		{
			ID:       8,
			ParentID: 7,
			MenuName: "Dashboard 5",
		},
		{
			ID:       9,
			ParentID: 8,
			MenuName: "Dashboard 6",
		},
		{
			ID:       10,
			ParentID: 9,
			MenuName: "Dashboard 7",
		},
	}
```

\
Buat file **main.go**

\
Buat fungsi **creatreTree**

```go
func createTree(nodes []*Menu) []*Menu {
	nodeMap := make(map[int]*Menu)

	// Create a mapping of ID to Menu
	for _, node := range nodes {
		nodeMap[node.ID] = node
	}

	// Iterate through nodes to build the tree
	var root []*Menu
	for _, node := range nodes {
		parentID := node.ParentID
		if parentID == 0 {
			// Node is the root
			root = append(root, node)
		} else {
			// Node has a parent, add it to the parent's children
			parentNode := nodeMap[parentID]
			if parentNode != nil {
				parentNode.Children = append(parentNode.Children, node)
			}
		}
	}

	return root
}
```

\
Kemudian buat fungsi **main**

```go
func main() {
	menus := []*Menu{
		{
			ID:       1,
			ParentID: 0,
			MenuName: "Home 1",
		},
		{
			ID:       2,
			ParentID: 1,
			MenuName: "Home 2",
		},
		{
			ID:       3,
			ParentID: 2,
			MenuName: "Home 3",
		},
		{
			ID:       4,
			ParentID: 0,
			MenuName: "Dashboard 1",
		},
		{
			ID:       5,
			ParentID: 4,
			MenuName: "Dashboard 2",
		},
		{
			ID:       6,
			ParentID: 5,
			MenuName: "Dashboard 3",
		},
		{
			ID:       7,
			ParentID: 6,
			MenuName: "Dashboard 4",
		},
		{
			ID:       8,
			ParentID: 7,
			MenuName: "Dashboard 5",
		},
		{
			ID:       9,
			ParentID: 8,
			MenuName: "Dashboard 6",
		},
		{
			ID:       10,
			ParentID: 9,
			MenuName: "Dashboard 7",
		},
	}

	trees := createTree(menus)

	b, _ := json.Marshal(trees)

	fmt.Println(string(b))
}

```


\
Full Code

```go
package main

import (
	"encoding/json"
	"fmt"
)

type Menu struct {
	ID       int
	ParentID int
	MenuName string `json:"menu_name"`
	MenuPath string `json:"menu_path"`
	Children []*Menu
}

func createTree(nodes []*Menu) []*Menu {
	nodeMap := make(map[int]*Menu)

	// Create a mapping of ID to Menu
	for _, node := range nodes {
		nodeMap[node.ID] = node
	}

	// Iterate through nodes to build the tree
	var root []*Menu
	for _, node := range nodes {
		parentID := node.ParentID
		if parentID == 0 {
			// Node is the root
			root = append(root, node)
		} else {
			// Node has a parent, add it to the parent's children
			parentNode := nodeMap[parentID]
			if parentNode != nil {
				parentNode.Children = append(parentNode.Children, node)
			}
		}
	}

	return root
}

func main() {
	menus := []*Menu{
		{
			ID:       1,
			ParentID: 0,
			MenuName: "Home 1",
		},
		{
			ID:       2,
			ParentID: 1,
			MenuName: "Home 2",
		},
		{
			ID:       3,
			ParentID: 2,
			MenuName: "Home 3",
		},
		{
			ID:       4,
			ParentID: 0,
			MenuName: "Dashboard 1",
		},
		{
			ID:       5,
			ParentID: 4,
			MenuName: "Dashboard 2",
		},
		{
			ID:       6,
			ParentID: 5,
			MenuName: "Dashboard 3",
		},
		{
			ID:       7,
			ParentID: 6,
			MenuName: "Dashboard 4",
		},
		{
			ID:       8,
			ParentID: 7,
			MenuName: "Dashboard 5",
		},
		{
			ID:       9,
			ParentID: 8,
			MenuName: "Dashboard 6",
		},
		{
			ID:       10,
			ParentID: 9,
			MenuName: "Dashboard 7",
		},
	}

	trees := createTree(menus)

	b, _ := json.Marshal(trees)

	fmt.Println(string(b))
}

```

\
Jalankan perintah **go run .** untuk menjalankan log


\
fungsi diatas akan menghasilkan data seperti berikut:

```json
[
    {
        "ID": 1,
        "ParentID": 0,
        "menu_name": "Home 1",
        "menu_path": "",
        "Children": [
            {
                "ID": 2,
                "ParentID": 1,
                "menu_name": "Home 2",
                "menu_path": "",
                "Children": [
                    {
                        "ID": 3,
                        "ParentID": 2,
                        "menu_name": "Home 3",
                        "menu_path": "",
                        "Children": null
                    }
                ]
            }
        ]
    },
    {
        "ID": 4,
        "ParentID": 0,
        "menu_name": "Dashboard 1",
        "menu_path": "",
        "Children": [
            {
                "ID": 5,
                "ParentID": 4,
                "menu_name": "Dashboard 2",
                "menu_path": "",
                "Children": [
                    {
                        "ID": 6,
                        "ParentID": 5,
                        "menu_name": "Dashboard 3",
                        "menu_path": "",
                        "Children": [
                            {
                                "ID": 7,
                                "ParentID": 6,
                                "menu_name": "Dashboard 4",
                                "menu_path": "",
                                "Children": [
                                    {
                                        "ID": 8,
                                        "ParentID": 7,
                                        "menu_name": "Dashboard 5",
                                        "menu_path": "",
                                        "Children": [
                                            {
                                                "ID": 9,
                                                "ParentID": 8,
                                                "menu_name": "Dashboard 6",
                                                "menu_path": "",
                                                "Children": [
                                                    {
                                                        "ID": 10,
                                                        "ParentID": 9,
                                                        "menu_name": "Dashboard 7",
                                                        "menu_path": "",
                                                        "Children": null
                                                    }
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    }
                ]
            }
        ]
    }
]
```

Pada tutorial kali ini kita akan membuat binary tree didalam bahasa pemrograman Golang.

Kelas tidak ditemukan