Téléchargement kubethor - Téléchargement du code source kubethor

kubethor

Autre code source

1.0.0

Télécharger

Kubethor

Kubethor est une application Web de gestion de Kubernetes construite à l'aide de Go and React. Il fournit une interface conviviale pour gérer et surveiller efficacement les clusters Kubernetes.

Table des matières

Caractéristiques
Construit avec
Image docker
Structure de dossier
Commencer
- Condition préalable
- Installation
- Exécution de l'application
- Exécuter l'application en tant que autonome
- Construire et exécuter l'image docker
- Déploiement de Kubernetes
Contributif
Licence
Contact

Caractéristiques

Gestion des cluster: gérez facilement plusieurs clusters Kubernetes.
Surveillance des ressources: visualiser et surveiller les ressources Kubernetes telles que les pods, les services, les déploiements, etc.
Aggrégation de journaux: journalisation centralisée pour afficher les journaux à partir de différents conteneurs.
Éditeur de ressources: modifiez les ressources Kubernetes directement à partir de l'interface Web.
Ressource Supprimer: supprimer facilement les ressources Kubernetes.
Affichage du détail des ressources: Afficher les informations détaillées sur les ressources de Kubernetes.
Communiquez entre les espaces de noms: basculez de manière transparente entre différents espaces de noms pour gérer les ressources.

Construit avec

L'extrémité avant
- React: une bibliothèque JavaScript pour la construction d'interfaces utilisateur.
- FlowBite: composants d'interface utilisateur construits avec CSS de vent arrière.
Backend
- GO (Golang): le langage de programmation utilisé pour le backend.
- Client de Kubernetes: bibliothèque client pour interagir avec les clusters Kubernetes.

Image docker

Tirez l'image docker: docker pull kubethor/kubethor
Exécutez le conteneur Docker: docker run -p 8080:8080 kubethor/kubethor
Accédez à l'application via http: // localhost: 8080 sur votre navigateur.

Pour plus de détails sur l'image Docker, visitez la page Kubethor Docker Hub.

Structure de dossier

Voici un aperçu de la structure du projet:

 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/ : contient des actifs statiques tels que des images, des polices et le fichier index.html qui sert de point d'entrée pour l'application React.
- src/ : Le code source principal de l'application React.
  - assets/ : contient des actifs frontaux tels que des images, des icônes et des styles.
  - components/ : Contient des composants et des crochets réutilisables utilisés dans l'application.
  - layouts/ : contient des composants de disposition qui définissent la structure des dispositions de page communes.
  - pages/ : Contient des composants de page qui représentent différentes vues ou routes dans l'application.
  - App.jsx : le composant d'application principal qui configure le routage et rend la disposition principale de l'application.
- package.json : définit les dépendances et scripts node.js pour le projet Frontend.
kubethor-backend/
- main.go : le fichier d'application principal GO qui initialise et exécute le serveur backend.
- go.mod : définit les dépendances du module GO pour le projet backend.
- api/ : contient les implémentations API que le serveur backend expose.
- config/ : contient des fichiers de configuration pour différents environnements et paramètres utilisés par le backend.
- build.sh : un script de construction utilisé pour compiler l'application backend autonome et gérer le processus de construction.
- k8s.yaml : le fichier de déploiement de Kubernetes qui spécifie comment déployer l'application backend sur un cluster Kubernetes.
- Dockerfile : le fichier docker build utilisé pour créer une image docker pour l'application backend.
- dist/ : Un répertoire où la construction React compilée est copiée à partir du dossier Frontend après le processus de construction. Cela permet au backend de servir l'application Frontend.

Commencer

Condition préalable

GO (version 1.16 ou plus)
Node.js (version 18.x ou supérieur)
Docker (facultatif, pour le déploiement conteneurisé)
kubectl (pour interagir avec les grappes de Kubernetes)

Vidéo:

Installation

Clone le référentiel:

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

Configuration du frontend:
- Accédez au répertoire kubethor-frontend :
```
 cd ../kubethor-frontend
```
- Installez les dépendances:
```
npm install
```
  Si une erreur utilise:
