Unduh kubethor - Unduh Kode Sumber kubethor

kubethor

Kode sumber lainnya

1.0.0

Unduh

Kubethor

Kubethor adalah aplikasi web manajemen Kubernetes yang dibangun menggunakan Go and React. Ini menyediakan antarmuka yang ramah pengguna untuk mengelola dan memantau cluster Kubernetes secara efisien.

Daftar isi

Fitur
Dibangun dengan
Gambar Docker
Struktur folder
Memulai
- Prasyarat
- Instalasi
- Menjalankan aplikasi
- Menjalankan aplikasi sebagai mandiri
- Bangun dan Jalankan Gambar Docker
- Penempatan Kubernetes
Berkontribusi
Lisensi
Kontak

Fitur

Manajemen Cluster: Dengan mudah mengelola beberapa kluster Kubernetes.
Pemantauan Sumber Daya: Visualisasikan dan Pantau Sumber Daya Kubernet seperti pod, layanan, penyebaran, dll.
Agregasi log: logging terpusat untuk melihat log dari berbagai wadah.
Editor Sumber Daya: Sunting sumber daya Kubernetes langsung dari antarmuka web.
Delete Resource: Hapus sumber daya Kubernetes dengan mudah.
Tampilan Detail Sumber Daya: Lihat informasi terperinci tentang sumber daya Kubernetes.
Beralih Antara Namespaces: Beralih dengan mulus di antara berbagai ruang nama untuk mengelola sumber daya.

Dibangun dengan

Frontend
- Bereaksi: Perpustakaan JavaScript untuk membangun antarmuka pengguna.
- Flowbite: Komponen UI Dibangun dengan CSS Tailwind.
Backend
- Go (Golang): Bahasa pemrograman yang digunakan untuk backend.
- Klien Kubernetes: Perpustakaan klien untuk berinteraksi dengan kluster Kubernetes.

Gambar Docker

Tarik gambar Docker: docker pull kubethor/kubethor
Jalankan wadah Docker: docker run -p 8080:8080 kubethor/kubethor
Akses aplikasi melalui http: // localhost: 8080 di browser Anda.

Untuk detail lebih lanjut tentang gambar Docker, kunjungi halaman Hub Kubethor Docker.

Struktur folder

Berikut gambaran struktur proyek:

 kubethor/
├── kubethor-frontend/          # React frontend
│   ├── public/                 # Public assets
│   ├── src/                    # React source code
│       ├── assets              # Contains frontend assets
│       ├── components          # Contains commonly used hooks and components
│       ├── layouts             # Contains common page layouts
│       ├── pages               # Contains pages component
│       ├── App.jsx
│       └── ...                 # Other frontend files
│   ├── package.json            # Node.js dependencies
│   └── ...                     # Other frontend files
│
├── kubethor-backend/           # Go backend
│   ├── main.go                 # Main Go application
│   ├── go.mod                  # Go module dependencies
│   ├── api                     # Contains api's
│   ├── config                  # Contains configuration
│   ├── build.sh                # Build script for standalone app
│   ├── k8s.yaml                # Kubernetes deployment file
│   ├── Dockerfile              # Kubernetes deployment file
│   ├── dist                    # Compiled React build (Need to copy from frontend folder after build)
│   └── ...                     # Other backend files and folders
│
├── README.md                   # Project README
└── ...                         # Other project files

kubethor-frontend/
- public/ : Berisi aset statis seperti gambar, font, dan file index.html yang berfungsi sebagai titik masuk untuk aplikasi React.
- src/ : Kode sumber utama untuk aplikasi React.
  - assets/ : Berisi aset frontend seperti gambar, ikon, dan gaya.
  - components/ : Berisi komponen reaksi yang dapat digunakan kembali dan kait yang digunakan di seluruh aplikasi.
  - layouts/ : Berisi komponen tata letak yang menentukan struktur tata letak halaman umum.
  - pages/ : Berisi komponen halaman yang mewakili tampilan atau rute yang berbeda dalam aplikasi.
  - App.jsx : Komponen aplikasi utama yang mengatur perutean dan membuat tata letak inti aplikasi.
- package.json : Menentukan dependensi dan skrip Node.js untuk proyek Frontend.
kubethor-backend/
- main.go : File aplikasi GO utama yang menginisialisasi dan menjalankan server backend.
- go.mod : Menentukan dependensi modul GO untuk proyek backend.
- api/ : Berisi implementasi API yang diekspos server backend.
- config/ : Berisi file konfigurasi untuk lingkungan dan pengaturan yang berbeda yang digunakan oleh backend.
- build.sh : Skrip build yang digunakan untuk menyusun aplikasi backend mandiri dan mengelola proses pembuatan.
- k8s.yaml : File penyebaran Kubernetes yang menentukan cara menggunakan aplikasi backend pada cluster Kubernetes.
- Dockerfile : File build Docker yang digunakan untuk membuat gambar Docker untuk aplikasi backend.
- dist/ : Direktori tempat pembuatan reaksi yang dikompilasi disalin dari folder frontend setelah proses pembuatan. Ini memungkinkan backend untuk melayani aplikasi Frontend.

