GiteaAdmin/go-lcg
1
0
Fork 0
mirror of https://github.com/Direct-Dev-Ru/go-lcg.git synced 2025-11-16 01:29:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Исправления в ветке main

Browse Source
This commit is contained in:
Кузнецов Антон (aka Direct-dev.ru)
2025-11-09 12:47:23 +06:00
parent 01488edbee
commit c975e00c50
14 changed files with 288 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
Dockerfiles/OllamaServer/Dockerfile
View File

@@ -1,74 +1,79 @@
# Multi-stage build для LCG с Ollama
FROM golang:1.24.6-alpine3.22 AS builder
# Используем готовый образ Ollama
FROM localhost/ollama_packed:latest
WORKDIR /build
# Устанавливаем bash если его нет (базовый образ ollama может быть на разных дистрибутивах)
RUN if ! command -v bash >/dev/null 2>&1; then \
if command -v apk >/dev/null 2>&1; then \
apk add --no-cache bash; \
elif command -v apt-get >/dev/null 2>&1; then \
apt-get update && apt-get install -y --no-install-recommends bash && rm -rf /var/lib/apt/lists/*; \
fi; \
fi
# Копируем файлы зависимостей
COPY go.mod go.sum ./
RUN go mod download
# Копируем исходный код
COPY . .
# Собираем бинарник
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-w -s -buildid=" -trimpath -o /build/lcg .
# Финальный образ с Ollama
FROM alpine:3.22
# Устанавливаем необходимые пакеты
RUN apk add --no-cache \
curl \
ca-certificates \
bash \
&& rm -rf /var/cache/apk/*
# Устанавливаем Ollama 0.9.5 (поддержка разных архитектур)
# Определяем архитектуру для копирования правильного бинарника
ARG TARGETARCH
RUN case ${TARGETARCH} in \
amd64) OLLAMA_ARCH=amd64 ;; \
arm64) OLLAMA_ARCH=arm64 ;; \
arm) OLLAMA_ARCH=arm64 ;; \
*) echo "Unsupported architecture: ${TARGETARCH}" && exit 1 ;; \
ARG TARGETOS=linux
# Копируем папку dist с бинарниками
# Структура: dist/lcg_linux_amd64_v1/lcg_* или dist/lcg_linux_arm64_v8.0/lcg_*
COPY dist/ /tmp/dist/
# Выбираем правильный бинарник в зависимости от архитектуры
# Если TARGETARCH не установлен, определяем архитектуру через uname
RUN ARCH="${TARGETARCH:-$(uname -m)}" && \
case "${ARCH}" in \
amd64|x86_64) \
BIN_FILE=$(find /tmp/dist/lcg_linux_amd64_v* -name "lcg_*" -type f 2>/dev/null | head -1) && \
if [ -n "$BIN_FILE" ]; then \
cp "$BIN_FILE" /usr/local/bin/lcg && \
echo "Установлен бинарник для amd64: $BIN_FILE"; \
else \
echo "Бинарник для amd64 не найден в /tmp/dist/" && exit 1; \
fi ;; \
arm64|aarch64|arm) \
BIN_FILE=$(find /tmp/dist/lcg_linux_arm64_v* -name "lcg_*" -type f 2>/dev/null | head -1) && \
if [ -n "$BIN_FILE" ]; then \
cp "$BIN_FILE" /usr/local/bin/lcg && \
echo "Установлен бинарник для arm64: $BIN_FILE"; \
else \
echo "Бинарник для arm64 не найден в /tmp/dist/" && exit 1; \
fi ;; \
*) \
echo "Unsupported architecture: ${ARCH}" && \
echo "Доступные бинарники:" && \
find /tmp/dist -name "lcg_*" -type f 2>/dev/null && \
exit 1 ;; \
esac && \
curl -L https://github.com/ollama/ollama/releases/download/v0.9.5/ollama-linux-${OLLAMA_ARCH} -o /usr/local/bin/ollama \
&& chmod +x /usr/local/bin/ollama
# Создаем пользователя для запуска сервисов
RUN addgroup -g 1000 ollama && \
adduser -D -u 1000 -G ollama ollama && \
mkdir -p /home/ollama/.ollama && \
chown -R ollama:ollama /home/ollama
# Копируем бинарник lcg
COPY --from=builder /build/lcg /usr/local/bin/lcg
RUN chmod +x /usr/local/bin/lcg
chmod +x /usr/local/bin/lcg && \
rm -rf /tmp/dist && \
(lcg --version || echo "Бинарник lcg установлен")
# Копируем entrypoint скрипт
COPY --chmod=755 Dockerfiles/OllamaServer/entrypoint.sh /entrypoint.sh
# Создаем директории для данных
RUN mkdir -p /app/data/results /app/data/prompts /app/data/config \
&& chown -R ollama:ollama /app/data
# Создаем директории для данных LCG
# В базовом образе ollama уже есть пользователь ollama
RUN mkdir -p /app/data/results /app/data/prompts /app/data/config
# Устанавливаем права доступа (пользователь ollama должен существовать в базовом образе)
RUN chown -R ollama:ollama /app/data 2>/dev/null || \
(chown -R 1000:1000 /app/data 2>/dev/null || true)
# Настройки по умолчанию
ENV LCG_PROVIDER=ollama
ENV LCG_HOST=http://127.0.0.1:11434/
ENV LCG_MODEL=codegeex4
ENV LCG_MODEL=qwen2.5-coder:1.5b
ENV LCG_RESULT_FOLDER=/app/data/results
ENV LCG_PROMPT_FOLDER=/app/data/prompts
ENV LCG_CONFIG_FOLDER=/app/data/config
ENV LCG_SERVER_HOST=0.0.0.0
ENV LCG_SERVER_PORT=8080
ENV LCG_SERVER_ALLOW_HTTP=true
ENV OLLAMA_HOST=0.0.0.0
ENV OLLAMA_PORT=11434
# ENV LCG_SERVER_ALLOW_HTTP=true
# ENV OLLAMA_HOST=127.0.0.1
# ENV OLLAMA_PORT=11434
# Expose порты
EXPOSE 8080 11434
# Переключаемся на пользователя ollama
USER ollama
EXPOSE 8080
WORKDIR /home/ollama

17
Dockerfiles/OllamaServer/Makefile
View File

@@ -23,14 +23,27 @@ help: ## Показать справку
@echo " make podman-compose-up - Запустить через podman-compose"
@echo " make podman-compose-down - Остановить podman-compose"
build: ## Собрать Docker образ
build: ## Собрать Docker образ (требует собранных бинарников в dist/)
@echo "⚠️ Убедитесь, что бинарники собраны: goreleaser build --snapshot --clean"
docker build -f $(DOCKERFILE) -t $(IMAGE_NAME):$(IMAGE_TAG) $(CONTEXT)
@echo "Образ $(IMAGE_NAME):$(IMAGE_TAG) успешно собран"
build-podman: ## Собрать Podman образ
build-podman: ## Собрать Podman образ (требует собранных бинарников в dist/)
@echo "⚠️ Убедитесь, что бинарники собраны: goreleaser build --snapshot --clean"
podman build -f $(DOCKERFILE) -t $(IMAGE_NAME):$(IMAGE_TAG) $(CONTEXT)
@echo "Образ $(IMAGE_NAME):$(IMAGE_TAG) успешно собран"
build-binaries: ## Собрать бинарники перед сборкой образа
@echo "Сборка бинарников..."
cd $(CONTEXT) && goreleaser build --snapshot --clean
@echo "Бинарники собраны в $(CONTEXT)/dist/"
build-all: build-binaries build ## Собрать бинарники и Docker образ
@echo "✅ Все готово!"
build-all-podman: build-binaries build-podman ## Собрать бинарники и Podman образ
@echo "✅ Все готово!"
run: ## Запустить контейнер (Docker)
docker run -d \
--name $(CONTAINER_NAME) \

23
Dockerfiles/OllamaServer/QUICKSTART.md
View File

@@ -4,7 +4,17 @@
1. Убедитесь, что у вас установлен Docker или Podman
2. Клонируйте репозиторий (если еще не сделали)
3. Перейдите в папку с Dockerfile
3. Соберите бинарники (требуется перед сборкой образа)
```bash
# Из корня проекта
goreleaser build --snapshot --clean
# Или используйте скрипт
./deploy/4.build-binaries.sh v2.0.15
```
4. Перейдите в папку с Dockerfile
```bash
cd Dockerfiles/OllamaServer
@@ -15,14 +25,16 @@ cd Dockerfiles/OllamaServer
### Вариант 1: Docker Compose (рекомендуется)
```bash
# Важно: убедитесь, что бинарники собраны в ../../dist/
docker-compose up -d
```
### Вариант 2: Ручная сборка и запуск
```bash
# Сборка образа
docker build -f Dockerfile -t lcg-ollama:latest ../..
# Сборка образа (контекст должен быть корень проекта)
cd ../.. # Переходим в корень проекта
docker build -f Dockerfiles/OllamaServer/Dockerfile -t lcg-ollama:latest .
# Запуск контейнера
docker run -d \
@@ -45,8 +57,9 @@ podman-compose -f podman-compose.yml up -d
### Вариант 2: Ручная сборка и запуск
```bash
# Сборка образа
podman build -f Dockerfile -t lcg-ollama:latest ../..
# Сборка образа (контекст должен быть корень проекта)
cd ../.. # Переходим в корень проекта
podman build -f Dockerfiles/OllamaServer/Dockerfile -t lcg-ollama:latest .
# Запуск контейнера
podman run -d \

95
Dockerfiles/OllamaServer/README.md
View File

@@ -7,62 +7,111 @@
## 📋 Описание
Контейнер автоматически запускает:
1. **Ollama сервер** (v0.9.5) на порту 11434
2. **LCG веб-сервер** на порту 8080
1 **Ollama сервер** (v0.9.5) на порту 11434
2 **LCG веб-сервер** на порту 8080
Ollama используется как провайдер LLM для генерации Linux команд.
## 🚀 Быстрый старт
### Предварительные требования
Перед сборкой Docker образа необходимо собрать бинарники:
```bash
# Из корня проекта
# Используйте goreleaser для сборки бинарников
goreleaser build --snapshot --clean
# Или используйте скрипт сборки
./deploy/4.build-binaries.sh v2.0.15
```
Убедитесь, что в папке `dist/` есть бинарники:
- `dist/lcg_linux_amd64_v1/lcg_*` для amd64
- `dist/lcg_linux_arm64_v8.0/lcg_*` для arm64
### Сборка образа
#### Docker
```bash
# Из корня проекта
# Из корня проекта (важно: контекст должен быть корень проекта)
docker build -f Dockerfiles/OllamaServer/Dockerfile -t lcg-ollama:latest .
# Или с указанием архитектуры
docker buildx build \
--platform linux/amd64,linux/arm64 \
-f Dockerfiles/OllamaServer/Dockerfile \
-t lcg-ollama:latest .
```
#### Podman
```bash
# Из корня проекта
podman build -f Dockerfiles/OllamaServer/Dockerfile -t lcg-ollama:latest .
# Или с указанием архитектуры
podman build \
--platform linux/amd64,linux/arm64 \
-f Dockerfiles/OllamaServer/Dockerfile \
-t lcg-ollama:latest .
```
### Запуск контейнера
#### Docker
#### Docker run
```bash
docker run -d \
--name lcg-ollama \
-p 8080:8080 \
-p 11434:11434 \
-p 8080:8080 \
lcg-ollama:latest
ollama serve
```
#### Podman
#### Podman run
```bash
podman run -d \
--name lcg-ollama \
-p 8080:8080 \
-p 11434:11434 \
lcg-ollama:latest
-p 8989:8080 \
--restart always \
lcg-ollama:latest \
ollama serve
```
когда контейнер запущен на удаленном хосте - можете воспользоваться консольными возможностями утилиты lcg следующим образом
``` bash
ssh user@[host_where_contaier_running] 'podman exec -it $(podman ps -q --filter \"ancestor=localhost/lcg-ollama:latest\") lcg [your query]
```
``` bash
ssh user@[host_where_contaier_running] 'podman exec -it $(podman ps -q --filter "ancestor=localhost/lcg-ollama:latest") /bin/sh -c "export LCG_MODEL=qwen3:0.6b && lcg config --full"'
### Использование docker-compose / podman-compose
#### Docker Compose
```bash
cd Dockerfiles/OllamaServer
docker-compose up -d
```
#### Podman Compose
```bash
cd Dockerfiles/OllamaServer
podman-compose -f podman-compose.yml up -d
```
Или используйте встроенную поддержку Podman:
```bash
cd Dockerfiles/OllamaServer
podman play kube podman-compose.yml
@@ -72,8 +121,8 @@ podman play kube podman-compose.yml
После запуска контейнера доступны:
- **LCG веб-интерфейс**: http://localhost:8080
- **Ollama API**: http://localhost:11434
- **LCG веб-интерфейс**: <http://localhost:8080>
- **Ollama API**: <http://localhost:11434>
## ⚙️ Переменные окружения
@@ -278,7 +327,8 @@ podman logs -f lcg-ollama
### Просмотр логов
#### Docker
#### Docker log
```bash
# Логи контейнера
docker logs lcg-ollama
@@ -287,7 +337,8 @@ docker logs lcg-ollama
docker logs -f lcg-ollama
```
#### Podman
#### Podman log
```bash
# Логи контейнера
podman logs lcg-ollama
@@ -298,24 +349,28 @@ podman logs -f lcg-ollama
### Подключение к контейнеру
#### Docker
#### Docker exec
```bash
docker exec -it lcg-ollama sh
```
#### Podman
#### Podman exec
```bash
podman exec -it lcg-ollama sh
```
### Проверка процессов
#### Docker
#### Docker check ps
```bash
docker exec lcg-ollama ps aux
```
#### Podman
#### Podman check ps
```bash
podman exec lcg-ollama ps aux
```
@@ -325,6 +380,7 @@ podman exec lcg-ollama ps aux
### Рекомендации для продакшена
1. **Используйте аутентификацию**:
```bash
-e LCG_SERVER_REQUIRE_AUTH=true
-e LCG_SERVER_PASSWORD=strong_password
@@ -339,6 +395,7 @@ podman exec lcg-ollama ps aux
- Используйте SSL сертификаты
4. **Ограничьте ресурсы**:
```bash
docker run -d \
--name lcg-ollama \
@@ -390,8 +447,8 @@ docker-compose up -d
## ❓ Поддержка
При возникновении проблем:
1. Проверьте логи: `docker logs lcg-ollama`
2. Проверьте переменные окружения
3. Убедитесь, что порты не заняты
4. Проверьте, что модели загружены в Ollama

48
Dockerfiles/OllamaServer/STRUCTURE.md
View File

@@ -19,14 +19,21 @@ Dockerfiles/OllamaServer/
## Описание файлов
### Dockerfile
Multi-stage Dockerfile, который:
1. Собирает бинарник LCG из исходного кода
2. Устанавливает Ollama 0.9.5
3. Создает пользователя ollama
4. Настраивает рабочее окружение
Dockerfile, который:
1. Использует готовый образ `ollama/ollama:0.9.5` как базовый
2. Копирует предварительно собранный бинарник LCG из папки `dist/`
3. Выбирает правильный бинарник в зависимости от архитектуры (amd64/arm64)
4. Устанавливает entrypoint.sh для запуска обоих сервисов
5. Настраивает рабочее окружение и переменные окружения
**Важно**: Перед сборкой образа необходимо собрать бинарники с помощью `goreleaser build --snapshot --clean`
### entrypoint.sh
Скрипт запуска, который:
1. Запускает Ollama сервер в фоне
2. Ожидает готовности Ollama API
3. Запускает LCG сервер в фоне
@@ -34,21 +41,27 @@ Multi-stage Dockerfile, который:
5. Корректно обрабатывает сигналы завершения
### docker-compose.yml / podman-compose.yml
Конфигурация для запуска через compose:
- Настройки портов
- Переменные окружения
- Volumes для персистентного хранения
- Healthcheck
### Makefile
Удобные команды для:
- Сборки образа
- Запуска/остановки контейнера
- Просмотра логов
- Работы с compose
### README.md
Полная документация с:
- Описанием функциональности
- Инструкциями по установке
- Настройками переменных окружения
@@ -56,6 +69,7 @@ Multi-stage Dockerfile, который:
- Решением проблем
### QUICKSTART.md
Краткое руководство для быстрого старта.
## Порты
@@ -73,6 +87,7 @@ Multi-stage Dockerfile, который:
## Переменные окружения
Основные переменные (см. README.md для полного списка):
- `LCG_PROVIDER=ollama`
- `LCG_HOST=http://127.0.0.1:11434/`
- `LCG_MODEL=codegeex4`
@@ -81,31 +96,48 @@ Multi-stage Dockerfile, который:
## Запуск
### Предварительная подготовка
Перед сборкой образа необходимо собрать бинарники:
```bash
# Из корня проекта
goreleaser build --snapshot --clean
```
Убедитесь, что в папке `dist/` есть бинарники для нужных архитектур.
### Docker
```bash
cd Dockerfiles/OllamaServer
docker-compose up -d
```
### Podman
```bash
cd Dockerfiles/OllamaServer
podman-compose -f podman-compose.yml up -d
```
### Make
```bash
cd Dockerfiles/OllamaServer
make compose-up
# или
make build-all # Собрать бинарники и Docker образ
make compose-up # Запустить через docker-compose
# Или для Podman
make build-all-podman
make podman-compose-up
```
## Архитектура
Контейнер запускает два сервиса:
1. **Ollama** (порт 11434) - LLM сервер
2. **LCG** (порт 8080) - Веб-интерфейс и API
Оба сервиса работают в одном контейнере и общаются через localhost.

3
Dockerfiles/OllamaServer/docker-compose.yml
View File

@@ -3,8 +3,9 @@ version: '3.8'
services:
lcg-ollama:
build:
context: ../..
context: ../.. # Контекст сборки - корень проекта (для доступа к dist/)
dockerfile: Dockerfiles/OllamaServer/Dockerfile
# TARGETARCH определяется автоматически Docker на основе платформы хоста
container_name: lcg-ollama
ports:
- "8080:8080" # LCG веб-сервер

80
Dockerfiles/OllamaServer/entrypoint.sh
View File

@@ -32,10 +32,6 @@ cleanup() {
kill $LCG_PID 2>/dev/null || true
wait $LCG_PID 2>/dev/null || true
fi
if [ ! -z "$OLLAMA_PID" ]; then
kill $OLLAMA_PID 2>/dev/null || true
wait $OLLAMA_PID 2>/dev/null || true
fi
log "Сервисы остановлены"
exit 0
}
@@ -48,11 +44,6 @@ if [ ! -f /usr/local/bin/lcg ]; then
exit 1
fi
# Проверка наличия Ollama
if [ ! -f /usr/local/bin/ollama ]; then
error "Ollama не найден в /usr/local/bin/ollama"
exit 1
fi
# Создаем необходимые директории
mkdir -p "${LCG_RESULT_FOLDER:-/app/data/results}"
@@ -60,14 +51,14 @@ mkdir -p "${LCG_PROMPT_FOLDER:-/app/data/prompts}"
mkdir -p "${LCG_CONFIG_FOLDER:-/app/data/config}"
# Настройка переменных окружения для Ollama
export OLLAMA_HOST="${OLLAMA_HOST:-0.0.0.0}"
export OLLAMA_HOST="${OLLAMA_HOST:-127.0.0.1}"
export OLLAMA_PORT="${OLLAMA_PORT:-11434}"
export OLLAMA_ORIGINS="*"
# Настройка переменных окружения для LCG
export LCG_PROVIDER="${LCG_PROVIDER:-ollama}"
export LCG_HOST="${LCG_HOST:-http://127.0.0.1:11434/}"
export LCG_MODEL="${LCG_MODEL:-codegeex4}"
export LCG_MODEL="${LCG_MODEL:-qwen2.5-coder:1.5b}"
export LCG_RESULT_FOLDER="${LCG_RESULT_FOLDER:-/app/data/results}"
export LCG_PROMPT_FOLDER="${LCG_PROMPT_FOLDER:-/app/data/prompts}"
export LCG_CONFIG_FOLDER="${LCG_CONFIG_FOLDER:-/app/data/config}"
@@ -85,39 +76,7 @@ info "LCG Server: http://${LCG_SERVER_HOST}:${LCG_SERVER_PORT}"
info "Ollama Host: $OLLAMA_HOST:$OLLAMA_PORT"
log "=========================================="
# Запускаем Ollama сервер в фоне
log "Запуск Ollama сервера..."
/usr/local/bin/ollama serve &
OLLAMA_PID=$!
# Ждем, пока Ollama запустится
log "Ожидание запуска Ollama сервера..."
sleep 5
# Проверяем, что Ollama запущен
if ! kill -0 $OLLAMA_PID 2>/dev/null; then
error "Ollama сервер не запустился"
exit 1
fi
# Проверяем доступность Ollama API
max_attempts=30
attempt=0
while [ $attempt -lt $max_attempts ]; do
# Проверяем через localhost, так как OLLAMA_HOST может быть 0.0.0.0
if curl -s -f "http://127.0.0.1:${OLLAMA_PORT}/api/tags" > /dev/null 2>&1; then
log "Ollama сервер готов!"
break
fi
attempt=$((attempt + 1))
if [ $attempt -eq $max_attempts ]; then
error "Ollama сервер не отвечает после $max_attempts попыток"
exit 1
fi
sleep 1
done
# Запускаем LCG сервер в фоне
log "Запуск LCG сервера..."
/usr/local/bin/lcg serve \
--host "${LCG_SERVER_HOST}" \
@@ -135,37 +94,6 @@ if ! kill -0 $LCG_PID 2>/dev/null; then
fi
log "LCG сервер запущен на http://${LCG_SERVER_HOST}:${LCG_SERVER_PORT}"
log "Ollama сервер доступен на http://${OLLAMA_HOST}:${OLLAMA_PORT}"
log "=========================================="
log "Сервисы запущены и готовы к работе!"
log "=========================================="
# Функция для проверки здоровья процессов
health_check() {
while true; do
# Проверяем Ollama
if ! kill -0 $OLLAMA_PID 2>/dev/null; then
error "Ollama процесс завершился неожиданно"
kill $LCG_PID 2>/dev/null || true
exit 1
fi
# Проверяем LCG
if ! kill -0 $LCG_PID 2>/dev/null; then
error "LCG процесс завершился неожиданно"
kill $OLLAMA_PID 2>/dev/null || true
exit 1
fi
sleep 10
done
}
# Запускаем проверку здоровья в фоне
health_check &
HEALTH_CHECK_PID=$!
# Ждем завершения процессов
wait $LCG_PID $OLLAMA_PID
kill $HEALTH_CHECK_PID 2>/dev/null || true
# Запускаем переданные аргументы
exec "$@"