```
npm config set registry https://registry.npmjs.org/
npm install --verbose
```
- Créez l'application React:
```
npm run build
```
- Pour l'exécution de l'application React dans l'environnement de développement:
```
npm run dev
```
Configuration du backend:
- Accédez au répertoire kubethor-backend :
```
 cd ../kubethor-backend
```
- Copier le dossier DIST [REACT App Build to Backend] de kubethor-frontend dans kubethor-backend Directory:
```
cp -r ../kubethor-frontend/dist/ ../kubethor-backend
```
- Téléchargez toutes les dépendances:
```
go mod download
```
- Construisez l'application GO:
```
go build -o kubethor-backend
```

Exécution de l'application

Démarrez le backend:
- Accédez au répertoire backend :
```
 cd kubethor-backend
```
- Exécutez l'application Go:
```
./kubethor-backend
```
L'application backend s'exécutera sur http://localhost:8080 .
Démarrez le frontend:
- Accédez au répertoire frontend :
```
 cd ../kubethor-frontend
```
- Démarrer le serveur de développement:
```
npm run dev
```
L'application Frontend s'exécutera sur http://localhost:3000 .

Exécuter l'application en tant que autonome

Construisez l'application autonome:
- Accédez au répertoire kubethor-backend :
```
 cd kubethor-backend
```
- Exécutez le script build.sh :
```
./build.sh
```
Remarque: le script build.sh construit l'application React, le copie dans le dossier kubethor-backend , puis l'intégre dans l'exécutable Go. Cet exécutable unique peut être exécuté pour servir toute l'application sur http://localhost:8080 sans avoir besoin d'exécuter le frontend séparément.
Exécutez l'application autonome:
- Après avoir exécuté build.sh , démarrez l'application:
```
./kubethor-backend
```
L'application sera disponible sur http://localhost:8080 .

Construire et exécuter l'image docker

Comme l'image Docker est également un type d'application autonome, assurez-vous de copier le dernier dossier dist dans le dossier kubethor-backend . Si vous construisez l'image à déployer sur un serveur hôte, assurez-vous de modifier l' API_BASE_URL et API_WS_URL dans kubethor-frontend avec votre nom d'hôte. Le script build.sh construit l'application React, le copie dans le dossier kubethor-backend . Il est bon d'exécuter build.sh avant de construire votre image Docker.

Construisez l'image Docker:
- Accédez au répertoire kubethor-backend :
```
 cd kubethor-backend
```
- Construisez l'image Docker:
```
docker build --no-cache -t kubethor-backend .
```
Exécutez le conteneur Docker:
- Exécutez le conteneur Docker:
```
docker run -p 8080:8080 kubethor-backend
```

Push to Docker Registry:

Connectez-vous à votre registre Docker:
```
docker login YOUR_REGISTERY.com
```

Marquez l'image Docker:

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

Poussez l'image Docker:

docker push YOUR_REGISTERY.com/kubethor/kubethor-backend

Déploiement de Kubernetes

Déployer dans le cluster Kubernetes:
- Accédez au répertoire kubethor-backend :
```
 cd kubethor-backend
```
- Assurez-vous que vous avez un cluster Kubernetes en cours d'exécution et kubectl configuré pour interagir avec lui.
- Mettez à jour le fichier k8s.yaml dans le répertoire kubethor-backend avec votre lien d'image Docker et URL de l'hôte :
- Appliquer la configuration de Kubernetes:
```
kubectl apply -f k8s.yaml -n my-namespace
```
- Après un déploiement réussi, accédez à votre URL de votre hôte
Remarque: Assurez-vous que vous disposez des autorisations nécessaires pour déployer des ressources à votre cluster Kubernetes. Le fichier k8s.yaml contient la configuration de déploiement de l'application Kubethor, y compris le déploiement, le service, l'entrée et le POD Horizontal Pod Autoscaler et d'autres ressources nécessaires à l'application pour exécuter dans un environnement Kubernetes.