Memulai

Prasyarat

Go (versi 1.16 atau lebih tinggi)
Node.js (versi 18.x atau lebih tinggi)
Docker (opsional, untuk penyebaran yang dimasukkan)
Kubectl (untuk berinteraksi dengan kluster Kubernetes)

Video:

Instalasi

Klon Repositori:

git clone [email protected]:sassoftware/kubethor.git
cd kubethor

Pengaturan Frontend:
- Arahkan ke direktori kubethor-frontend :
```
 cd ../kubethor-frontend
```
- Instal dependensi:
```
npm install
```
  Jika ada penggunaan kesalahan:
```
npm config set registry https://registry.npmjs.org/
npm install --verbose
```
- Bangun Aplikasi React:
```
npm run build
```
- Untuk menjalankan aplikasi bereaksi di lingkungan pengembangan:
```
npm run dev
```
Pengaturan Backend:
- Arahkan ke direktori kubethor-backend :
```
 cd ../kubethor-backend
```
- Salin Folder Dist [React App Build to Backend] dari kubethor-frontend ke direktori kubethor-backend :
```
cp -r ../kubethor-frontend/dist/ ../kubethor-backend
```
- Unduh semua dependensi:
```
go mod download
```
- Bangun Aplikasi GO:
```
go build -o kubethor-backend
```

Menjalankan aplikasi

Mulailah backend:
- Arahkan ke direktori backend :
```
 cd kubethor-backend
```
- Jalankan aplikasi Go:
```
./kubethor-backend
```
Aplikasi Backend akan berjalan di http://localhost:8080 .
Mulai frontend:
- Arahkan ke Direktori frontend :
```
 cd ../kubethor-frontend
```
- Mulai server pengembangan:
```
npm run dev
```
Aplikasi Frontend akan berjalan di http://localhost:3000 .

Menjalankan aplikasi sebagai mandiri

Bangun aplikasi mandiri:
- Arahkan ke direktori kubethor-backend :
```
 cd kubethor-backend
```
- Jalankan skrip build.sh :
```
./build.sh
```
Catatan: Skrip build.sh membangun aplikasi React, menyalinnya ke folder kubethor-backend , dan kemudian menanamkannya ke GO Executable. Single yang dapat dieksekusi ini dapat dijalankan untuk melayani seluruh aplikasi di http://localhost:8080 tanpa perlu menjalankan frontend secara terpisah.
Jalankan aplikasi mandiri:
- Setelah menjalankan build.sh , mulai aplikasi:
```
./kubethor-backend
```
Aplikasi akan tersedia di http://localhost:8080 .

Bangun dan Jalankan Gambar Docker

Karena gambar Docker juga merupakan jenis aplikasi mandiri, pastikan Anda menyalin folder dist terbaru ke folder kubethor-backend . Jika Anda membangun gambar untuk digunakan di server host, pastikan untuk mengubah API_BASE_URL dan API_WS_URL di kubethor-frontend dengan nama host Anda. Script build.sh membangun aplikasi React, menyalinnya ke folder kubethor-backend . Adalah baik untuk menjalankan build.sh sebelum membangun gambar Docker Anda.

Bangun gambar Docker:
- Arahkan ke direktori kubethor-backend :
```
 cd kubethor-backend
```
- Bangun gambar Docker:
```
docker build --no-cache -t kubethor-backend .
```
Jalankan wadah Docker:
- Jalankan wadah Docker:
```
docker run -p 8080:8080 kubethor-backend
```

Push ke Docker Registry:

Masuk ke Docker Registry Anda:
```
docker login YOUR_REGISTERY.com
```

Tandai gambar Docker:

docker tag kubethor-backend:latest YOUR_REGISTERY.com/kubethor/kubethor-backend:latest

Dorong gambar Docker:

docker push YOUR_REGISTERY.com/kubethor/kubethor-backend

Penempatan Kubernetes

Deploy ke kluster Kubernetes:
- Arahkan ke direktori kubethor-backend :
```
 cd kubethor-backend
```
- Pastikan Anda memiliki cluster Kubernetes yang berjalan dan kubectl dikonfigurasi untuk berinteraksi dengannya.
- Perbarui file k8s.yaml di direktori kubethor-backend dengan tautan gambar Docker Anda dan URL host :
- Terapkan konfigurasi Kubernetes:
```
kubectl apply -f k8s.yaml -n my-namespace
```
- Setelah penempatan yang berhasil, buka URL tuan rumah Anda
Catatan: Pastikan Anda memiliki izin yang diperlukan untuk menggunakan sumber daya ke kluster Kubernetes Anda. File k8s.yaml berisi konfigurasi untuk menyebarkan aplikasi Kubethor, termasuk penyebaran, layanan, ingress, dan autoscaler pod horizontal dan sumber daya lain yang diperlukan untuk aplikasi dijalankan di lingkungan Kubernetes.