Descargar kubethor - Descargar el código fuente de kubethor

kubethor

Otro código fuente

1.0.0

Descargar

Kubethor

Kubethor es una aplicación web de administración de Kubernetes creada con GO y React. Proporciona una interfaz fácil de usar para administrar y monitorear los grupos de Kubernetes de manera eficiente.

Tabla de contenido

Características
Construido con
Imagen de Docker
Estructura de carpetas
Empezando
- Requisitos previos
- Instalación
- Ejecutando la aplicación
- Ejecutando la aplicación como independiente
- Imagen de Docker construyendo y ejecutando
- Implementación de Kubernetes
Que contribuye
Licencia
Contacto

Características

Gestión de clúster: gestione fácilmente múltiples grupos de Kubernetes.
Monitoreo de recursos: visualice y monitoree los recursos de Kubernetes como vainas, servicios, implementaciones, etc.
Agregación de registro: registro centralizado para ver registros de diferentes contenedores.
Editor de recursos: edite los recursos de Kubernetes directamente desde la interfaz web.
Eliminar recursos: eliminar los recursos de Kubernetes con facilidad.
Vista de detalles de recursos: Ver información detallada sobre los recursos de Kubernetes.
Cambie entre espacios de nombres: cambie sin problemas entre diferentes espacios de nombres para administrar los recursos.

Construido con

Interfaz
- React: una biblioteca JavaScript para construir interfaces de usuario.
- FlowBite: componentes de UI construidos con CSS de viento de cola.
Backend
- Go (Golang): el lenguaje de programación utilizado para el backend.
- Cliente de Kubernetes: Biblioteca de clientes para interactuar con clústeres de Kubernetes.

Imagen de Docker

Tire de la imagen Docker: docker pull kubethor/kubethor
Ejecute el contenedor Docker: docker run -p 8080:8080 kubethor/kubethor
Acceda a la aplicación a través de http: // localhost: 8080 en su navegador.

Para obtener más detalles sobre la imagen de Docker, visite la página Kubethor Docker Hub.

Estructura de carpetas

Aquí hay una descripción general de la estructura del proyecto:

 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/ : contiene activos estáticos como imágenes, fuentes y el archivo index.html que sirve como punto de entrada para la aplicación React.
- src/ : el código fuente principal para la aplicación React.
  - assets/ : contiene activos frontend como imágenes, iconos y estilos.
  - components/ : Contiene componentes y ganchos reaccionados reutilizables utilizados en toda la aplicación.
  - layouts/ : contiene componentes de diseño que definen la estructura de los diseños de página comunes.
  - pages/ : Contiene componentes de página que representan diferentes vistas o rutas en la aplicación.
  - App.jsx : el componente principal de la aplicación que establece el enrutamiento y representa el diseño central de la aplicación.
- package.json : define las dependencias y scripts node.js para el proyecto frontend.
kubethor-backend/
- main.go : el archivo de aplicación GO principal que inicializa y ejecuta el servidor de backend.
- go.mod : Define las dependencias del módulo GO para el proyecto de backend.
- api/ : contiene las implementaciones de API que expone el servidor de backend.
- config/ : contiene archivos de configuración para diferentes entornos y configuraciones utilizados por el backend.
- build.sh : un script de compilación utilizado para compilar la aplicación de backend independiente y administrar el proceso de compilación.
- k8s.yaml : El archivo de implementación de Kubernetes que especifica cómo implementar la aplicación de back -end en un clúster Kubernetes.
- Dockerfile : el archivo de compilación Docker utilizado para crear una imagen Docker para la aplicación de backend.
- dist/ : un directorio donde la compilación React se copia de la carpeta frontend después del proceso de compilación. Esto permite que el backend sirva a la aplicación frontend.

Empezando

Requisitos previos

GO (versión 1.16 o superior)
Node.js (versión 18.x o superior)
Docker (opcional, para la implementación contenederizada)
Kubectl (para interactuar con clústeres de Kubernetes)

Video:

Instalación

Clon el repositorio:

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

