Download de kubethor - Download de código fonte de kubethor

kubethor

Outro código-fonte

1.0.0

Baixar

Kubethor

Kubethor é um aplicativo da Web de gerenciamento de Kubernetes criado usando Go e React. Ele fornece uma interface amigável para gerenciar e monitorar os clusters Kubernetes com eficiência.

Índice

Características
Construído com
Imagem do Docker
Estrutura de pastas
Começando
- Pré -requisitos
- Instalação
- Executando o aplicativo
- Executando o aplicativo como independente
- Construa e execute a imagem do Docker
- Implantação de Kubernetes
Contribuindo
Licença
Contato

Características

Gerenciamento de cluster: gerencie facilmente vários clusters Kubernetes.
Monitoramento de Recursos: Visualize e monitore recursos Kubernetes, como vagens, serviços, implantações, etc.
Agregação de log: log centralizado para visualizar logs de diferentes contêineres.
Editor de recursos: edite os recursos da Kubernetes diretamente da interface da web.
Excluir recursos: exclua os recursos da Kubernetes com facilidade.
Visualização de detalhes de recursos: Veja informações detalhadas sobre os recursos da Kubernetes.
Alterne entre os espaços para nome: alterne perfeitamente entre diferentes espaços para gerenciar recursos.

Construído com

Front-end
- REACT: Uma biblioteca JavaScript para criar interfaces de usuário.
- Flowbite: componentes da interface do usuário construídos com CSS do Tailwind.
Back -end
- GO (GOLANG): A linguagem de programação usada para o back -end.
- Kubernetes Cliente: Biblioteca Client para interagir com clusters Kubernetes.

Imagem do Docker

Puxe a imagem do Docker: docker pull kubethor/kubethor
Execute o contêiner do Docker: docker run -p 8080:8080 kubethor/kubethor
Acesse o aplicativo via http: // localhost: 8080 no seu navegador.

Para mais detalhes sobre a imagem do Docker, visite a página Kubethor Docker Hub.

Estrutura de pastas

Aqui está uma visão geral da estrutura do projeto:

 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/ : contém ativos estáticos, como imagens, fontes e o arquivo index.html, que serve como ponto de entrada para o aplicativo React.
- src/ : o código -fonte principal para o aplicativo REACT.
  - assets/ : Contém ativos de front -end, como imagens, ícones e estilos.
  - components/ : contém componentes e ganchos reutilizáveis de reação usados em todo o aplicativo.
  - layouts/ : contém componentes de layout que definem a estrutura dos layouts de página comuns.
  - pages/ : contém componentes de página que representam vistas ou rotas diferentes no aplicativo.
  - App.jsx : o componente principal do aplicativo que configura o roteamento e renderiza o layout principal do aplicativo.
- package.json : define as dependências e scripts do Node.js para o projeto front -end.
kubethor-backend/
- main.go : O arquivo de aplicativo GO principal que inicializa e executa o servidor de back -end.
- go.mod : define as dependências do módulo GO para o projeto de back -end.
- api/ : Contém as implementações da API que o servidor de back -end expõe.
- config/ : Contém arquivos de configuração para diferentes ambientes e configurações usadas pelo back -end.
- build.sh : Um script de construção usado para compilar o aplicativo de back -end independente e gerenciar o processo de construção.
- k8s.yaml : O arquivo de implantação do Kubernetes que especifica como implantar o aplicativo de back -end em um cluster Kubernetes.
- Dockerfile : o arquivo de construção do docker usado para criar uma imagem do docker para o aplicativo de back -end.
- dist/ : Um diretório em que a construção do React Compiled é copiada da pasta front -end após o processo de construção. Isso permite que o back -end sirva o aplicativo front -end.

Começando

Pré -requisitos

GO (versão 1.16 ou superior)
Node.js (versão 18.x ou superior)
Docker (opcional, para implantação de contêiner)
Kubectl (para interagir com os clusters de Kubernetes)

Vídeo:

Instalação

Clone o repositório:

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