Configuración de frontend:
- Navegue al Directorio kubethor-frontend :
```
 cd ../kubethor-frontend
```
- Instale las dependencias:
```
npm install
```
  Si algún error usa:
```
npm config set registry https://registry.npmjs.org/
npm install --verbose
```
- Cree la aplicación React:
```
npm run build
```
- Para ejecutar la aplicación React en entorno de desarrollo:
```
npm run dev
```
Configuración de backend:
- Navegue al Directorio kubethor-backend :
```
 cd ../kubethor-backend
```
- Copiar la carpeta Dist [React App Build para Backend] desde kubethor-frontend en el directorio de kubethor-backend :
```
cp -r ../kubethor-frontend/dist/ ../kubethor-backend
```
- Descargar todas las dependencias:
```
go mod download
```
- Cree la aplicación GO:
```
go build -o kubethor-backend
```

Ejecutando la aplicación

Comience el backend:
- Navegue al directorio backend :
```
 cd kubethor-backend
```
- Ejecute la aplicación GO:
```
./kubethor-backend
```
La aplicación de backend se ejecutará en http://localhost:8080 .
Comience el frontend:
- Navegue al directorio frontend :
```
 cd ../kubethor-frontend
```
- Inicie el servidor de desarrollo:
```
npm run dev
```
La aplicación frontend se ejecutará en http://localhost:3000 .

Ejecutando la aplicación como independiente

Cree la aplicación independiente:
- Navegue al Directorio kubethor-backend :
```
 cd kubethor-backend
```
- Ejecute el script build.sh :
```
./build.sh
```
Nota: El script build.sh construye la aplicación React, la copia en la carpeta kubethor-backend y luego la incrusta en el ejecutable de GO. Este solo ejecutable se puede ejecutar para servir a toda la aplicación en http://localhost:8080 sin necesidad de ejecutar el frontend por separado.
Ejecute la aplicación independiente:
- Después de ejecutar build.sh , inicie la aplicación:
```
./kubethor-backend
```
La aplicación estará disponible en http://localhost:8080 .

Imagen de Docker construyendo y ejecutando

Como la imagen de Docker también es un tipo de aplicación independiente, asegúrese de copiar la última carpeta dist en la carpeta kubethor-backend . Si está creando la imagen para implementar en un servidor host, asegúrese de cambiar el API_BASE_URL y API_WS_URL en kubethor-frontend con su nombre de host. El script build.sh construye la aplicación React, la copia en la carpeta kubethor-backend . Es bueno ejecutar build.sh antes de construir su imagen Docker.

Construye la imagen Docker:
- Navegue al Directorio kubethor-backend :
```
 cd kubethor-backend
```
- Construye la imagen Docker:
```
docker build --no-cache -t kubethor-backend .
```
Ejecute el contenedor Docker:
- Ejecute el contenedor Docker:
```
docker run -p 8080:8080 kubethor-backend
```

Empuje al Registro de Docker:

Inicie sesión en su registro de Docker:
```
docker login YOUR_REGISTERY.com
```

Etiqueta la imagen de Docker:

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

Empuje la imagen de Docker:

docker push YOUR_REGISTERY.com/kubethor/kubethor-backend

Implementación de Kubernetes

Implementar en el clúster de Kubernetes:
- Navegue al Directorio kubethor-backend :
```
 cd kubethor-backend
```
- Asegúrese de tener un clúster Kubernetes en ejecución y kubectl configurado para interactuar con él.
- Actualice el archivo k8s.yaml en el directorio kubethor-backend con su enlace de imagen Docker y URL de host :
- Aplique la configuración de Kubernetes:
```
kubectl apply -f k8s.yaml -n my-namespace
```
- Después de una implementación exitosa, vaya a su URL de anfitrión
Nota: Asegúrese de tener los permisos necesarios para implementar recursos en su clúster Kubernetes. El archivo k8s.yaml contiene la configuración para implementar la aplicación Kubethor, incluida la implementación, el servicio, la entrada y el autoscaler de POD horizontal y otros recursos necesarios para que la aplicación se ejecute en un entorno de Kubernetes.