Configuração do front -end:
- Navegue até o diretório kubethor-frontend :
```
 cd ../kubethor-frontend
```
- Instale as dependências:
```
npm install
```
  Se houver algum erro usar:
```
npm config set registry https://registry.npmjs.org/
npm install --verbose
```
- Crie o aplicativo React:
```
npm run build
```
- Para executar o aplicativo React no ambiente de desenvolvimento:
```
npm run dev
```
Configuração de back -end:
- Navegue até o diretório kubethor-backend :
```
 cd ../kubethor-backend
```
- Copie a pasta Dist Dist [Aplicativo React Build no back-end] de kubethor-frontend no diretório kubethor-backend :
```
cp -r ../kubethor-frontend/dist/ ../kubethor-backend
```
- Baixe todas as dependências:
```
go mod download
```
- Construa o aplicativo Go:
```
go build -o kubethor-backend
```

Executando o aplicativo

Comece o back -end:
- Navegue até o diretório backend :
```
 cd kubethor-backend
```
- Execute o aplicativo Go:
```
./kubethor-backend
```
O aplicativo de back -end será executado em http://localhost:8080 .
Comece o front -end:
- Navegue até o diretório frontend :
```
 cd ../kubethor-frontend
```
- Inicie o servidor de desenvolvimento:
```
npm run dev
```
O aplicativo front -end será executado em http://localhost:3000 .

Executando o aplicativo como independente

Construa o aplicativo independente:
- Navegue até o diretório kubethor-backend :
```
 cd kubethor-backend
```
- Execute o script build.sh :
```
./build.sh
```
Nota: O script build.sh cria o aplicativo React, copia-o para a pasta kubethor-backend e o incorpora no executável Go. Este único executável pode ser executado para servir o aplicativo inteiro no http://localhost:8080 sem precisar executar o front -end separadamente.
Execute o aplicativo independente:
- Depois de executar build.sh , inicie o aplicativo:
```
./kubethor-backend
```
O aplicativo estará disponível em http://localhost:8080 .

Construa e execute a imagem do Docker

Como a imagem do Docker também é um tipo de aplicativo independente, verifique se você copia a pasta dist mais recente na pasta kubethor-backend . Se você estiver criando a imagem para implantar em um servidor host, altere a API_BASE_URL e API_WS_URL em kubethor-frontend com o nome do seu host. O script build.sh cria o aplicativo React, copia-o para a pasta kubethor-backend . É bom executar build.sh antes de criar sua imagem do Docker.

Construa a imagem do Docker:
- Navegue até o diretório kubethor-backend :
```
 cd kubethor-backend
```
- Construa a imagem do Docker:
```
docker build --no-cache -t kubethor-backend .
```
Execute o contêiner do docker:
- Execute o contêiner do docker:
```
docker run -p 8080:8080 kubethor-backend
```

Push to Docker Registry:

Faça login no seu registro do Docker:
```
docker login YOUR_REGISTERY.com
```

Marque a imagem do docker:

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

Empurre a imagem do Docker:

docker push YOUR_REGISTERY.com/kubethor/kubethor-backend

Implantação de Kubernetes

Implante no cluster de Kubernetes:
- Navegue até o diretório kubethor-backend :
```
 cd kubethor-backend
```
- Certifique -se de ter um cluster Kubernetes em execução e kubectl configurado para interagir com ele.
- Atualize o arquivo k8s.yaml no diretório kubethor-backend com o link da imagem do Docker e o URL do host :
- Aplique a configuração do Kubernetes:
```
kubectl apply -f k8s.yaml -n my-namespace
```
- Após a implantação bem -sucedida, vá para o URL do seu host
NOTA: Verifique se você possui as permissões necessárias para implantar recursos no seu cluster Kubernetes. O arquivo k8s.yaml contém a configuração para implantar o aplicativo Kubethor, incluindo implantação, serviço, entrada e pods de pods horizontal e outros recursos necessários para que o aplicativo seja executado em um ambiente de Kubernetes.