infra/bgp-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: infra/bgp-server:bind
Branches Tags
infra/bgp-server:main infra/bgp-server:bird infra/bgp-server:frr infra/bgp-server:bind
..
pull from: infra/bgp-server:bird
Branches Tags
infra/bgp-server:bird infra/bgp-server:frr infra/bgp-server:main infra/bgp-server:bind
9 Commits
bind .. bird
Author SHA1 Message Date
denozord c85bb1bd8b a 2025-07-11 19:34:27 +07:00
denozord 935c1ffec3 123 2025-07-11 19:32:02 +07:00
denozord 825255c64a update 2025-07-11 19:24:43 +07:00
denozord 9d07df53d0 update 2025-07-11 19:06:56 +07:00
denozord 8f53e99188 update 2025-07-11 18:46:16 +07:00
denozord af197d8953 Remove obsolete files and scripts related to the BGP server setup, including .gitignore, Dockerfile, and various documentation files. Update docker-compose.yml to streamline the configuration for the FRRouting BGP server. This cleanup enhances project maintainability and focuses on the current implementation. 2025-07-11 18:41:15 +07:00
denozord 58f1405fef Update BGP configuration across multiple files to reflect new IP addresses. Changed router ID and neighbor IP in docker-compose.yml, Dockerfile, frr.conf, and related documentation. Adjusted subnet in network settings and prefixes in data files for consistency. Enhanced scripts to utilize updated environment variables.
Build and Push Docker Image / build (push) Successful in 8m1s
Details
2025-07-11 18:22:16 +07:00
denozord 170553612d Merge branch 'bind'
Build and Push Docker Image / build (push) Successful in 7m58s
Details
2025-07-11 18:06:14 +07:00
denozord e197dae9f7 Переписан BGP сервер на FRR 2025-07-11 18:06:07 +07:00
38 changed files with 3953 additions and 3001 deletions
Expand all files Collapse all files
.gitea/workflows/docker.yml
-32
View File
@@ -1,32 +0,0 @@
name: Build and Push Docker Image
on:
push:
branches:
- main
pull_request:
workflow_dispatch:
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v3
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v2
- name: Login to Private Registry
uses: docker/login-action@v2
with:
registry: git.shts.su
username: ${{ gitea.actor }}
password: ${{ secrets.ACTIONS_PAT }}
- name: Build and push Docker image
uses: docker/build-push-action@v4
with:
context: .
push: true
tags: git.shts.su/infra/bgp-server:latest
.gitignore
-47
View File
@@ -1,47 +0,0 @@
# Logs
logs/
*.log
# Docker
.dockerignore
# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
# Virtual environments
venv/
env/
ENV/
# IDE
.vscode/
.idea/
*.swp
*.swo
# OS
.DS_Store
Thumbs.db
# Temporary files
*.tmp
*.temp
CHANGELOG.md
+65
View File
@@ -0,0 +1,65 @@
# Changelog
Все значимые изменения в проекте BGP Server будут документированы в этом файле.
## [1.0.0] - 2025-01-11
### Добавлено
- Первоначальная версия BGP сервера на базе BIRD
- Поддержка IPv4 и IPv6
- Автоматическая загрузка префиксов из файла
- Система мониторинга BGP сессий
- Скрипт автоматической установки для Ubuntu 24.04
- Поддержка community для префиксов
- Автоматический systemd таймер для загрузки префиксов
- Полная документация и руководства
### Функции
- **BGP Server**: Прием соединений от любых пиров
- **Prefix Management**: Загрузка префиксов из файла с community
- **Monitoring**: Мониторинг BGP сессий и системной статистики
- **Security**: Настройка firewall и ограничение доступа
- **Automation**: Автоматическая загрузка префиксов каждые 5 минут
### Файлы
- `install.sh` - Скрипт установки
- `config/bird.conf` - Конфигурация BIRD IPv4
- `config/bird6.conf` - Конфигурация BIRD IPv6
- `scripts/load_prefixes.py` - Скрипт загрузки префиксов
- `scripts/monitor.py` - Скрипт мониторинга
- `data/prefixes.txt` - Пример файла с префиксами
- `README.md` - Основная документация
- `SETUP.md` - Подробные инструкции по настройке
- `QUICKSTART.md` - Быстрый старт
### Технические детали
- **OS**: Ubuntu 24.04 LTS
- **BGP Daemon**: BIRD 2.x
- **Language**: Python 3.x
- **Protocols**: BGP IPv4/IPv6
- **Port**: 179 (BGP)
---
## Планы на будущее
### Версия 1.1.0
- [ ] Web интерфейс для управления
- [ ] REST API для управления префиксами
- [ ] Поддержка Route Reflector
- [ ] Интеграция с системами мониторинга
- [ ] Поддержка BGP-LS
### Версия 1.2.0
- [ ] Поддержка BGP FlowSpec
- [ ] Автоматическое резервное копирование
- [ ] Расширенная система логирования
- [ ] Поддержка множественных ASN
- [ ] Интеграция с DNS
### Версия 2.0.0
- [ ] Микросервисная архитектура
- [ ] Поддержка Docker контейнеров
- [ ] Kubernetes deployment
- [ ] GraphQL API
- [ ] Real-time уведомления
DEPLOY.md
+293
View File
@@ -0,0 +1,293 @@
# Развертывание BGP сервера на Ubuntu 24.04
## Клонирование репозитория
### 1. Клонирование с веткой bird
```bash
# Клонирование репозитория с веткой bird
git clone -b bird <repository-url> bgp-server
# Переход в директорию проекта
cd bgp-server
```
### 2. Альтернативные способы клонирования
#### Если ветка bird существует:
```bash
# Клонирование с указанием ветки
git clone -b bird https://github.com/username/bgp-server.git
# Или клонирование и переключение на ветку
git clone https://github.com/username/bgp-server.git
cd bgp-server
git checkout bird
```
#### Если нужно создать ветку bird:
```bash
# Клонирование основного репозитория
git clone https://github.com/username/bgp-server.git
cd bgp-server
# Создание и переключение на ветку bird
git checkout -b bird
# Добавление всех файлов
git add .
# Коммит изменений
git commit -m "Initial BGP server implementation"
# Отправка ветки на сервер
git push origin bird
```
### 3. Проверка клонирования
```bash
# Проверка текущей ветки
git branch
# Проверка содержимого
ls -la
# Проверка статуса git
git status
```
## Установка на сервере
### 1. Подготовка системы
```bash
# Обновление системы
sudo apt update && sudo apt upgrade -y
# Установка необходимых пакетов
sudo apt install -y python3 python3-pip git curl wget
```
### 2. Клонирование и установка
```bash
# Клонирование репозитория (замените на ваш URL)
git clone -b bird https://github.com/username/bgp-server.git
cd bgp-server
# Проверка файлов
ls -la
# Сделать скрипт установки исполняемым
chmod +x install.sh
# Запуск установки
sudo ./install.sh
```
### 3. Настройка после установки
```bash
# Настройка IP адреса и ASN
sudo nano /etc/bird/bird.conf
# Измените:
# router id YOUR_SERVER_IP;
# local as YOUR_ASN;
# Настройка префиксов
sudo nano /opt/bgp-server/data/prefixes.txt
# Добавьте ваши префиксы
# Загрузка префиксов
python3 /opt/bgp-server/scripts/load_prefixes.py
# Проверка статуса
python3 /opt/bgp-server/scripts/monitor.py
```
## Примеры команд для разных репозиториев
### GitHub
```bash
git clone -b bird https://github.com/username/bgp-server.git
```
### GitLab
```bash
git clone -b bird https://gitlab.com/username/bgp-server.git
```
### Bitbucket
```bash
git clone -b bird https://bitbucket.org/username/bgp-server.git
```
### SSH (если настроен ключ)
```bash
git clone -b bird [email protected]:username/bgp-server.git
```
## Автоматическое развертывание
### Скрипт автоматического развертывания
Создайте файл `deploy.sh`:
```bash
#!/bin/bash
# Автоматическое развертывание BGP сервера
REPO_URL="https://github.com/username/bgp-server.git"
BRANCH="bird"
INSTALL_DIR="/opt/bgp-server-deploy"
echo "Начинаем развертывание BGP сервера..."
# Создание директории
sudo mkdir -p $INSTALL_DIR
cd $INSTALL_DIR
# Клонирование репозитория
echo "Клонирование репозитория..."
git clone -b $BRANCH $REPO_URL .
# Проверка успешности клонирования
if [ $? -eq 0 ]; then
echo "Репозиторий успешно клонирован"
# Запуск установки
chmod +x install.sh
sudo ./install.sh
else
echo "Ошибка при клонировании репозитория"
exit 1
fi
```
### Использование скрипта развертывания
```bash
# Создание скрипта
nano deploy.sh
# Сделать исполняемым
chmod +x deploy.sh
# Запуск
./deploy.sh
```
## Проверка установки
### 1. Проверка сервисов
```bash
# Статус BIRD сервисов
sudo systemctl status bird bird6
# Проверка портов
sudo netstat -tlnp | grep :179
# Проверка процессов
ps aux | grep bird
```
### 2. Проверка конфигурации
```bash
# Проверка синтаксиса конфигурации
sudo birdc -p /etc/bird/bird.conf
sudo bird6c -p /etc/bird/bird6.conf
# Проверка протоколов
sudo birdc show protocols
```
### 3. Проверка префиксов
```bash
# Загрузка префиксов
python3 /opt/bgp-server/scripts/load_prefixes.py
# Проверка маршрутов
sudo birdc show routes
```
## Troubleshooting
### Проблема: Не удается клонировать репозиторий
```bash
# Проверка подключения к интернету
ping -c 3 github.com
# Проверка git
git --version
# Очистка кэша git
git config --global credential.helper cache
```
### Проблема: Ветка bird не найдена
```bash
# Просмотр доступных веток
git branch -r
# Клонирование без указания ветки
git clone https://github.com/username/bgp-server.git
cd bgp-server
# Создание локальной ветки
git checkout -b bird origin/main
```
### Проблема: Нет прав доступа
```bash
# Настройка SSH ключей (если используете SSH)
ssh-keygen -t rsa -b 4096 -C "[email protected]"
cat ~/.ssh/id_rsa.pub
# Добавьте ключ в настройки GitHub/GitLab
# Или используйте HTTPS с токеном
git clone https://username:[email protected]/username/bgp-server.git
```
## Обновление репозитория
### Обновление кода
```bash
# Переход в директорию проекта
cd /path/to/bgp-server
# Получение обновлений
git fetch origin
# Переключение на ветку bird
git checkout bird
# Обновление кода
git pull origin bird
# Перезапуск сервисов (если нужно)
sudo systemctl restart bird bird6
```
### Автоматическое обновление
Создайте cron задачу для автоматического обновления:
```bash
# Редактирование crontab
crontab -e
# Добавление задачи (обновление каждый день в 2:00)
0 2 * * * cd /opt/bgp-server && git pull origin bird && sudo systemctl restart bird bird6
```
---
**Готово!** Теперь у вас есть полные инструкции по клонированию и развертыванию BGP сервера. 🚀
DOCKER_RUN.md
-533
View File
@@ -1,533 +0,0 @@
# Инструкция по запуску BGP Server из Docker Registry
## Быстрый старт
### 1. Создание файлов с префиксами
Создайте папку `data` и файл с префиксами:
```powershell
# Создание папки для данных
mkdir data
# Создание файла с префиксами
@"
# Основные префиксы
192.168.1.0/24
192.168.2.0/24
10.0.0.0/8
172.16.0.0/12
# Дополнительные префиксы
203.0.113.0/24
198.51.100.0/24
"@ | Out-File -FilePath "data/prefixes.txt" -Encoding UTF8
# Проверка создания файла
Get-Content data/prefixes.txt
```
### 2. Запуск контейнера из registry
```powershell
# Запуск BGP сервера из registry с переменными окружения
docker run -d `
--name bgp-server `
--restart unless-stopped `
-p 179:179 `
-v ${PWD}/data:/app/data:ro `
-v ${PWD}/logs:/app/logs `
-e BGP_LOCAL_AS=65000 `
-e BGP_ROUTER_ID=192.168.1.100 `
-e BGP_NEIGHBOR_IP=192.168.1.1 `
-e BGP_NEIGHBOR_AS=65001 `
-e BGP_HOLD_TIME=90 `
-e BGP_KEEPALIVE=30 `
git.shts.su/infra/bgp-server:latest
# Простой запуск с настройками по умолчанию
docker run -d `
--name bgp-server `
--restart unless-stopped `
-p 179:179 `
-v ${PWD}/data:/app/data:ro `
-v ${PWD}/logs:/app/logs `
git.shts.su/infra/bgp-server:latest
# Пример с кастомными настройками
docker run -d `
--name bgp-server-custom `
--restart unless-stopped `
-p 179:179 `
-v ${PWD}/data:/app/data:ro `
-v ${PWD}/logs:/app/logs `
-e BGP_LOCAL_AS=65000 `
-e BGP_ROUTER_ID=10.0.0.100 `
-e BGP_NEIGHBOR_IP=10.0.0.1 `
-e BGP_NEIGHBOR_AS=65001 `
-e BGP_HOLD_TIME=180 `
-e BGP_LOG_LEVEL=DEBUG `
-e BGP_MD5_PASSWORD="your-secure-password" `
git.shts.su/infra/bgp-server:latest
```
### 3. Проверка работы
```powershell
# Просмотр логов
docker logs -f bgp-server
# Проверка статуса контейнера
docker ps
# Проверка BGP сессии
docker exec bgp-server exabgpcli show neighbor
```
## Подробная настройка
### Структура файлов
```
your-project/
├── data/
│ ├── prefixes.txt # Основные префиксы
│ └── additional_prefixes.txt # Дополнительные префиксы
├── logs/ # Логи (создается автоматически)
└── DOCKER_RUN.md # Эта инструкция
```
### Формат файла с префиксами
**data/prefixes.txt:**
```
# Основные префиксы
192.168.1.0/24
192.168.2.0/24
10.0.0.0/8
172.16.0.0/12
# Комментарии начинаются с #
# Пустые строки игнорируются
# Можно добавлять дополнительные префиксы
203.0.113.0/24
198.51.100.0/24
```
**data/additional_prefixes.txt:**
```
# Дополнительные префиксы
172.20.0.0/16
172.21.0.0/16
```
### Полная команда запуска с настройками
```powershell
docker run -d `
--name bgp-server `
--restart unless-stopped `
-p 179:179 `
-v ${PWD}/data:/app/data:ro `
-v ${PWD}/logs:/app/logs `
-e BGP_LOCAL_AS=65000 `
-e BGP_ROUTER_ID=192.168.1.100 `
-e BGP_NEIGHBOR_IP=192.168.1.1 `
-e BGP_NEIGHBOR_AS=65001 `
-e BGP_HOLD_TIME=90 `
-e BGP_KEEPALIVE=30 `
git.shts.su/infra/bgp-server:latest
```
### Переменные окружения
| Переменная | Описание | По умолчанию |
|------------|----------|--------------|
| `BGP_LOCAL_AS` | AS номер сервера | 65000 |
| `BGP_ROUTER_ID` | Router ID сервера | 192.168.1.100 |
| `BGP_NEIGHBOR_IP` | IP адрес BGP пира | 192.168.1.1 |
| `BGP_NEIGHBOR_AS` | AS номер пира | 65001 |
| `BGP_HOLD_TIME` | Hold time в секундах | 90 |
| `BGP_KEEPALIVE` | Keepalive в секундах | 30 |
| `BGP_MD5_PASSWORD` | MD5 пароль для аутентификации | (не используется) |
| `BGP_LOG_LEVEL` | Уровень логирования (DEBUG, INFO, WARNING, ERROR) | INFO |
### Просмотр сгенерированной конфигурации
```powershell
# Просмотр текущей конфигурации ExaBGP
docker exec bgp-server cat /app/exabgp.conf
# Просмотр переменных окружения
docker exec bgp-server env | findstr BGP_
```
## Управление контейнером
### Основные команды
```powershell
# Запуск контейнера
docker start bgp-server
# Остановка контейнера
docker stop bgp-server
# Перезапуск контейнера
docker restart bgp-server
# Удаление контейнера
docker rm -f bgp-server
# Просмотр логов
docker logs bgp-server
# Логи в реальном времени
docker logs -f bgp-server
```
### Обновление контейнера
```powershell
# Безопасное обновление (рекомендуется)
docker stop bgp-server
docker rm bgp-server
docker pull git.shts.su/infra/bgp-server:latest
docker run -d `
--name bgp-server `
--restart unless-stopped `
-p 179:179 `
-v ${PWD}/data:/app/data:ro `
-v ${PWD}/logs:/app/logs `
git.shts.su/infra/bgp-server:latest
# Быстрое обновление (если настройки не изменились)
docker pull git.shts.su/infra/bgp-server:latest
docker restart bgp-server
# Использование скрипта обновления
.\scripts\update-container.ps1
# Принудительное обновление без подтверждения
.\scripts\update-container.ps1 -Force
```
### Обновление префиксов
```powershell
# 1. Отредактируйте файл prefixes.txt
notepad data/prefixes.txt
# 2. Перезапустите контейнер
docker restart bgp-server
# 3. Проверьте логи
docker logs bgp-server
```
### Проверка работы
```powershell
# Статус контейнера
docker ps
# Проверка BGP сессии
docker exec bgp-server exabgpcli show neighbor
# Проверка загруженных префиксов
docker exec bgp-server cat /app/logs/prefixes.log
# Проверка содержимого файлов
docker exec bgp-server cat /app/data/prefixes.txt
# Использование ресурсов
docker stats bgp-server
```
## Настройка RouterOS (клиент)
### Определение версии RouterOS
Сначала определите, какой синтаксис поддерживает ваша версия RouterOS:
```routeros
# Проверка версии RouterOS
/system resource print
# Проверка доступных команд BGP
/routing/bgp/print
/routing bgp print
```
**Если команда `/routing/bgp/print` работает** - используйте новый синтаксис (RouterOS 7.14+)
**Если команда `/routing bgp print` работает** - используйте старый синтаксис
### Адаптация конфигурации под ваши настройки
Замените следующие параметры в командах на ваши значения:
| Параметр | Описание | Ваше значение |
|----------|----------|---------------|
| `as=65001` | Ваш AS номер | Ваш AS номер |
| `router-id=192.168.0.254` | Ваш Router ID | IP адрес вашего роутера |
| `local.address=192.168.0.254` | Ваш локальный IP | IP адрес вашего роутера |
| `remote.address=192.168.100.99` | IP BGP сервера | IP адрес Docker контейнера |
| `remote.as=65000` | AS BGP сервера | AS номер BGP сервера (по умолчанию 65000) |
### Команды для RouterOS 7.14+
**Используйте рабочую конфигурацию с template и connection (см. ниже)**
### Настройка RouterOS 7.14 (рабочая конфигурация)
**Использование template и connection:**
```routeros
# Создать шаблон BGP с вашим AS и router-id
/routing bgp template
add as=65001 disabled=no name=bgp-server output.network=bgp-networks .no-client-to-client-reflection=yes router-id=192.168.0.254 routing-table=main
# Фильтр на запрет экспорта маршрутов (подстраховка)
/routing filter rule
add chain=discard disabled=no rule="reject;"
# Фильтр на импорт маршрутов с изменением next-hop
/routing filter rule
add chain=bgp-server-in disabled=no rule="set gw 192.168.100.99; accept;"
# Настройка BGP пира
/routing bgp connection
add connect=yes disabled=no input.filter=bgp-server-in listen=yes local.address=192.168.0.254 .role=ebgp multihop=yes name=bgp-server.network output.filter-chain=discard remote.address=192.168.100.99/32 .as=65000 .port=179 routing-table=main templates=bgp-server
# Проверка статуса
/routing bgp connection print
/routing bgp route print
```
### Объяснение параметров конфигурации
**BGP Template:**
- `as=65001` - ваш AS номер
- `router-id=192.168.0.254` - ваш Router ID (IP адрес роутера)
- `output.network=bgp-networks` - сеть для экспорта (создается автоматически)
- `.no-client-to-client-reflection=yes` - отключение отражения между клиентами
**Routing Filter Rules:**
- `chain=discard` - цепочка для отклонения экспортируемых маршрутов
- `chain=bgp-server-in` - цепочка для обработки входящих маршрутов
- `set gw 192.168.100.99` - установка next-hop на IP BGP сервера
**BGP Connection:**
- `connect=yes` - активное подключение
- `listen=yes` - ожидание входящих подключений
- `local.address=192.168.0.254` - ваш локальный IP
- `remote.address=192.168.100.99/32` - IP BGP сервера
- `remote.as=65000` - AS номер BGP сервера
- `templates=bgp-server` - использование созданного шаблона
### Команды для удаления конфигурации
Если нужно удалить конфигурацию и начать заново:
```routeros
# Удаление BGP connection
/routing bgp connection remove bgp-server.network
# Удаление фильтров
/routing filter rule remove [find chain=bgp-server-in]
/routing filter rule remove [find chain=discard]
# Удаление BGP template
/routing bgp template remove bgp-server
# Проверка удаления
/routing bgp connection print
/routing filter rule print
/routing bgp template print
```
## Устранение неполадок
### Проблема: Контейнер не запускается
```powershell
# Проверьте логи
docker logs bgp-server
# Проверьте, не занят ли порт 179
netstat -an | findstr :179
# Проверьте права доступа к папкам
ls -la data/
ls -la logs/
```
### Проблема: BGP сессия не устанавливается
```powershell
# Проверьте сетевое подключение
docker exec bgp-server ping 192.168.1.1
# Проверьте конфигурацию
docker exec bgp-server cat /app/exabgp.conf
# Проверьте логи BGP
docker logs bgp-server | findstr "BGP"
```
### Проблема: Префиксы не анонсируются
```powershell
# Проверьте файлы с префиксами
docker exec bgp-server cat /app/data/prefixes.txt
# Проверьте логи процесса загрузки
docker exec bgp-server cat /app/logs/prefixes.log
# Проверьте статус процесса
docker exec bgp-server ps aux | findstr load_prefixes
```
### Проблема: Ошибки ExaBGP конфигурации
```powershell
# Проверьте конфигурацию ExaBGP
docker exec bgp-server cat /app/exabgp.conf
# Валидация конфигурации
docker exec bgp-server exabgp --validate /app/exabgp.conf
# Проверьте named pipes
docker exec bgp-server ls -la /run/exabgp/
docker exec bgp-server ls -la /var/run/exabgp/
# Проверьте логи ExaBGP
docker exec bgp-server cat /app/logs/exabgp.log
# Проверьте переменные окружения
docker exec bgp-server env | findstr BGP_
```
### Проблема: Файл prefixes.txt не найден
```powershell
# Проверьте монтирование volume
docker exec bgp-server ls -la /app/data/
# Создайте файл вручную
docker exec bgp-server bash -c "echo '192.168.1.0/24' > /app/data/prefixes.txt"
# Перезапустите контейнер
docker restart bgp-server
```
### Проблема: BGP сессия не устанавливается в RouterOS
```routeros
# Проверьте доступные команды BGP
/routing/bgp/print
# Проверьте экземпляры BGP
/routing/bgp/instance/print
# Проверьте пиры
/routing/bgp/peer/print
# Проверьте маршруты
/routing/bgp/route/print
# Проверьте логи BGP
/log print where topics~"bgp"
```
### Проблема: Неправильный синтаксис команд RouterOS
Если команды `/routing/bgp/` не работают, попробуйте старый синтаксис:
```routeros
# Старый синтаксис RouterOS
/routing bgp instance add name=bgp-server as=65001 router-id=192.168.1.1
/routing bgp peer add name=bgp-server remote-address=192.168.1.100 remote-as=65000 instance=bgp-server
/routing bgp instance set bgp-server disabled=no
```
### Диагностика версии RouterOS
```routeros
# Проверка версии RouterOS
/system resource print
# Проверка доступных команд BGP
/routing/bgp/print
/routing bgp print
# Проверка доступных подкоманд
/routing/bgp/instance/print
/routing bgp instance print
# Если команды не найдены, используйте старый синтаксис
```
## Примеры использования
### Пример 1: Простой запуск
```powershell
# Создание файла с префиксами
"192.168.1.0/24`n10.0.0.0/8" | Out-File -FilePath "data/prefixes.txt" -Encoding UTF8
# Запуск контейнера
docker run -d --name bgp-server -p 179:179 -v ${PWD}/data:/app/data:ro git.shts.su/infra/bgp-server:latest
```
### Пример 2: Запуск с кастомными настройками
```powershell
docker run -d `
--name bgp-server `
-p 179:179 `
-v ${PWD}/data:/app/data:ro `
-v ${PWD}/logs:/app/logs `
-e BGP_LOCAL_AS=65000 `
-e BGP_ROUTER_ID=10.0.0.100 `
-e BGP_NEIGHBOR_IP=10.0.0.1 `
-e BGP_NEIGHBOR_AS=65001 `
git.shts.su/infra/bgp-server:latest
```
### Пример 3: Запуск с несколькими файлами префиксов
```powershell
# Создание нескольких файлов
"192.168.1.0/24`n192.168.2.0/24" | Out-File -FilePath "data/prefixes.txt" -Encoding UTF8
"10.0.0.0/8`n172.16.0.0/12" | Out-File -FilePath "data/additional_prefixes.txt" -Encoding UTF8
# Запуск контейнера
docker run -d --name bgp-server -p 179:179 -v ${PWD}/data:/app/data:ro git.shts.su/infra/bgp-server:latest
```
## Безопасность
### Рекомендации
1. **Ограничение доступа**: Настройте firewall для ограничения доступа к порту 179
2. **Аутентификация**: Используйте MD5 аутентификацию в BGP
3. **Логирование**: Включите детальное логирование для аудита
4. **Обновления**: Регулярно обновляйте Docker образы
### Настройка MD5 аутентификации
Добавьте переменную окружения:
```powershell
-e BGP_MD5_PASSWORD="your-secure-password"
```
В RouterOS:
```routeros
# Для RouterOS 7.14+ (новый синтаксис)
/routing/bgp/peer set bgp-server password="your-secure-password"
# Для старых версий RouterOS
/routing bgp peer set bgp-server password="your-secure-password"
```
Dockerfile
-43
View File
@@ -1,43 +0,0 @@
FROM python:3.9-slim
# Установка системных зависимостей
RUN apt-get update && apt-get install -y \
iproute2 \
iputils-ping \
net-tools \
procps \
&& rm -rf /var/lib/apt/lists/*
# Установка ExaBGP
RUN pip install exabgp
# Создание структуры директорий
RUN mkdir -p /app/scripts /app/data /app/logs /run/exabgp /var/run/exabgp /usr/local/run/exabgp /usr/local/var/run/exabgp
# Копирование файлов
COPY exabgp.conf /app/exabgp.conf
COPY scripts/ /app/scripts/
COPY data/ /app/data/
# Установка прав доступа
RUN chmod +x /app/scripts/start.sh
RUN chmod +x /app/scripts/load_prefixes.py
RUN chmod +x /app/scripts/generate_config.py
# Рабочая директория
WORKDIR /app
# Открытие BGP порта
EXPOSE 179
# Установка переменных окружения по умолчанию
ENV BGP_LOCAL_AS=65000
ENV BGP_ROUTER_ID=192.168.1.100
ENV BGP_NEIGHBOR_IP=192.168.1.1
ENV BGP_NEIGHBOR_AS=65001
ENV BGP_HOLD_TIME=90
ENV BGP_KEEPALIVE=30
ENV BGP_LOG_LEVEL=INFO
# Команда запуска
ENTRYPOINT ["/app/scripts/start.sh"]
QUICKSTART.md
+119 -187
View File
@@ -1,228 +1,160 @@
# Быстрый старт BGP сервера
## Минимальные требования
## 🚀 Установка за 5 минут
- Docker Desktop для Windows
- PowerShell
- RouterOS 7.14+ (на стороне клиента)
### 1. Подготовка
```bash
# Обновление системы
sudo apt update && sudo apt upgrade -y
## Быстрый запуск (5 минут)
# Установка зависимостей
sudo apt install -y python3 git
```
### 1. Клонирование и подготовка
```powershell
# Клонирование репозитория (если нужно)
git clone <repository-url>
### 2. Клонирование и установка
```bash
# Клонирование проекта (замените на ваш репозиторий)
git clone <your-repo-url>
cd bgp-server
# Создание необходимых директорий
mkdir logs
# Запуск установки
chmod +x install.sh
sudo ./install.sh
```
### 2. Настройка префиксов
### 3. Настройка
```bash
# Настройка IP адреса и ASN
sudo nano /etc/bird/bird.conf
# Измените router id и local as на ваши значения
Отредактируйте файл `data/prefixes.txt`:
```
192.168.1.0/24
10.0.0.0/8
172.16.0.0/12
# Настройка префиксов
sudo nano /opt/bgp-server/data/prefixes.txt
# Добавьте ваши префиксы с community
```
### 3. Запуск сервера
### 4. Запуск
```bash
# Загрузка префиксов
python3 /opt/bgp-server/scripts/load_prefixes.py
```powershell
# Запуск с автоматической сборкой
.\scripts\start-server.ps1 -Build
# Или вручную
docker-compose up -d --build
```
### 4. Проверка работы
```powershell
# Проверка статуса
docker-compose ps
# Просмотр логов
docker-compose logs -f bgp-server
# Мониторинг
docker exec bgp-server python3 /app/scripts/monitor.py
python3 /opt/bgp-server/scripts/monitor.py
```
### 5. Настройка RouterOS
## 📋 Основные команды
Выполните в RouterOS:
| Команда | Описание |
|---------|----------|
| `bgp-status` | Статус BGP сервера |
| `bgp-load` | Загрузить префиксы |
| `bgp-monitor` | Непрерывный мониторинг |
| `bird-status` | Статус сервисов |
| `bird-restart` | Перезапуск сервисов |
| `bird-logs` | Просмотр логов |
```routeros
/routing bgp instance add name=bgp-server as=65001 router-id=192.168.1.1
/routing bgp network add network=192.168.1.0/24
/routing bgp peer add name=bgp-server remote-address=192.168.1.100 remote-as=65000 instance=bgp-server
/routing bgp instance set bgp-server disabled=no
## 🔧 Быстрая настройка
### Настройка префиксов
Формат файла `/opt/bgp-server/data/prefixes.txt`:
```
192.168.1.0/24 65001:100 "Customer A"
10.0.1.0/24 65001:200 "Customer B"
```
### 6. Проверка BGP сессии
В RouterOS:
```routeros
/routing bgp peer print
### Настройка клиента
Пример для Cisco:
```
router bgp CLIENT_ASN
neighbor YOUR_SERVER_IP remote-as YOUR_ASN
neighbor YOUR_SERVER_IP send-community
```
Ожидаемый результат:
```
Flags: X - disabled, I - invalid, D - dynamic, E - established
0 name="bgp-server" ... state=established uptime=1m30s prefix-count=8
```
## Полезные команды
### Управление сервером
```powershell
# Запуск
.\scripts\start-server.ps1
# Остановка
.\scripts\stop-server.ps1
# Перезапуск
docker-compose restart
# Просмотр логов
docker-compose logs -f bgp-server
```
### Мониторинг
```powershell
# Проверка статуса
docker-compose ps
# Мониторинг ресурсов
docker stats bgp-server
# Проверка BGP сессии
docker exec bgp-server exabgpcli show neighbor
```
### Обновление префиксов
```powershell
# Перезагрузка префиксов без перезапуска
docker exec bgp-server python3 /app/scripts/reload_prefixes.py
# Или перезапуск сервера
docker-compose restart
```
## Устранение неполадок
### Проблема: Контейнер не запускается
```powershell
# Проверка логов
docker-compose logs bgp-server
# Проверка портов
netstat -an | findstr :179
# Пересборка образа
docker-compose build --no-cache
```
## 🛠️ Troubleshooting
### Проблема: BGP сессия не устанавливается
```powershell
# Проверка сетевого подключения
docker exec bgp-server ping 192.168.1.1
# Проверка конфигурации
docker exec bgp-server cat /app/exabgp.conf
```bash
# Проверка firewall
sudo ufw status
# Проверка логов
docker-compose logs bgp-server
sudo journalctl -u bird -n 20
```
### Проблема: Префиксы не анонсируются
### Проблема: Префиксы не загружаются
```bash
# Проверка файла префиксов
python3 /opt/bgp-server/scripts/load_prefixes.py --file /opt/bgp-server/data/prefixes.txt
```powershell
# Проверка файлов с префиксами
docker exec bgp-server cat /app/data/prefixes.txt
# Проверка логов загрузки префиксов
docker exec bgp-server cat /app/logs/prefixes.log
# Перезагрузка префиксов
docker exec bgp-server python3 /app/scripts/reload_prefixes.py
# Проверка логов
sudo tail -f /var/log/bird/prefix_loader.log
```
## Настройка сети
## 📁 Структура файлов
### Изменение IP адресов
Отредактируйте `docker-compose.yml`:
```yaml
environment:
- BGP_ROUTER_ID=192.168.1.100 # IP сервера
- BGP_NEIGHBOR_IP=192.168.1.1 # IP RouterOS
```
bgp-server/
├── install.sh # Скрипт установки
├── config/
│ ├── bird.conf # Конфигурация BIRD IPv4
│ └── bird6.conf # Конфигурация BIRD IPv6
├── scripts/
│ ├── load_prefixes.py # Загрузка префиксов
│ └── monitor.py # Мониторинг
├── data/
│ └── prefixes.txt # Файл с префиксами
└── logs/ # Логи
```
И `exabgp.conf`:
```ini
neighbor 192.168.1.1 { # IP RouterOS
router-id 192.168.1.100; # IP сервера
local-address 192.168.1.100; # IP сервера
# ...
}
```
### Изменение AS номеров
В `docker-compose.yml`:
```yaml
environment:
- BGP_LOCAL_AS=65000 # AS сервера
- BGP_NEIGHBOR_AS=65001 # AS RouterOS
```
В `exabgp.conf`:
```ini
neighbor 192.168.1.1 {
local-as 65000; # AS сервера
peer-as 65001; # AS RouterOS
}
```
## Безопасность
### MD5 аутентификация
В `exabgp.conf`:
```ini
neighbor 192.168.1.1 {
# ... существующие настройки ...
md5-password "your-secure-password";
}
```
В RouterOS:
```routeros
/routing bgp peer set bgp-server tcp-md5-key="your-secure-password"
```
## 🔒 Безопасность
### Firewall
```bash
# Проверка статуса
sudo ufw status
```powershell
# Windows Firewall (PowerShell)
New-NetFirewallRule -DisplayName "BGP Server" -Direction Inbound -Protocol TCP -LocalPort 179 -Action Allow
# Разрешение BGP
sudo ufw allow 179/tcp
```
## Готово!
### Ограничение доступа
```bash
# Ограничение birdc только для localhost
sudo nano /etc/bird/bird.conf
# Добавьте: control socket "/var/run/bird.ctl" mode 0600;
```
После выполнения всех шагов у вас должен работать BGP сервер, который раздает префиксы из текстовых файлов в RouterOS.
## 📊 Мониторинг
Для получения дополнительной информации см. основной файл `README.md`.
### Проверка BGP сессий
```bash
sudo birdc show protocols
sudo birdc show routes
```
### Системная статистика
```bash
# Использование ресурсов
htop
# Сетевые соединения
netstat -tlnp | grep :179
```
## 🆘 Поддержка
- **Логи**: `/var/log/bird/`
- **Конфигурация**: `/etc/bird/`
- **Данные**: `/opt/bgp-server/data/`
- **Документация**: `SETUP.md`
## ⚡ Автоматизация
Система автоматически:
- Загружает префиксы каждые 5 минут
- Перезапускается при сбоях
- Ведет логи всех операций
---
**Готово!** Ваш BGP сервер настроен и готов к работе. 🎉
README.md
+107 -325
View File
@@ -1,373 +1,155 @@
# BGP Server для раздачи префиксов
# BGP Server Setup
Этот проект представляет собой BGP сервер, который раздает префиксы из текстовых файлов. Сервер работает в Docker контейнере и предназначен для интеграции с RouterOS 7.14+.
## Обзор
BGP сервер на Ubuntu 24.04 с возможностью подключения любых пиров и загрузки префиксов из файла с community.
## Архитектура решения
- **BGP Server**: ExaBGP в Docker контейнере
- **Источник данных**: Текстовые файлы с префиксами
- **Клиент**: RouterOS 7.14+ для получения префиксов
- **Протокол**: BGP (только исходящие анонсы)
## Архитектура
- **BGP Server**: BIRD (Bird Internet Routing Daemon)
- **OS**: Ubuntu 24.04
- **Функции**:
- Прием BGP соединений от любых пиров
- Загрузка префиксов из файла prefixes.txt
- Настройка community для каждого префикса
- Сервер НЕ получает префиксы, только раздает их клиентам
## Структура проекта
```
bgp-server/
├── docker-compose.yml # Конфигурация Docker
├── Dockerfile # Образ Docker
├── exabgp.conf # Конфигурация ExaBGP
├── README.md
├── install.sh # Скрипт установки
├── config/
│ ├── bird.conf # Основная конфигурация BIRD
│ └── bird6.conf # Конфигурация для IPv6 (опционально)
├── scripts/
│ ├── start.sh # Скрипт запуска
│ └── load_prefixes.py # Загрузка префиксов из файлов
│ ├── load_prefixes.py # Скрипт загрузки префиксов
│ └── monitor.py # Мониторинг BGP сессий
├── data/
│ ├── prefixes.txt # Основной файл с префиксами
│ └── additional_prefixes.txt # Дополнительные префиксы
├── logs/ # Логи ExaBGP
└── README.md # Эта инструкция
│ └── prefixes.txt # Файл с префиксами и community
└── logs/
└── bird.log # Логи BIRD
```
## Быстрый старт
## Установка
### 1. Подготовка файлов с префиксами
Создайте файл `data/prefixes.txt` с префиксами в формате:
```
192.168.1.0/24
10.0.0.0/8
172.16.0.0/12
### 1. Обновление системы
```bash
sudo apt update && sudo apt upgrade -y
```
### 2. Запуск сервера
```powershell
# Клонирование репозитория (если нужно)
git clone <repository-url>
cd bgp-server
# Запуск с Docker Compose
docker-compose up -d
### 2. Установка BIRD
```bash
sudo apt install bird2 -y
```
### 3. Проверка работы
### 3. Настройка конфигурации
```bash
# Копирование конфигурационных файлов
sudo cp config/bird.conf /etc/bird/bird.conf
sudo cp config/bird6.conf /etc/bird/bird6.conf
```powershell
# Просмотр логов
docker-compose logs -f bgp-server
# Создание директорий
sudo mkdir -p /var/log/bird
sudo mkdir -p /opt/bgp-server/data
sudo mkdir -p /opt/bgp-server/scripts
# Проверка статуса контейнера
docker-compose ps
# Копирование скриптов
sudo cp scripts/* /opt/bgp-server/scripts/
sudo cp data/prefixes.txt /opt/bgp-server/data/
```
## Подробная настройка
### Требования
- Docker Desktop для Windows
- PowerShell
- RouterOS 7.14+ на стороне клиента
### Шаг 1: Настройка файлов с префиксами
Создайте файлы с префиксами в папке `data/`:
**data/prefixes.txt:**
```
# Основные префиксы
192.168.1.0/24
192.168.2.0/24
10.0.0.0/8
172.16.0.0/12
# Комментарии начинаются с #
# Пустые строки игнорируются
### 4. Запуск сервисов
```bash
sudo systemctl enable bird
sudo systemctl start bird
sudo systemctl enable bird6
sudo systemctl start bird6
```
**data/additional_prefixes.txt:**
## Конфигурация
### Формат файла prefixes.txt
```
# Дополнительные префиксы
203.0.113.0/24
198.51.100.0/24
# Формат: prefix community description
# Community: ASN:value (например, 65001:100)
192.168.1.0/24 65001:100 "Customer A - Premium"
10.0.1.0/24 65001:200 "Customer B - Standard"
172.16.1.0/24 65001:300 "Customer C - Basic"
203.0.113.0/24 65001:400 "Customer D - Enterprise"
```
### Шаг 2: Конфигурация BGP сервера
### Загрузка префиксов
```bash
# Загрузка префиксов из файла
python3 /opt/bgp-server/scripts/load_prefixes.py
Отредактируйте `exabgp.conf`:
```ini
# Основная конфигурация
process load-prefixes {
run /app/scripts/load_prefixes.py;
encoder json;
}
# Настройки BGP
neighbor 192.168.1.1 {
router-id 192.168.1.100;
local-address 192.168.1.100;
local-as 65000;
peer-as 65001;
# Только исходящие анонсы
capability {
graceful-restart;
}
# Настройки сессии
hold-time 90;
keepalive 30;
# Логирование
api {
processes [load-prefixes];
neighbor-changes;
receive {
parsed;
update;
}
send {
parsed;
update;
}
}
}
# Мониторинг BGP сессий
python3 /opt/bgp-server/scripts/monitor.py
```
### Шаг 3: Настройка Docker
## Мониторинг
**docker-compose.yml:**
```yaml
version: '3.8'
services:
bgp-server:
build: .
container_name: bgp-server
restart: unless-stopped
ports:
- "179:179" # BGP порт
volumes:
- ./data:/app/data:ro
- ./logs:/app/logs
environment:
- BGP_LOCAL_AS=65000
- BGP_ROUTER_ID=192.168.1.100
- BGP_NEIGHBOR_IP=192.168.1.1
- BGP_NEIGHBOR_AS=65001
networks:
- bgp-network
networks:
bgp-network:
driver: bridge
ipam:
config:
- subnet: 192.168.1.0/24
### Проверка статуса BIRD
```bash
sudo birdc show protocols
sudo birdc show routes
sudo birdc show route table all
```
### Шаг 4: Настройка RouterOS
На стороне RouterOS 7.14+ выполните следующие команды:
```routeros
# Создание BGP экземпляра
/routing bgp instance
add name=bgp-server as=65001 router-id=192.168.1.1
# Настройка BGP сети
/routing bgp network
add network=192.168.1.0/24
# Настройка BGP пира
/routing bgp peer
add name=bgp-server remote-address=192.168.1.100 remote-as=65000 instance=bgp-server
# Включение BGP
/routing bgp instance set bgp-server disabled=no
```
### Шаг 5: Запуск и мониторинг
```powershell
# Запуск сервера
docker-compose up -d
# Просмотр логов в реальном времени
docker-compose logs -f bgp-server
# Проверка статуса BGP сессии
docker exec bgp-server exabgpcli show neighbor
```
## Мониторинг и логирование
### Просмотр логов
```powershell
# Все логи
docker-compose logs bgp-server
# Логи в реальном времени
docker-compose logs -f bgp-server
# Логи за последние 100 строк
docker-compose logs --tail=100 bgp-server
```
### Проверка статуса
```powershell
# Статус контейнера
docker-compose ps
# Проверка BGP сессии
docker exec bgp-server exabgpcli show neighbor
# Проверка загруженных префиксов
docker exec bgp-server cat /app/logs/prefixes.log
```
## Обновление префиксов
### Автоматическое обновление
Сервер автоматически перезагружает префиксы при изменении файлов в папке `data/`.
### Ручное обновление
```powershell
# Перезапуск сервера
docker-compose restart bgp-server
# Или перезагрузка только процесса загрузки префиксов
docker exec bgp-server pkill -f load_prefixes.py
```
## Устранение неполадок
### Проблема: BGP сессия не устанавливается
1. Проверьте сетевое подключение:
```powershell
docker exec bgp-server ping 192.168.1.1
```
2. Проверьте конфигурацию:
```powershell
docker exec bgp-server cat /app/exabgp.conf
```
3. Проверьте логи:
```powershell
docker-compose logs bgp-server
```
### Проблема: Префиксы не анонсируются
1. Проверьте файлы с префиксами:
```powershell
docker exec bgp-server cat /app/data/prefixes.txt
```
2. Проверьте логи процесса загрузки:
```powershell
docker exec bgp-server cat /app/logs/prefixes.log
```
### Проблема: Docker контейнер не запускается
1. Проверьте порты:
```powershell
netstat -an | findstr :179
```
2. Проверьте Docker логи:
```powershell
docker-compose logs
```bash
sudo journalctl -u bird -f
sudo tail -f /var/log/bird/bird.log
```
## Безопасность
### Рекомендации по безопасности
### Firewall настройки
```bash
# Разрешить BGP (порт 179)
sudo ufw allow 179/tcp
1. **Ограничение доступа**: Настройте firewall для ограничения доступа к порту 179
2. **Аутентификация**: Используйте MD5 аутентификацию в BGP
3. **Логирование**: Включите детальное логирование для аудита
4. **Обновления**: Регулярно обновляйте Docker образы
# Разрешить SSH
sudo ufw allow ssh
### Настройка MD5 аутентификации
В `exabgp.conf` добавьте:
```ini
neighbor 192.168.1.1 {
# ... существующие настройки ...
md5-password "your-secure-password";
}
# Включить firewall
sudo ufw enable
```
В RouterOS:
```routeros
/routing bgp peer set bgp-server password="your-secure-password"
```
### Ограничение доступа
- Настройте ACL в конфигурации BIRD
- Используйте MD5 аутентификацию для BGP сессий
- Ограничьте доступ к birdc только с localhost
## Производительность
## Troubleshooting
### Оптимизация для больших объемов префиксов
### Частые проблемы
1. **BGP сессия не устанавливается**
- Проверьте firewall настройки
- Убедитесь, что ASN настроен правильно
- Проверьте логи BIRD
1. **Кэширование**: Используйте Redis для кэширования префиксов
2. **База данных**: Для больших объемов используйте PostgreSQL
3. **Мониторинг**: Настройте метрики производительности
2. **Префиксы не загружаются**
- Проверьте формат файла prefixes.txt
- Убедитесь, что скрипт load_prefixes.py имеет права на выполнение
- Проверьте синтаксис конфигурации BIRD
### Мониторинг ресурсов
3. **Высокая нагрузка на CPU**
- Оптимизируйте конфигурацию BIRD
- Проверьте количество префиксов
- Мониторьте использование памяти
```powershell
# Использование ресурсов контейнера
docker stats bgp-server
## Полезные команды
# Проверка дискового пространства
docker system df
```
```bash
# Перезагрузка конфигурации BIRD
sudo birdc configure
## Альтернативные решения
# Проверка синтаксиса конфигурации
sudo birdc -p
### 1. Bird BGP Daemon
# Экспорт маршрутов
sudo birdc show route export all
Если ExaBGP не подходит, можно использовать Bird:
```dockerfile
FROM ubuntu:20.04
RUN apt-get update && apt-get install -y bird
COPY bird.conf /etc/bird/bird.conf
CMD ["bird", "-f", "-d"]
```
### 2. FRRouting (FRR)
Другой популярный вариант:
```dockerfile
FROM ubuntu:20.04
RUN apt-get update && apt-get install -y frr
COPY frr.conf /etc/frr/frr.conf
CMD ["/usr/lib/frr/frrinit", "start"]
```
### 3. GoBGP
Для более современного подхода:
```dockerfile
FROM golang:1.19-alpine
RUN go install github.com/osrg/gobgp/cmd/gobgpd@latest
COPY gobgpd.conf /etc/gobgpd.conf
CMD ["gobgpd", "-f", "/etc/gobgpd.conf"]
```
## Заключение
Этот BGP сервер предоставляет простое и эффективное решение для раздачи префиксов из текстовых файлов. Docker контейнеризация обеспечивает легкое развертывание и управление, а интеграция с RouterOS позволяет быстро настроить клиентскую сторону.
Для продакшн использования рекомендуется:
- Настроить мониторинг и алертинг
- Добавить резервное копирование конфигурации
- Реализовать автоматическое восстановление после сбоев
- Настроить централизованное логирование
# Статистика протоколов
sudo birdc show protocols all
```
SETUP.md
+367
View File
@@ -0,0 +1,367 @@
# Настройка BGP Сервера
## Предварительные требования
### Системные требования
- Ubuntu 24.04 LTS
- Минимум 2 ГБ RAM
- Минимум 10 ГБ свободного места на диске
- Статический IP адрес
- Root доступ или sudo права
### Сетевые требования
- Открытый порт 179 (BGP)
- Настроенный firewall
- Стабильное интернет-соединение
## Пошаговая установка
### 1. Подготовка системы
```bash
# Обновление системы
sudo apt update && sudo apt upgrade -y
# Установка необходимых пакетов
sudo apt install -y python3 python3-pip git curl wget
```
### 2. Клонирование проекта
```bash
# Клонирование репозитория (если используете git)
git clone <repository-url>
cd bgp-server
# Или копирование файлов вручную
```
### 3. Запуск установки
```bash
# Сделать скрипт исполняемым
chmod +x install.sh
# Запуск установки
sudo ./install.sh
```
### 4. Настройка конфигурации
После установки необходимо настроить конфигурационные файлы:
#### Настройка router ID
Отредактируйте файлы `/etc/bird/bird.conf` и `/etc/bird/bird6.conf`:
```bash
sudo nano /etc/bird/bird.conf
```
Найдите строку:
```
router id 192.168.1.1;
```
Замените на ваш реальный IP адрес:
```
router id YOUR_SERVER_IP;
```
#### Настройка ASN
В том же файле найдите:
```
local as 65001;
```
Замените на ваш ASN:
```
local as YOUR_ASN;
```
### 5. Настройка префиксов
Отредактируйте файл `/opt/bgp-server/data/prefixes.txt`:
```bash
sudo nano /opt/bgp-server/data/prefixes.txt
```
Формат записи:
```
# prefix community description
192.168.1.0/24 65001:100 "Customer A - Premium"
10.0.1.0/24 65001:200 "Customer B - Standard"
```
### 6. Загрузка префиксов
```bash
# Загрузка префиксов из файла
python3 /opt/bgp-server/scripts/load_prefixes.py
# Проверка статуса
python3 /opt/bgp-server/scripts/monitor.py
```
## Конфигурация клиентов
### Настройка BGP клиента
Клиенты должны настроить BGP сессию с вашим сервером:
```
# Пример конфигурации для клиента (Cisco)
router bgp CLIENT_ASN
neighbor YOUR_SERVER_IP remote-as YOUR_ASN
neighbor YOUR_SERVER_IP description "BGP Server"
neighbor YOUR_SERVER_IP send-community
neighbor YOUR_SERVER_IP route-map EXPORT out
!
route-map EXPORT permit 10
set community YOUR_ASN:100
!
```
### Настройка для MikroTik
```
/routing bgp instance
add name=bgp-server as=CLIENT_ASN router-id=CLIENT_ROUTER_ID
/routing bgp peer
add name=bgp-server-peer instance=bgp-server remote-address=YOUR_SERVER_IP remote-as=YOUR_ASN
```
## Мониторинг и управление
### Основные команды
```bash
# Статус BGP сервера
bgp-status
# Загрузка префиксов
bgp-load
# Непрерывный мониторинг
bgp-monitor
# Статус сервисов
bird-status
# Перезапуск сервисов
bird-restart
# Просмотр логов
bird-logs
```
### Проверка BGP сессий
```bash
# Показать все протоколы
sudo birdc show protocols
# Показать маршруты
sudo birdc show routes
# Показать BGP пиры
sudo birdc show protocols all bgp
```
### Просмотр логов
```bash
# Логи BIRD IPv4
sudo journalctl -u bird -f
# Логи BIRD IPv6
sudo journalctl -u bird6 -f
# Логи загрузки префиксов
sudo tail -f /var/log/bird/prefix_loader.log
# Логи мониторинга
sudo tail -f /var/log/bird/monitor.log
```
## Безопасность
### Firewall настройки
```bash
# Проверка статуса firewall
sudo ufw status
# Разрешение дополнительных портов (если нужно)
sudo ufw allow 22/tcp comment "SSH"
sudo ufw allow 179/tcp comment "BGP"
# Включение firewall
sudo ufw enable
```
### Ограничение доступа
```bash
# Ограничение доступа к birdc только с localhost
sudo nano /etc/bird/bird.conf
```
Добавьте в конфигурацию:
```
# Ограничение доступа к birdc
control socket "/var/run/bird.ctl" mode 0600 owner bird group bird;
```
### MD5 аутентификация
Для дополнительной безопасности можно включить MD5 аутентификацию:
```bash
# В конфигурации BIRD
protocol bgp {
# ... другие настройки ...
password "your_secure_password";
}
```
## Troubleshooting
### Частые проблемы
#### 1. BGP сессия не устанавливается
```bash
# Проверьте firewall
sudo ufw status
# Проверьте логи
sudo journalctl -u bird -n 50
# Проверьте конфигурацию
sudo birdc -p /etc/bird/bird.conf
```
#### 2. Префиксы не загружаются
```bash
# Проверьте права доступа
ls -la /opt/bgp-server/scripts/load_prefixes.py
# Проверьте синтаксис файла префиксов
python3 /opt/bgp-server/scripts/load_prefixes.py --file /opt/bgp-server/data/prefixes.txt
# Проверьте логи
sudo tail -f /var/log/bird/prefix_loader.log
```
#### 3. Высокая нагрузка на CPU
```bash
# Проверьте количество маршрутов
sudo birdc show route count
# Проверьте использование памяти
free -h
# Оптимизируйте конфигурацию
sudo nano /etc/bird/bird.conf
```
### Полезные команды для диагностики
```bash
# Проверка сетевых соединений
netstat -tlnp | grep :179
# Проверка процессов BIRD
ps aux | grep bird
# Проверка использования ресурсов
htop
# Проверка дискового пространства
df -h
# Проверка системных логов
dmesg | tail -20
```
## Обновление и обслуживание
### Обновление BIRD
```bash
# Обновление пакетов
sudo apt update
sudo apt upgrade bird2
# Перезапуск сервисов
sudo systemctl restart bird bird6
```
### Резервное копирование
```bash
# Создание резервной копии конфигурации
sudo cp /etc/bird/bird.conf /etc/bird/bird.conf.backup.$(date +%Y%m%d)
sudo cp /etc/bird/bird6.conf /etc/bird/bird6.conf.backup.$(date +%Y%m%d)
# Резервная копия префиксов
sudo cp /opt/bgp-server/data/prefixes.txt /opt/bgp-server/data/prefixes.txt.backup.$(date +%Y%m%d)
```
### Восстановление из резервной копии
```bash
# Восстановление конфигурации
sudo cp /etc/bird/bird.conf.backup.YYYYMMDD /etc/bird/bird.conf
sudo cp /etc/bird/bird6.conf.backup.YYYYMMDD /etc/bird/bird6.conf
# Перезапуск сервисов
sudo systemctl restart bird bird6
```
## Дополнительные возможности
### Автоматическая загрузка префиксов
Система автоматически загружает префиксы каждые 5 минут. Для изменения интервала:
```bash
sudo nano /etc/systemd/system/bgp-prefix-loader.timer
```
Измените строку:
```
OnUnitActiveSec=5min
```
### Настройка уведомлений
Можно настроить отправку уведомлений при проблемах:
```bash
# Установка mailutils
sudo apt install mailutils
# Настройка отправки уведомлений в скриптах
```
### Интеграция с системой мониторинга
Для интеграции с системами мониторинга (Zabbix, Nagios):
```bash
# Создание скрипта для проверки здоровья
sudo nano /opt/bgp-server/scripts/health_check.py
```
## Поддержка
При возникновении проблем:
1. Проверьте логи: `/var/log/bird/`
2. Проверьте статус сервисов: `systemctl status bird bird6`
3. Проверьте конфигурацию: `birdc -p /etc/bird/bird.conf`
4. Обратитесь к документации BIRD: https://bird.network.cz/
TESTING.md
-338
View File
@@ -1,338 +0,0 @@
# Тестирование BGP сервера
## Подготовка к тестированию
### Требования для тестирования
- Docker Desktop для Windows
- PowerShell
- RouterOS 7.14+ (физический или виртуальный)
- Сетевое подключение между сервером и RouterOS
### Схема тестирования
```
[Windows Host] ←→ [RouterOS Device]
192.168.1.100 192.168.1.1
AS: 65000 AS: 65001
```
## Пошаговое тестирование
### Шаг 1: Подготовка окружения
```powershell
# Клонирование репозитория
git clone <repository-url>
cd bgp-server
# Создание директорий
mkdir logs
# Проверка файлов
Get-ChildItem -Recurse
```
### Шаг 2: Настройка тестовых префиксов
Отредактируйте `data/prefixes.txt`:
```
# Тестовые префиксы
192.168.100.0/24
192.168.200.0/24
10.10.10.0/24
172.16.100.0/24
```
### Шаг 3: Запуск BGP сервера
```powershell
# Запуск с автоматической сборкой
.\scripts\start-server.ps1 -Build
# Проверка статуса
docker-compose ps
```
Ожидаемый результат:
```
Name Command State Ports
bgp-server /app/script Up 0.0.0.0:179->179/tcp
```
### Шаг 4: Проверка логов сервера
```powershell
# Просмотр логов
docker-compose logs bgp-server
# Проверка логов в реальном времени
docker-compose logs -f bgp-server
```
Ожидаемые сообщения:
```
Starting BGP Server...
Validating ExaBGP configuration...
Starting ExaBGP...
ExaBGP started successfully with PID: XXX
```
### Шаг 5: Проверка загрузки префиксов
```powershell
# Проверка логов загрузки префиксов
docker exec bgp-server cat /app/logs/prefixes.log
```
Ожидаемый результат:
```
[2024-01-01 12:00:00] Starting prefix loader...
[2024-01-01 12:00:00] Loaded 4 prefixes from prefixes.txt
[2024-01-01 12:00:00] Total prefixes loaded: 4
[2024-01-01 12:00:00] Announced prefix: 10.10.10.0/24
[2024-01-01 12:00:00] Announced prefix: 172.16.100.0/24
[2024-01-01 12:00:00] Announced prefix: 192.168.100.0/24
[2024-01-01 12:00:00] Announced prefix: 192.168.200.0/24
[2024-01-01 12:00:00] All prefixes announced successfully
```
### Шаг 6: Настройка RouterOS
Выполните в RouterOS:
```routeros
# Создание BGP экземпляра
/routing bgp instance add name=bgp-server as=65001 router-id=192.168.1.1
# Настройка BGP сети
/routing bgp network add network=192.168.1.0/24
# Настройка BGP пира
/routing bgp peer add name=bgp-server remote-address=192.168.1.100 remote-as=65000 instance=bgp-server
# Включение BGP экземпляра
/routing bgp instance set bgp-server disabled=no
```
### Шаг 7: Проверка BGP сессии
В RouterOS:
```routeros
# Проверка статуса BGP пира
/routing bgp peer print
```
Ожидаемый результат:
```
Flags: X - disabled, I - invalid, D - dynamic, E - established
0 name="bgp-server" instance=bgp-server remote-address=192.168.1.100 remote-as=65000
state=established uptime=1m30s prefix-count=4 updates-sent=4 updates-received=0
withdrawn-sent=0 withdrawn-received=0
```
### Шаг 8: Проверка полученных маршрутов
В RouterOS:
```routeros
# Просмотр полученных BGP маршрутов
/routing bgp routes print
```
Ожидаемый результат:
```
Flags: * - best, b - backup
0 * dst-address=10.10.10.0/24 gateway=192.168.1.100 immediate-gw=192.168.1.100
bgp-local-pref=100 bgp-origin=igp bgp-as-path="" bgp-community="" bgp-ext-community=""
bgp-large-community="" bgp-med="" bgp-prepend="" bgp-atomic-aggregate=no bgp-aggregator-as=""
bgp-aggregator-id="" bgp-nexthop=192.168.1.100 bgp-identifier=192.168.1.100
bgp-cluster-list="" bgp-dampening=no bgp-peer=bgp-server
1 * dst-address=172.16.100.0/24 gateway=192.168.1.100 immediate-gw=192.168.1.100
bgp-local-pref=100 bgp-origin=igp bgp-as-path="" bgp-community="" bgp-ext-community=""
bgp-large-community="" bgp-med="" bgp-prepend="" bgp-atomic-aggregate=no bgp-aggregator-as=""
bgp-aggregator-id="" bgp-nexthop=192.168.1.100 bgp-identifier=192.168.1.100
bgp-cluster-list="" bgp-dampening=no bgp-peer=bgp-server
2 * dst-address=192.168.100.0/24 gateway=192.168.1.100 immediate-gw=192.168.1.100
bgp-local-pref=100 bgp-origin=igp bgp-as-path="" bgp-community="" bgp-ext-community=""
bgp-large-community="" bgp-med="" bgp-prepend="" bgp-atomic-aggregate=no bgp-aggregator-as=""
bgp-aggregator-id="" bgp-nexthop=192.168.1.100 bgp-identifier=192.168.1.100
bgp-cluster-list="" bgp-dampening=no bgp-peer=bgp-server
3 * dst-address=192.168.200.0/24 gateway=192.168.1.100 immediate-gw=192.168.1.100
bgp-local-pref=100 bgp-origin=igp bgp-as-path="" bgp-community="" bgp-ext-community=""
bgp-large-community="" bgp-med="" bgp-prepend="" bgp-atomic-aggregate=no bgp-aggregator-as=""
bgp-aggregator-id="" bgp-nexthop=192.168.1.100 bgp-identifier=192.168.1.100
bgp-cluster-list="" bgp-dampening=no bgp-peer=bgp-server
```
### Шаг 9: Тестирование обновления префиксов
```powershell
# Добавление нового префикса
echo "192.168.300.0/24" >> data/prefixes.txt
# Перезагрузка префиксов
docker exec bgp-server python3 /app/scripts/reload_prefixes.py
```
Проверьте в RouterOS:
```routeros
/routing bgp routes print
```
Должен появиться новый маршрут `192.168.300.0/24`.
### Шаг 10: Тестирование отзыва префиксов
```powershell
# Удаление префикса из файла
# Отредактируйте data/prefixes.txt и удалите одну строку
# Перезагрузка префиксов
docker exec bgp-server python3 /app/scripts/reload_prefixes.py
```
Проверьте в RouterOS:
```routeros
/routing bgp routes print
```
Удаленный префикс должен исчезнуть из таблицы маршрутов.
## Автоматизированное тестирование
### Скрипт тестирования
Создайте файл `test-bgp.ps1`:
```powershell
# Скрипт автоматизированного тестирования
Write-Host "=== BGP Server Testing ===" -ForegroundColor Green
# Проверка Docker
Write-Host "1. Checking Docker..." -ForegroundColor Yellow
try {
docker --version | Out-Null
Write-Host "✓ Docker is available" -ForegroundColor Green
} catch {
Write-Host "✗ Docker is not available" -ForegroundColor Red
exit 1
}
# Проверка контейнера
Write-Host "2. Checking container status..." -ForegroundColor Yellow
$containerStatus = docker ps --filter name=bgp-server --format "{{.Status}}"
if ($containerStatus) {
Write-Host "✓ Container is running: $containerStatus" -ForegroundColor Green
} else {
Write-Host "✗ Container is not running" -ForegroundColor Red
exit 1
}
# Проверка BGP процесса
Write-Host "3. Checking BGP process..." -ForegroundColor Yellow
$bgpProcess = docker exec bgp-server pgrep -f exabgp
if ($bgpProcess) {
Write-Host "✓ BGP process is running" -ForegroundColor Green
} else {
Write-Host "✗ BGP process is not running" -ForegroundColor Red
}
# Проверка префиксов
Write-Host "4. Checking prefixes..." -ForegroundColor Yellow
$prefixCount = docker exec bgp-server cat /app/data/prefixes.txt | Select-String -Pattern "^\d" | Measure-Object | Select-Object -ExpandProperty Count
Write-Host "✓ Found $prefixCount prefixes" -ForegroundColor Green
# Проверка логов
Write-Host "5. Checking logs..." -ForegroundColor Yellow
$logEntries = docker exec bgp-server cat /app/logs/prefixes.log | Measure-Object -Line | Select-Object -ExpandProperty Lines
Write-Host "✓ Found $logEntries log entries" -ForegroundColor Green
Write-Host "=== Testing Complete ===" -ForegroundColor Green
```
### Запуск тестирования
```powershell
.\test-bgp.ps1
```
## Тестирование производительности
### Тест с большим количеством префиксов
```powershell
# Создание файла с большим количеством префиксов
$prefixes = @()
for ($i = 1; $i -le 1000; $i++) {
$prefixes += "192.168.$i.0/24"
}
$prefixes | Out-File -FilePath "data/large_prefixes.txt" -Encoding UTF8
# Замена основного файла
Move-Item "data/prefixes.txt" "data/prefixes_backup.txt"
Move-Item "data/large_prefixes.txt" "data/prefixes.txt"
# Перезагрузка префиксов
docker exec bgp-server python3 /app/scripts/reload_prefixes.py
```
### Мониторинг производительности
```powershell
# Мониторинг ресурсов
docker stats bgp-server
# Проверка времени загрузки
Measure-Command { docker exec bgp-server python3 /app/scripts/load_prefixes.py }
```
## Тестирование отказоустойчивости
### Тест перезапуска контейнера
```powershell
# Перезапуск контейнера
docker-compose restart
# Ожидание восстановления
Start-Sleep -Seconds 30
# Проверка статуса
docker-compose ps
```
### Тест сетевых сбоев
```powershell
# Симуляция сетевого сбоя (требует настройки)
# Отключение сетевого интерфейса на RouterOS
# Проверка восстановления
# Включение сетевого интерфейса
# Проверка BGP сессии
docker exec bgp-server exabgpcli show neighbor
```
## Очистка после тестирования
```powershell
# Остановка сервера
.\scripts\stop-server.ps1
# Удаление контейнера
docker-compose down
# Очистка образов (опционально)
docker system prune -f
```
## Заключение
После успешного прохождения всех тестов BGP сервер готов к продакшн использованию. Регулярно выполняйте тестирование для обеспечения стабильной работы.
TROUBLESHOOTING.md
+279
View File
@@ -0,0 +1,279 @@
# Troubleshooting - Решение проблем
## Проблема: "Unit file bird6.service does not exist"
### Описание проблемы
В Ubuntu 24.04 сервис `bird6` не всегда устанавливается по умолчанию вместе с пакетом `bird2`.
### Решение 1: Установка BIRD6 отдельно
```bash
# Установка BIRD6
sudo apt install -y bird6
# Проверка установки
which bird6
systemctl list-unit-files | grep bird6
```
### Решение 2: Использование скрипта установки BIRD6
```bash
# Сделать скрипт исполняемым
chmod +x install_bird6.sh
# Запуск установки BIRD6
sudo ./install_bird6.sh
```
### Решение 3: Ручное создание сервиса BIRD6
Если BIRD6 не устанавливается, создайте сервис вручную:
```bash
# Создание systemd сервиса для BIRD6
sudo tee /etc/systemd/system/bird6.service > /dev/null << EOF
[Unit]
Description=BIRD Internet Routing Daemon (IPv6)
Documentation=man:bird(8)
After=network.target
[Service]
Type=notify
ExecStart=/usr/sbin/bird6 -c /etc/bird/bird6.conf -s /var/run/bird6.ctl
ExecReload=/bin/kill -HUP \$MAINPID
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
EOF
# Перезагрузка systemd
sudo systemctl daemon-reload
# Включение и запуск сервиса
sudo systemctl enable bird6
sudo systemctl start bird6
# Проверка статуса
sudo systemctl status bird6
```
### Решение 4: Использование только IPv4
Если BIRD6 не нужен, можно использовать только IPv4:
```bash
# Проверка статуса BIRD IPv4
sudo systemctl status bird
# Проверка конфигурации
sudo birdc -p /etc/bird/bird.conf
# Запуск BIRD IPv4
sudo systemctl start bird
```
## Другие частые проблемы
### Проблема: "Permission denied" при запуске скриптов
```bash
# Установка прав на выполнение
chmod +x install.sh
chmod +x install_bird6.sh
chmod +x scripts/*.py
# Проверка прав
ls -la install.sh
ls -la scripts/
```
### Проблема: "Command not found: birdc"
```bash
# Проверка установки BIRD
which bird
which birdc
# Переустановка BIRD
sudo apt remove --purge bird2
sudo apt install -y bird2
# Проверка символических ссылок
ls -la /usr/sbin/bird*
```
### Проблема: "Configuration file not found"
```bash
# Проверка существования файлов конфигурации
ls -la /etc/bird/
# Копирование файлов конфигурации
sudo cp config/bird.conf /etc/bird/
sudo cp config/bird6.conf /etc/bird/
# Проверка прав доступа
sudo chown bird:bird /etc/bird/bird*.conf
sudo chmod 644 /etc/bird/bird*.conf
```
### Проблема: "Port 179 already in use"
```bash
# Проверка процессов на порту 179
sudo netstat -tlnp | grep :179
sudo lsof -i :179
# Остановка конфликтующих сервисов
sudo systemctl stop bird bird6
sudo pkill bird
# Перезапуск сервисов
sudo systemctl start bird
sudo systemctl start bird6
```
### Проблема: "Firewall blocking BGP"
```bash
# Проверка статуса firewall
sudo ufw status
# Разрешение BGP порта
sudo ufw allow 179/tcp
# Проверка правил iptables
sudo iptables -L | grep 179
```
### Проблема: "Python script errors"
```bash
# Проверка версии Python
python3 --version
# Установка зависимостей
sudo apt install -y python3-pip
# Проверка скриптов
python3 -m py_compile scripts/load_prefixes.py
python3 -m py_compile scripts/monitor.py
```
## Проверка работоспособности
### Полная диагностика
```bash
#!/bin/bash
# Скрипт диагностики BGP сервера
echo "=== Диагностика BGP сервера ==="
echo "1. Проверка установки BIRD:"
which bird && echo "✓ BIRD найден" || echo "✗ BIRD не найден"
which birdc && echo "✓ BIRDc найден" || echo "✗ BIRDc не найден"
echo "2. Проверка сервисов:"
systemctl is-active bird && echo "✓ BIRD IPv4 активен" || echo "✗ BIRD IPv4 неактивен"
systemctl is-active bird6 2>/dev/null && echo "✓ BIRD IPv6 активен" || echo "✗ BIRD IPv6 неактивен"
echo "3. Проверка портов:"
netstat -tlnp | grep :179 && echo "✓ Порт 179 прослушивается" || echo "✗ Порт 179 не прослушивается"
echo "4. Проверка конфигурации:"
birdc -p /etc/bird/bird.conf 2>/dev/null && echo "✓ Конфигурация IPv4 корректна" || echo "✗ Ошибка в конфигурации IPv4"
bird6c -p /etc/bird/bird6.conf 2>/dev/null && echo "✓ Конфигурация IPv6 корректна" || echo "✗ Ошибка в конфигурации IPv6"
echo "5. Проверка файлов:"
ls -la /etc/bird/ && echo "✓ Файлы конфигурации найдены" || echo "✗ Файлы конфигурации не найдены"
echo "6. Проверка логов:"
tail -5 /var/log/bird/bird.log 2>/dev/null || echo "Логи BIRD не найдены"
```
### Сохранение скрипта диагностики
```bash
# Создание скрипта диагностики
nano diagnose_bgp.sh
# Вставьте код выше
# Сделать исполняемым
chmod +x diagnose_bgp.sh
# Запуск диагностики
./diagnose_bgp.sh
```
## Восстановление после сбоя
### Полное переустановка
```bash
# Остановка сервисов
sudo systemctl stop bird bird6
# Удаление конфигурации
sudo rm -rf /etc/bird/bird*.conf
sudo rm -rf /opt/bgp-server
# Переустановка BIRD
sudo apt remove --purge bird2 bird6
sudo apt install -y bird2
# Повторная установка
sudo ./install.sh
```
### Восстановление из резервной копии
```bash
# Восстановление конфигурации
sudo cp /etc/bird/bird.conf.backup.* /etc/bird/bird.conf
sudo cp /etc/bird/bird6.conf.backup.* /etc/bird/bird6.conf
# Перезапуск сервисов
sudo systemctl restart bird bird6
```
## Получение помощи
### Логи для диагностики
```bash
# Сбор логов для анализа
sudo journalctl -u bird --no-pager > bird_logs.txt
sudo journalctl -u bird6 --no-pager > bird6_logs.txt
sudo systemctl status bird bird6 > service_status.txt
sudo netstat -tlnp > network_status.txt
# Создание архива с логами
tar -czf bgp_diagnostics_$(date +%Y%m%d_%H%M%S).tar.gz *.txt
```
### Полезные команды
```bash
# Проверка версии BIRD
bird --version
# Проверка синтаксиса конфигурации
birdc -p /etc/bird/bird.conf
# Просмотр протоколов
birdc show protocols
# Просмотр маршрутов
birdc show routes
# Просмотр логов в реальном времени
journalctl -u bird -f
```
---
**Примечание**: Если проблема не решается, соберите логи и обратитесь к документации BIRD: https://bird.network.cz/
alternative-solutions.md
-293
View File
@@ -1,293 +0,0 @@
# Альтернативные решения для BGP сервера
## Обзор решений
В данном документе представлены альтернативные решения для создания BGP сервера, который раздает префиксы из текстовых файлов.
## 1. Bird BGP Daemon
### Преимущества
- Высокая производительность
- Поддержка IPv6
- Гибкая конфигурация
- Активная разработка
### Недостатки
- Сложная конфигурация
- Меньше документации на русском языке
### Dockerfile
```dockerfile
FROM ubuntu:20.04
# Установка Bird
RUN apt-get update && apt-get install -y bird
# Создание директорий
RUN mkdir -p /etc/bird /var/log/bird
# Копирование конфигурации
COPY bird.conf /etc/bird/bird.conf
# Открытие BGP порта
EXPOSE 179
# Запуск Bird
CMD ["bird", "-f", "-d"]
```
### Конфигурация (bird.conf)
```
# Основная конфигурация Bird
log stderr all;
log "/var/log/bird.log" all;
# Настройки BGP
router id 192.168.1.100;
# Протокол для загрузки префиксов из файла
protocol static {
route 192.168.1.0/24 via 192.168.1.100;
route 10.0.0.0/8 via 192.168.1.100;
route 172.16.0.0/12 via 192.168.1.100;
}
# BGP протокол
protocol bgp bgp_peer {
local as 65000;
neighbor 192.168.1.1 as 65001;
export where proto = "static";
import none;
}
```
## 2. FRRouting (FRR)
### Преимущества
- Полная совместимость с Cisco IOS
- Поддержка множества протоколов
- Хорошая документация
- Активное сообщество
### Недостатки
- Больший размер образа
- Более сложная настройка
### Dockerfile
```dockerfile
FROM ubuntu:20.04
# Установка FRR
RUN apt-get update && apt-get install -y frr
# Создание директорий
RUN mkdir -p /etc/frr /var/log/frr
# Копирование конфигурации
COPY frr.conf /etc/frr/frr.conf
# Открытие BGP порта
EXPOSE 179
# Запуск FRR
CMD ["/usr/lib/frr/frrinit", "start"]
```
### Конфигурация (frr.conf)
```
! FRR configuration
hostname bgp-server
password zebra
enable password zebra
! BGP configuration
router bgp 65000
bgp router-id 192.168.1.100
neighbor 192.168.1.1 remote-as 65001
neighbor 192.168.1.1 description RouterOS
!
address-family ipv4 unicast
network 192.168.1.0/24
network 10.0.0.0/8
network 172.16.0.0/12
neighbor 192.168.1.1 activate
exit-address-family
```
## 3. GoBGP
### Преимущества
- Современный подход
- Высокая производительность
- Поддержка gRPC API
- Легкая интеграция с Go приложениями
### Недостатки
- Меньше готовых примеров
- Требует знания Go для расширения
### Dockerfile
```dockerfile
FROM golang:1.19-alpine
# Установка GoBGP
RUN go install github.com/osrg/gobgp/cmd/gobgpd@latest
# Создание директорий
RUN mkdir -p /etc/gobgp
# Копирование конфигурации
COPY gobgpd.conf /etc/gobgpd.conf
# Открытие BGP порта
EXPOSE 179
# Запуск GoBGP
CMD ["gobgpd", "-f", "/etc/gobgpd.conf"]
```
### Конфигурация (gobgpd.conf)
```toml
[global.config]
as = 65000
router-id = "192.168.1.100"
[[neighbors]]
[neighbors.config]
neighbor-address = "192.168.1.1"
peer-as = 65001
[[neighbors.afi-safis]]
[neighbors.afi-safis.config]
afi-safi-name = "ipv4-unicast"
[[defined-sets.prefix-sets]]
prefix-set-name = "prefixes"
[[defined-sets.prefix-sets.prefix-list]]
ip-prefix = "192.168.1.0/24"
[[defined-sets.prefix-sets.prefix-list]]
ip-prefix = "10.0.0.0/8"
[[defined-sets.prefix-sets.prefix-list]]
ip-prefix = "172.16.0.0/12"
```
## 4. Quagga (устаревший)
### Преимущества
- Простая конфигурация
- Много документации
- Стабильность
### Недостатки
- Устаревший проект
- Отсутствие обновлений
- Проблемы с безопасностью
### Dockerfile
```dockerfile
FROM ubuntu:18.04
# Установка Quagga
RUN apt-get update && apt-get install -y quagga
# Создание директорий
RUN mkdir -p /etc/quagga /var/log/quagga
# Копирование конфигурации
COPY zebra.conf /etc/quagga/zebra.conf
COPY bgpd.conf /etc/quagga/bgpd.conf
# Открытие BGP порта
EXPOSE 179
# Запуск Quagga
CMD ["/usr/lib/quagga/zebra", "-f", "/etc/quagga/zebra.conf"]
```
## 5. Собственное решение на Python
### Преимущества
- Полный контроль
- Легкая кастомизация
- Простота отладки
### Недостатки
- Требует разработки
- Меньше производительность
- Необходимость поддержки
### Пример реализации
```python
import asyncio
import ipaddress
from pybgp import BGP
class BGPServer:
def __init__(self, local_as, router_id, neighbor_ip, neighbor_as):
self.local_as = local_as
self.router_id = router_id
self.neighbor_ip = neighbor_ip
self.neighbor_as = neighbor_as
self.prefixes = set()
async def load_prefixes(self, filename):
"""Загрузка префиксов из файла"""
with open(filename, 'r') as f:
for line in f:
line = line.strip()
if line and not line.startswith('#'):
try:
ipaddress.ip_network(line)
self.prefixes.add(line)
except ValueError:
print(f"Invalid prefix: {line}")
async def announce_prefixes(self):
"""Анонсирование префиксов"""
for prefix in self.prefixes:
# Логика анонсирования
pass
async def main():
server = BGPServer(65000, "192.168.1.100", "192.168.1.1", 65001)
await server.load_prefixes("prefixes.txt")
await server.announce_prefixes()
if __name__ == "__main__":
asyncio.run(main())
```
## Сравнение решений
| Решение | Простота | Производительность | Документация | Поддержка |
|---------|----------|-------------------|--------------|-----------|
| ExaBGP | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ |
| Bird | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| FRR | ⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| GoBGP | ⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ |
| Quagga | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐ |
| Python | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
## Рекомендации
### Для простых задач
- **ExaBGP** - лучший выбор для быстрого прототипирования
- **Python решение** - для полного контроля
### Для продакшн использования
- **Bird** - для высокой производительности
- **FRR** - для совместимости с Cisco
### Для современных проектов
- **GoBGP** - для интеграции с микросервисами
- **ExaBGP** - для простых сценариев
## Заключение
Выбор решения зависит от конкретных требований:
- Простота настройки → ExaBGP
- Производительность → Bird/FRR
- Современность → GoBGP
- Контроль → Python решение
Для большинства случаев ExaBGP является оптимальным выбором благодаря простоте настройки и достаточной производительности.
config/bird.conf
+104
View File
@@ -0,0 +1,104 @@
# BIRD Configuration for BGP Server
# Ubuntu 24.04
# Logging configuration
log "/var/log/bird/bird.log" all;
log stderr all;
# Router ID (замените на ваш IP адрес)
router id 192.168.1.1;
# Protocol configuration
protocol device {
scan time 10;
}
protocol direct {
disabled;
}
protocol kernel {
disabled;
}
# Таблица для BGP маршрутов
table bgp_table;
# Статическая таблица маршрутов
protocol static {
# Маршруты будут загружаться из файла prefixes.txt
# через скрипт load_prefixes.py
table bgp_table;
# Пример статических маршрутов
# route 192.168.1.0/24 via 192.168.1.1;
# route 10.0.1.0/24 via 10.0.1.1;
}
# BGP Configuration
# Принимаем соединения от любых пиров
protocol bgp {
# Локальные настройки
local as 65001;
# Настройки для всех пиров
hold time 90;
keepalive time 30;
startup hold time 240;
# Принимаем соединения от любых IP
listen bgp port 179;
# Настройки для пиров
import none; # Не импортируем маршруты от пиров
export all; # Экспортируем все маршруты пирам
# Настройки для статических маршрутов
import where source = RTS_STATIC;
export where source = RTS_STATIC;
# MD5 аутентификация (опционально)
# password "your_bgp_password";
# Настройки для больших таблиц маршрутизации
table limit 100000;
# Настройки для community
import filter {
# Принимаем маршруты с community
if bgp_community.matches(65001:*) then {
accept;
}
reject;
};
export filter {
# Экспортируем маршруты с community
if source = RTS_STATIC then {
bgp_community.add(65001:100);
accept;
}
reject;
};
}
# Фильтры для community
filter community_filter {
if bgp_community.matches(65001:*) then {
accept;
}
reject;
}
# Функция для добавления community
function add_community() {
bgp_community.add(65001:100);
}
# Настройки для мониторинга
protocol pipe {
table master;
peer table bgp_table;
import all;
export none;
}
config/bird6.conf
+103
View File
@@ -0,0 +1,103 @@
# BIRD IPv6 Configuration for BGP Server
# Ubuntu 24.04
# Logging configuration
log "/var/log/bird/bird6.log" all;
log stderr all;
# Router ID (замените на ваш IPv4 адрес)
router id 192.168.1.1;
# Protocol configuration
protocol device {
scan time 10;
}
protocol direct {
disabled;
}
protocol kernel {
disabled;
}
# Таблица для BGP маршрутов IPv6
table bgp_table;
# Статическая таблица маршрутов IPv6
protocol static {
# Маршруты будут загружаться из файла prefixes6.txt
# через скрипт load_prefixes.py
table bgp_table;
# Пример статических маршрутов IPv6
# route 2001:db8::/32 via 2001:db8::1;
# route 2001:db8:1::/48 via 2001:db8:1::1;
}
# BGP IPv6 Configuration
protocol bgp {
# Локальные настройки
local as 65001;
# Настройки для всех пиров
hold time 90;
keepalive time 30;
startup hold time 240;
# Принимаем соединения от любых IPv6 адресов
listen bgp port 179;
# Настройки для пиров
import none; # Не импортируем маршруты от пиров
export all; # Экспортируем все маршруты пирам
# Настройки для статических маршрутов
import where source = RTS_STATIC;
export where source = RTS_STATIC;
# MD5 аутентификация (опционально)
# password "your_bgp_password";
# Настройки для больших таблиц маршрутизации
table limit 100000;
# Настройки для community
import filter {
# Принимаем маршруты с community
if bgp_community.matches(65001:*) then {
accept;
}
reject;
};
export filter {
# Экспортируем маршруты с community
if source = RTS_STATIC then {
bgp_community.add(65001:100);
accept;
}
reject;
};
}
# Фильтры для community
filter community_filter {
if bgp_community.matches(65001:*) then {
accept;
}
reject;
}
# Функция для добавления community
function add_community() {
bgp_community.add(65001:100);
}
# Настройки для мониторинга
protocol pipe {
table master;
peer table bgp_table;
import all;
export none;
}
config/bird_any_peer.conf
+97
View File
@@ -0,0 +1,97 @@
# BIRD Configuration for BGP Server - Accept ANY Peer
# Ubuntu 24.04
# Эта конфигурация принимает ЛЮБЫХ пиров с ЛЮБЫМИ ASN
# Logging configuration
log "/var/log/bird/bird.log" all;
log stderr all;
# Router ID (замените на ваш IP адрес)
router id 192.168.1.1;
# Protocol configuration
protocol device {
scan time 10;
}
protocol direct {
disabled;
}
protocol kernel {
disabled;
}
# Таблица для BGP маршрутов
table bgp_table;
# Статическая таблица маршрутов
protocol static {
# Маршруты будут загружаться из файла prefixes.txt
# через скрипт load_prefixes.py
table bgp_table;
}
# BGP Configuration - принимаем ЛЮБЫХ пиров
protocol bgp {
# Локальные настройки
local as 65001;
# Настройки для всех пиров
hold time 90;
keepalive time 30;
startup hold time 240;
# Принимаем соединения от ЛЮБЫХ IP и ЛЮБЫХ ASN
listen bgp port 179;
# Настройки для пиров - принимаем ЛЮБЫХ пиров
import none; # Не импортируем маршруты от пиров
export all; # Экспортируем все маршруты пирам
# Настройки для статических маршрутов
import where source = RTS_STATIC;
export where source = RTS_STATIC;
# MD5 аутентификация ОТКЛЮЧЕНА для приема любых пиров
# password "your_bgp_password";
# Настройки для больших таблиц маршрутизации
table limit 100000;
# Настройки для community - принимаем любые community
import filter {
# Принимаем ВСЕ маршруты от любых пиров
accept;
};
export filter {
# Экспортируем маршруты с community
if source = RTS_STATIC then {
bgp_community.add(65001:100);
accept;
}
reject;
};
}
# Фильтры для community
filter community_filter {
if bgp_community.matches(65001:*) then {
accept;
}
reject;
}
# Функция для добавления community
function add_community() {
bgp_community.add(65001:100);
}
# Настройки для мониторинга
protocol pipe {
table master;
peer table bgp_table;
import all;
export none;
}
config/bird_fixed.conf
+66
View File
@@ -0,0 +1,66 @@
# BIRD Configuration for BGP Server
# Ubuntu 24.04 - Fixed Version
# Logging configuration
log "/var/log/bird/bird.log" all;
log stderr all;
# Router ID (замените на ваш IP адрес)
router id 77.232.38.173;
# Protocol configuration
protocol device {
scan time 10;
}
protocol direct {
disabled;
}
protocol kernel {
disabled;
}
# Статическая таблица маршрутов
protocol static {
# Маршруты будут загружаться из файла prefixes.txt
# через скрипт load_prefixes.py
# Пример статических маршрутов
# route 192.168.1.0/24 via 192.168.1.1;
# route 10.0.1.0/24 via 10.0.1.1;
}
# BGP Configuration - принимаем любых пиров, но не получаем префиксы
protocol bgp any_peer {
# Локальные настройки
local as 65001;
# Настройки для всех пиров
hold time 90;
keepalive time 30;
startup hold time 240;
# Принимаем соединения от любых IP
listen bgp port 179;
# НЕ импортируем маршруты от пиров
import none;
# Экспортируем только статические маршруты
export where source = RTS_STATIC;
# MD5 аутентификация (опционально)
# password "your_bgp_password";
# Настройки для больших таблиц маршрутизации
table limit 100000;
}
# Настройки для мониторинга
protocol pipe {
table master;
peer table bgp_table;
import all;
export none;
}
config/bird_simple.conf
+42
View File
@@ -0,0 +1,42 @@
# Простая конфигурация BIRD для тестирования
# Ubuntu 24.04
# Logging configuration
log "/var/log/bird/bird.log" all;
log stderr all;
# Router ID (замените на ваш IP адрес)
router id 192.168.1.1;
# Protocol configuration
protocol device {
scan time 10;
}
protocol direct {
disabled;
}
protocol kernel {
disabled;
}
# Статическая таблица маршрутов
protocol static {
# Пример статических маршрутов
route 192.168.1.0/24 via 192.168.1.1;
route 10.0.1.0/24 via 10.0.1.1;
}
# BGP Configuration
protocol bgp {
# Локальные настройки
local as 65001;
# Принимаем соединения от любых IP
listen bgp port 179;
# Настройки для пиров
import none; # Не импортируем маршруты от пиров
export all; # Экспортируем все маршруты пирам
}
config/bird_test.conf
+36
View File
@@ -0,0 +1,36 @@
# Минимальная тестовая конфигурация BIRD
# Ubuntu 24.04
# Logging
log stderr all;
# Router ID
router id 77.232.38.173;
# Device protocol
protocol device {
scan time 10;
}
# Direct protocol (disabled)
protocol direct {
disabled;
}
# Kernel protocol (disabled)
protocol kernel {
disabled;
}
# Static routes
protocol static {
# Пустая таблица статических маршрутов
}
# BGP protocol
protocol bgp any_peer {
local as 65001;
listen bgp port 179;
import none;
export where source = RTS_STATIC;
}
data/additional_prefixes.txt
-10
View File
@@ -1,10 +0,0 @@
# Дополнительные префиксы
# Этот файл может содержать дополнительные сети для анонсирования
# Тестовые сети
192.168.100.0/24
192.168.200.0/24
# Специальные сети
10.10.10.0/24
10.20.20.0/24
data/prefixes.txt
+29 -12
View File
@@ -1,14 +1,31 @@
# Основные префиксы для анонсирования
# Формат: IP/маска (например: 192.168.1.0/24)
# BGP Prefixes with Community Configuration
# Format: prefix community description
# Community format: ASN:value (e.g., 65001:100)
# Приватные сети
192.168.1.0/24
192.168.2.0/24
192.168.10.0/24
10.0.0.0/8
172.16.0.0/12
# Customer A - Premium Service
192.168.1.0/24 65001:100 "Customer A - Premium"
192.168.2.0/24 65001:100 "Customer A - Premium"
10.0.1.0/24 65001:100 "Customer A - Premium"
# Дополнительные сети
203.0.113.0/24
198.51.100.0/24
203.0.113.1/32
# Customer B - Standard Service
10.0.2.0/24 65001:200 "Customer B - Standard"
172.16.1.0/24 65001:200 "Customer B - Standard"
172.16.2.0/24 65001:200 "Customer B - Standard"
# Customer C - Basic Service
203.0.113.0/24 65001:300 "Customer C - Basic"
203.0.113.16/28 65001:300 "Customer C - Basic"
198.51.100.0/24 65001:300 "Customer C - Basic"
# Customer D - Enterprise Service
192.0.2.0/24 65001:400 "Customer D - Enterprise"
192.0.3.0/24 65001:400 "Customer D - Enterprise"
10.1.0.0/16 65001:400 "Customer D - Enterprise"
# Customer E - High Priority
172.20.0.0/16 65001:500 "Customer E - High Priority"
10.10.0.0/16 65001:500 "Customer E - High Priority"
# Customer F - Low Priority
192.168.100.0/24 65001:600 "Customer F - Low Priority"
10.100.0.0/16 65001:600 "Customer F - Low Priority"
docker-compose.yml
-28
View File
@@ -1,28 +0,0 @@
version: '3.8'
services:
bgp-server:
build: .
container_name: bgp-server
restart: unless-stopped
ports:
- "179:179" # BGP порт
volumes:
- ./data:/app/data:ro
- ./logs:/app/logs
environment:
- BGP_LOCAL_AS=65000
- BGP_ROUTER_ID=192.168.1.100
- BGP_NEIGHBOR_IP=192.168.1.1
- BGP_NEIGHBOR_AS=65001
networks:
- bgp-network
cap_add:
- NET_ADMIN # Для работы с сетевыми интерфейсами
networks:
bgp-network:
driver: bridge
ipam:
config:
- subnet: 192.168.1.0/24
enable_any_peer.sh
+401
View File
@@ -0,0 +1,401 @@
#!/bin/bash
# Скрипт для включения режима приема ЛЮБЫХ пиров
# Ubuntu 24.04
set -e
# Цвета для вывода
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Функции для вывода
print_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
print_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
print_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
print_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# Проверка на root права
check_root() {
if [[ $EUID -ne 0 ]]; then
print_error "Этот скрипт должен быть запущен с правами root"
exit 1
fi
}
# Получение IP адреса сервера
get_server_ip() {
# Попытка получить основной IP адрес
local ip=$(ip route get 8.8.8.8 | awk '{print $7; exit}' 2>/dev/null)
if [[ -z "$ip" ]]; then
# Альтернативный способ
ip=$(hostname -I | awk '{print $1}' 2>/dev/null)
fi
if [[ -z "$ip" ]]; then
print_warning "Не удалось определить IP адрес, используем 192.168.1.1"
ip="192.168.1.1"
fi
echo "$ip"
}
# Создание конфигурации для любых пиров
create_any_peer_config() {
local server_ip=$(get_server_ip)
print_info "Создание конфигурации для приема ЛЮБЫХ пиров с IP: $server_ip"
# Создание конфигурации IPv4
cat > /etc/bird/bird.conf << EOF
# BIRD Configuration for BGP Server - Accept ANY Peer
# Ubuntu 24.04
# Эта конфигурация принимает ЛЮБЫХ пиров с ЛЮБЫМИ ASN
# Logging configuration
log "/var/log/bird/bird.log" all;
log stderr all;
# Router ID
router id $server_ip;
# Protocol configuration
protocol device {
scan time 10;
}
protocol direct {
disabled;
}
protocol kernel {
disabled;
}
# Таблица для BGP маршрутов
table bgp_table;
# Статическая таблица маршрутов
protocol static {
# Маршруты будут загружаться из файла prefixes.txt
# через скрипт load_prefixes.py
table bgp_table;
}
# BGP Configuration - принимаем ЛЮБЫХ пиров
protocol bgp {
# Локальные настройки
local as 65001;
# Настройки для всех пиров
hold time 90;
keepalive time 30;
startup hold time 240;
# Принимаем соединения от ЛЮБЫХ IP и ЛЮБЫХ ASN
listen bgp port 179;
# Настройки для пиров - принимаем ЛЮБЫХ пиров
import none; # Не импортируем маршруты от пиров
export all; # Экспортируем все маршруты пирам
# Настройки для статических маршрутов
import where source = RTS_STATIC;
export where source = RTS_STATIC;
# MD5 аутентификация ОТКЛЮЧЕНА для приема любых пиров
# password "your_bgp_password";
# Настройки для больших таблиц маршрутизации
table limit 100000;
# Настройки для community - принимаем любые community
import filter {
# Принимаем ВСЕ маршруты от любых пиров
accept;
};
export filter {
# Экспортируем маршруты с community
if source = RTS_STATIC then {
bgp_community.add(65001:100);
accept;
}
reject;
};
}
# Фильтры для community
filter community_filter {
if bgp_community.matches(65001:*) then {
accept;
}
reject;
}
# Функция для добавления community
function add_community() {
bgp_community.add(65001:100);
}
# Настройки для мониторинга
protocol pipe {
table master;
peer table bgp_table;
import all;
export none;
}
EOF
# Создание конфигурации IPv6
cat > /etc/bird/bird6.conf << EOF
# BIRD IPv6 Configuration for BGP Server - Accept ANY Peer
# Ubuntu 24.04
# Эта конфигурация принимает ЛЮБЫХ пиров с ЛЮБЫМИ ASN
# Logging configuration
log "/var/log/bird/bird6.log" all;
log stderr all;
# Router ID
router id $server_ip;
# Protocol configuration
protocol device {
scan time 10;
}
protocol direct {
disabled;
}
protocol kernel {
disabled;
}
# Таблица для BGP маршрутов IPv6
table bgp_table;
# Статическая таблица маршрутов IPv6
protocol static {
# Маршруты будут загружаться из файла prefixes6.txt
# через скрипт load_prefixes.py
table bgp_table;
}
# BGP IPv6 Configuration - принимаем ЛЮБЫХ пиров
protocol bgp {
# Локальные настройки
local as 65001;
# Настройки для всех пиров
hold time 90;
keepalive time 30;
startup hold time 240;
# Принимаем соединения от ЛЮБЫХ IPv6 адресов и ЛЮБЫХ ASN
listen bgp port 179;
# Настройки для пиров - принимаем ЛЮБЫХ пиров
import none; # Не импортируем маршруты от пиров
export all; # Экспортируем все маршруты пирам
# Настройки для статических маршрутов
import where source = RTS_STATIC;
export where source = RTS_STATIC;
# MD5 аутентификация ОТКЛЮЧЕНА для приема любых пиров
# password "your_bgp_password";
# Настройки для больших таблиц маршрутизации
table limit 100000;
# Настройки для community - принимаем любые community
import filter {
# Принимаем ВСЕ маршруты от любых пиров
accept;
};
export filter {
# Экспортируем маршруты с community
if source = RTS_STATIC then {
bgp_community.add(65001:100);
accept;
}
reject;
};
}
# Фильтры для community
filter community_filter {
if bgp_community.matches(65001:*) then {
accept;
}
reject;
}
# Функция для добавления community
function add_community() {
bgp_community.add(65001:100);
}
# Настройки для мониторинга
protocol pipe {
table master;
peer table bgp_table;
import all;
export none;
}
EOF
# Установка правильных прав доступа
chown bird:bird /etc/bird/bird*.conf
chmod 644 /etc/bird/bird*.conf
print_success "Конфигурация для любых пиров создана"
}
# Проверка конфигурации
check_config() {
print_info "Проверка конфигурации..."
if bird -p /etc/bird/bird.conf; then
print_success "Конфигурация BIRD (IPv4) корректна"
else
print_error "Ошибка в конфигурации BIRD (IPv4)"
return 1
fi
if command -v bird6 &> /dev/null; then
if bird6 -p /etc/bird/bird6.conf; then
print_success "Конфигурация BIRD (IPv6) корректна"
else
print_warning "Ошибка в конфигурации BIRD (IPv6)"
fi
fi
return 0
}
# Перезапуск сервисов
restart_services() {
print_info "Перезапуск сервисов BIRD..."
# Остановка сервисов
systemctl stop bird 2>/dev/null || true
systemctl stop bird6 2>/dev/null || true
# Запуск BIRD IPv4
systemctl start bird
if systemctl is-active --quiet bird; then
print_success "BIRD (IPv4) запущен"
else
print_error "Ошибка запуска BIRD (IPv4)"
systemctl status bird
return 1
fi
# Попытка запуска BIRD6 если существует
if systemctl list-unit-files | grep -q bird6; then
systemctl start bird6
if systemctl is-active --quiet bird6; then
print_success "BIRD (IPv6) запущен"
else
print_warning "BIRD (IPv6) не запущен"
fi
fi
return 0
}
# Проверка работоспособности
test_functionality() {
print_info "Проверка работоспособности..."
# Проверка статуса сервисов
echo ""
print_info "Статус сервисов:"
systemctl status bird --no-pager -l
# Проверка портов
echo ""
print_info "Проверка портов:"
if netstat -tlnp | grep :179; then
print_success "Порт 179 прослушивается"
else
print_warning "Порт 179 не прослушивается"
fi
# Проверка протоколов
echo ""
print_info "Проверка протоколов:"
if birdc show protocols 2>/dev/null; then
print_success "BIRD отвечает на команды"
else
print_warning "BIRD не отвечает на команды"
fi
}
# Основная функция
main() {
echo "=========================================="
echo "Enable ANY Peer Mode for BGP Server"
echo "Ubuntu 24.04"
echo "=========================================="
check_root
# Создание конфигурации для любых пиров
create_any_peer_config
# Проверка конфигурации
if check_config; then
# Перезапуск сервисов
if restart_services; then
# Проверка работоспособности
test_functionality
print_success "Режим приема любых пиров включен!"
echo ""
echo "Теперь сервер принимает ЛЮБЫХ пиров с ЛЮБЫМИ ASN"
echo ""
echo "Полезные команды:"
echo " sudo birdc show protocols"
echo " sudo birdc show routes"
echo " sudo systemctl status bird"
echo " sudo journalctl -u bird -f"
echo ""
echo "Для подключения клиентов используйте:"
echo " Remote AS: 65001"
echo " Remote IP: $(get_server_ip)"
echo " Port: 179"
else
print_error "Ошибка перезапуска сервисов"
exit 1
fi
else
print_error "Ошибка в конфигурации"
exit 1
fi
}
# Запуск основной функции
main "$@"
exabgp.conf
-5
View File
@@ -1,5 +0,0 @@
# Этот файл будет перезаписан динамически сгенерированной конфигурацией
# из переменных окружения при запуске контейнера.
#
# Для просмотра текущей конфигурации используйте:
# docker exec bgp-server cat /app/exabgp.conf
fix_bird_config.sh
+137
View File
@@ -0,0 +1,137 @@
#!/bin/bash
# Скрипт для исправления конфигурации BIRD
# Ubuntu 24.04
set -e
echo "=========================================="
echo "Исправление конфигурации BIRD"
echo "Ubuntu 24.04"
echo "=========================================="
# Получаем IP адрес сервера
SERVER_IP=$(curl -s ifconfig.me 2>/dev/null || echo "192.168.1.1")
echo "[INFO] Используется IP адрес: $SERVER_IP"
# Останавливаем BIRD если запущен
echo "[INFO] Остановка BIRD..."
systemctl stop bird 2>/dev/null || true
# Создаем резервную копию текущей конфигурации
if [ -f /etc/bird/bird.conf ]; then
cp /etc/bird/bird.conf /etc/bird/bird.conf.backup.$(date +%Y%m%d_%H%M%S)
echo "[INFO] Создана резервная копия: /etc/bird/bird.conf.backup"
fi
# Создаем простую рабочую конфигурацию
echo "[INFO] Создание простой конфигурации BIRD..."
cat > /etc/bird/bird.conf << EOF
# Простая конфигурация BIRD для BGP сервера
# Ubuntu 24.04
# Logging
log stderr all;
log "/var/log/bird/bird.log" all;
# Router ID
router id $SERVER_IP;
# Device protocol
protocol device {
scan time 10;
}
# Direct protocol (disabled)
protocol direct {
disabled;
}
# Kernel protocol (disabled)
protocol kernel {
disabled;
}
# Static routes
protocol static {
# Статические маршруты будут загружаться через скрипт
}
# BGP protocol - принимаем любых пиров
protocol bgp any_peer {
local as 65001;
listen bgp port 179;
import none; # Не принимаем маршруты от пиров
export where source = RTS_STATIC; # Экспортируем только статические маршруты
}
EOF
# Проверяем синтаксис конфигурации (пробуем запустить в тестовом режиме)
echo "[INFO] Проверка синтаксиса конфигурации..."
if timeout 5s bird -c /etc/bird/bird.conf -f 2>/dev/null; then
echo "[SUCCESS] Конфигурация синтаксически корректна"
else
echo "[INFO] Попытка создания минимальной конфигурации..."
# Создаем еще более простую конфигурацию
cat > /etc/bird/bird.conf << EOF
# Минимальная конфигурация BIRD
log stderr all;
router id $SERVER_IP;
protocol device {
scan time 10;
}
protocol direct {
disabled;
}
protocol kernel {
disabled;
}
protocol static {
}
protocol bgp any_peer {
local as 65001;
listen bgp port 179;
import none;
export where source = RTS_STATIC;
}
EOF
echo "[INFO] Минимальная конфигурация создана"
fi
# Создаем директорию для логов если не существует
mkdir -p /var/log/bird
chown bird:bird /var/log/bird 2>/dev/null || true
# Запускаем BIRD
echo "[INFO] Запуск BIRD..."
systemctl start bird
# Проверяем статус
if systemctl is-active --quiet bird; then
echo "[SUCCESS] BIRD успешно запущен"
# Показываем статус
echo "[INFO] Статус BIRD:"
systemctl status bird --no-pager -l
# Показываем информацию о протоколах
echo "[INFO] Информация о протоколах:"
birdc show protocols 2>/dev/null || echo "birdc недоступен"
else
echo "[ERROR] Не удалось запустить BIRD"
echo "[INFO] Логи BIRD:"
journalctl -u bird --no-pager -l -n 20
exit 1
fi
echo "[SUCCESS] Конфигурация BIRD исправлена и сервис запущен"
echo "[INFO] BIRD слушает на порту 179 и принимает соединения от любых пиров"
echo "[INFO] Сервер НЕ будет принимать префиксы от пиров, только экспортировать свои"
fix_config.sh
+224
View File
@@ -0,0 +1,224 @@
#!/bin/bash
# Скрипт для исправления конфигурации BIRD
# Ubuntu 24.04
set -e
# Цвета для вывода
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Функции для вывода
print_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
print_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
print_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
print_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# Проверка на root права
check_root() {
if [[ $EUID -ne 0 ]]; then
print_error "Этот скрипт должен быть запущен с правами root"
exit 1
fi
}
# Получение IP адреса сервера
get_server_ip() {
# Попытка получить основной IP адрес
local ip=$(ip route get 8.8.8.8 | awk '{print $7; exit}' 2>/dev/null)
if [[ -z "$ip" ]]; then
# Альтернативный способ
ip=$(hostname -I | awk '{print $1}' 2>/dev/null)
fi
if [[ -z "$ip" ]]; then
print_warning "Не удалось определить IP адрес, используем 192.168.1.1"
ip="192.168.1.1"
fi
echo "$ip"
}
# Создание простой конфигурации BIRD
create_simple_config() {
local server_ip=$(get_server_ip)
print_info "Создание простой конфигурации BIRD с IP: $server_ip"
# Создание простой конфигурации
cat > /etc/bird/bird.conf << EOF
# Простая конфигурация BIRD для BGP сервера
# Ubuntu 24.04
# Logging configuration
log "/var/log/bird/bird.log" all;
log stderr all;
# Router ID
router id $server_ip;
# Protocol configuration
protocol device {
scan time 10;
}
protocol direct {
disabled;
}
protocol kernel {
disabled;
}
# Статическая таблица маршрутов
protocol static {
# Маршруты будут загружаться из файла prefixes.txt
# через скрипт load_prefixes.py
}
# BGP Configuration
protocol bgp {
# Локальные настройки
local as 65001;
# Принимаем соединения от любых IP
listen bgp port 179;
# Настройки для пиров
import none; # Не импортируем маршруты от пиров
export all; # Экспортируем все маршруты пирам
}
EOF
print_success "Простая конфигурация создана"
}
# Проверка конфигурации
check_config() {
print_info "Проверка конфигурации BIRD..."
if bird -p /etc/bird/bird.conf; then
print_success "Конфигурация BIRD корректна"
return 0
else
print_error "Ошибка в конфигурации BIRD"
return 1
fi
}
# Перезапуск сервисов
restart_services() {
print_info "Перезапуск сервисов BIRD..."
# Остановка сервисов
systemctl stop bird 2>/dev/null || true
systemctl stop bird6 2>/dev/null || true
# Запуск BIRD IPv4
systemctl start bird
if systemctl is-active --quiet bird; then
print_success "BIRD (IPv4) запущен"
else
print_error "Ошибка запуска BIRD (IPv4)"
systemctl status bird
return 1
fi
# Попытка запуска BIRD6 если существует
if systemctl list-unit-files | grep -q bird6; then
systemctl start bird6
if systemctl is-active --quiet bird6; then
print_success "BIRD (IPv6) запущен"
else
print_warning "BIRD (IPv6) не запущен"
fi
fi
return 0
}
# Проверка работоспособности
test_functionality() {
print_info "Проверка работоспособности..."
# Проверка статуса сервисов
echo ""
print_info "Статус сервисов:"
systemctl status bird --no-pager -l
# Проверка портов
echo ""
print_info "Проверка портов:"
if netstat -tlnp | grep :179; then
print_success "Порт 179 прослушивается"
else
print_warning "Порт 179 не прослушивается"
fi
# Проверка протоколов
echo ""
print_info "Проверка протоколов:"
if birdc show protocols 2>/dev/null; then
print_success "BIRD отвечает на команды"
else
print_warning "BIRD не отвечает на команды"
fi
}
# Основная функция
main() {
echo "=========================================="
echo "BIRD Configuration Fix Script"
echo "Ubuntu 24.04"
echo "=========================================="
check_root
# Создание простой конфигурации
create_simple_config
# Проверка конфигурации
if check_config; then
# Перезапуск сервисов
if restart_services; then
# Проверка работоспособности
test_functionality
print_success "Конфигурация исправлена успешно!"
echo ""
echo "Полезные команды:"
echo " sudo birdc show protocols"
echo " sudo birdc show routes"
echo " sudo systemctl status bird"
echo " sudo journalctl -u bird -f"
else
print_error "Ошибка перезапуска сервисов"
exit 1
fi
else
print_error "Ошибка в конфигурации"
exit 1
fi
}
# Запуск основной функции
main "$@"
install.sh
+571
View File
@@ -0,0 +1,571 @@
#!/bin/bash
# BGP Server Installation Script for Ubuntu 24.04
# Устанавливает BIRD и настраивает BGP сервер
set -e
# Цвета для вывода
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Функции для вывода
print_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
print_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
print_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
print_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# Проверка на root права
check_root() {
if [[ $EUID -ne 0 ]]; then
print_error "Этот скрипт должен быть запущен с правами root"
exit 1
fi
}
# Получение IP адреса сервера
get_server_ip() {
# Попытка получить основной IP адрес
local ip=$(ip route get 8.8.8.8 | awk '{print $7; exit}' 2>/dev/null)
if [[ -z "$ip" ]]; then
# Альтернативный способ
ip=$(hostname -I | awk '{print $1}' 2>/dev/null)
fi
if [[ -z "$ip" ]]; then
print_warning "Не удалось определить IP адрес, используем 192.168.1.1"
ip="192.168.1.1"
fi
echo "$ip"
}
# Проверка версии Ubuntu
check_ubuntu_version() {
if [[ ! -f /etc/os-release ]]; then
print_error "Не удалось определить версию ОС"
exit 1
fi
source /etc/os-release
if [[ "$ID" != "ubuntu" ]]; then
print_error "Этот скрипт предназначен только для Ubuntu"
exit 1
fi
if [[ "$VERSION_ID" != "24.04" ]]; then
print_warning "Скрипт тестировался на Ubuntu 24.04. Текущая версия: $VERSION_ID"
fi
print_success "Обнаружена Ubuntu $VERSION_ID"
}
# Обновление системы
update_system() {
print_info "Обновление системы..."
apt update
apt upgrade -y
print_success "Система обновлена"
}
# Установка BIRD
install_bird() {
print_info "Установка BIRD..."
# Установка BIRD2
apt install -y bird2
# Проверка установки
if command -v bird &> /dev/null; then
print_success "BIRD установлен успешно"
else
print_error "Ошибка установки BIRD"
exit 1
fi
}
# Создание директорий
create_directories() {
print_info "Создание директорий..."
mkdir -p /var/log/bird
mkdir -p /opt/bgp-server/data
mkdir -p /opt/bgp-server/scripts
mkdir -p /opt/bgp-server/logs
# Установка прав доступа
chown -R bird:bird /var/log/bird
chmod 755 /opt/bgp-server/scripts
print_success "Директории созданы"
}
# Копирование файлов конфигурации
copy_config_files() {
print_info "Копирование файлов конфигурации..."
# Резервная копия оригинальных конфигураций
if [[ -f /etc/bird/bird.conf ]]; then
cp /etc/bird/bird.conf /etc/bird/bird.conf.backup.$(date +%Y%m%d_%H%M%S)
fi
if [[ -f /etc/bird/bird6.conf ]]; then
cp /etc/bird/bird6.conf /etc/bird/bird6.conf.backup.$(date +%Y%m%d_%H%M%S)
fi
# Получение IP адреса сервера
local server_ip=$(get_server_ip)
print_info "Используется IP адрес: $server_ip"
# Создание правильной конфигурации BIRD IPv4
cat > /etc/bird/bird.conf << EOF
# BIRD Configuration for BGP Server
# Ubuntu 24.04
# Logging configuration
log "/var/log/bird/bird.log" all;
log stderr all;
# Router ID
router id $server_ip;
# Protocol configuration
protocol device {
scan time 10;
}
protocol direct {
disabled;
}
protocol kernel {
disabled;
}
table bgp_table;
protocol static {
table bgp_table;
}
protocol bgp {
local as 65001;
listen bgp port 179;
hold time 90;
keepalive time 30;
startup hold time 240;
# Сервер НЕ принимает маршруты от клиентов
import none;
# Сервер раздает ТОЛЬКО свои статические маршруты
export where source = RTS_STATIC;
# MD5 аутентификация (опционально)
# password "your_bgp_password";
table limit 100000;
# Фильтры: не принимаем ничего, раздаем всё
import filter {
reject;
};
export filter {
accept;
};
}
filter community_filter {
reject;
}
function add_community() {
# пусто
}
protocol pipe {
table master;
peer table bgp_table;
import all;
export none;
}
EOF
# Создание правильной конфигурации BIRD IPv6
cat > /etc/bird/bird6.conf << EOF
# BIRD IPv6 Configuration for BGP Server
# Ubuntu 24.04
# Logging configuration
log "/var/log/bird/bird6.log" all;
log stderr all;
# Router ID
router id $server_ip;
# Protocol configuration
protocol device {
scan time 10;
}
protocol direct {
disabled;
}
protocol kernel {
disabled;
}
table bgp_table;
protocol static {
table bgp_table;
}
protocol bgp {
local as 65001;
listen bgp port 179;
hold time 90;
keepalive time 30;
startup hold time 240;
# Сервер НЕ принимает маршруты от клиентов
import none;
# Сервер раздает ТОЛЬКО свои статические маршруты
export where source = RTS_STATIC;
# MD5 аутентификация (опционально)
# password "your_bgp_password";
table limit 100000;
# Фильтры: не принимаем ничего, раздаем всё
import filter {
reject;
};
export filter {
accept;
};
}
filter community_filter {
reject;
}
function add_community() {
# пусто
}
protocol pipe {
table master;
peer table bgp_table;
import all;
export none;
}
EOF
# Копирование скриптов
cp scripts/load_prefixes.py /opt/bgp-server/scripts/
cp scripts/monitor.py /opt/bgp-server/scripts/
# Копирование файла с префиксами
cp data/prefixes.txt /opt/bgp-server/data/
# Установка прав на выполнение для скриптов
chmod +x /opt/bgp-server/scripts/*.py
# Установка правильных прав доступа к конфигурации
chown bird:bird /etc/bird/bird*.conf
chmod 644 /etc/bird/bird*.conf
print_success "Файлы конфигурации созданы и скопированы"
}
# Настройка firewall
configure_firewall() {
print_info "Настройка firewall..."
# Установка ufw если не установлен
if ! command -v ufw &> /dev/null; then
apt install -y ufw
fi
# Разрешение BGP порта
ufw allow 179/tcp comment "BGP"
# Разрешение SSH
ufw allow ssh comment "SSH"
# Включение firewall
ufw --force enable
print_success "Firewall настроен"
}
# Настройка systemd сервисов
configure_services() {
print_info "Настройка systemd сервисов..."
# Включение автозапуска для bird (IPv4)
systemctl enable bird
# Проверка существования bird6 сервиса
if systemctl list-unit-files | grep -q bird6; then
systemctl enable bird6
print_info "BIRD6 сервис найден и включен"
else
print_warning "BIRD6 сервис не найден, будет использоваться только IPv4"
fi
# Запуск сервисов
systemctl start bird
# Проверка статуса bird
if systemctl is-active --quiet bird; then
print_success "BIRD (IPv4) запущен"
else
print_error "Ошибка запуска BIRD (IPv4)"
systemctl status bird
fi
# Запуск bird6 если существует
if systemctl list-unit-files | grep -q bird6; then
systemctl start bird6
if systemctl is-active --quiet bird6; then
print_success "BIRD (IPv6) запущен"
else
print_error "Ошибка запуска BIRD (IPv6)"
systemctl status bird6
fi
else
print_warning "BIRD6 не запущен (сервис не найден)"
fi
}
# Проверка конфигурации
check_configuration() {
print_info "Проверка конфигурации BIRD..."
# Проверка синтаксиса IPv4 конфигурации
if bird -p /etc/bird/bird.conf; then
print_success "Конфигурация BIRD (IPv4) корректна"
else
print_error "Ошибка в конфигурации BIRD (IPv4)"
print_info "Попытка создания простой конфигурации..."
create_simple_config
if bird -p /etc/bird/bird.conf; then
print_success "Простая конфигурация BIRD (IPv4) создана"
else
print_error "Не удалось создать рабочую конфигурацию BIRD (IPv4)"
exit 1
fi
fi
# Проверка синтаксиса IPv6 конфигурации
if command -v bird6 &> /dev/null; then
if bird6 -p /etc/bird/bird6.conf; then
print_success "Конфигурация BIRD (IPv6) корректна"
else
print_warning "Ошибка в конфигурации BIRD (IPv6), будет использоваться только IPv4"
fi
else
print_warning "BIRD6 не установлен, пропускаем проверку IPv6"
fi
}
# Создание простой конфигурации
create_simple_config() {
local server_ip=$(get_server_ip)
print_info "Создание простой конфигурации BIRD с IP: $server_ip"
cat > /etc/bird/bird.conf << EOF
# Простая конфигурация BIRD для BGP сервера
# Ubuntu 24.04
log "/var/log/bird/bird.log" all;
log stderr all;
router id $server_ip;
protocol device { scan time 10; }
protocol direct { disabled; }
protocol kernel { disabled; }
protocol static {}
protocol bgp {
local as 65001;
listen bgp port 179;
import none;
export where source = RTS_STATIC;
import filter { reject; };
export filter { accept; };
}
EOF
chown bird:bird /etc/bird/bird.conf
chmod 644 /etc/bird/bird.conf
print_success "Простая конфигурация создана"
}
# Создание systemd таймера для автоматической загрузки префиксов
create_systemd_timer() {
print_info "Создание systemd таймера для загрузки префиксов..."
# Создание сервиса
cat > /etc/systemd/system/bgp-prefix-loader.service << EOF
[Unit]
Description=BGP Prefix Loader
After=bird.service bird6.service
[Service]
Type=oneshot
ExecStart=/usr/bin/python3 /opt/bgp-server/scripts/load_prefixes.py
User=root
StandardOutput=journal
StandardError=journal
[Install]
WantedBy=multi-user.target
EOF
# Создание таймера
cat > /etc/systemd/system/bgp-prefix-loader.timer << EOF
[Unit]
Description=Run BGP Prefix Loader every 5 minutes
Requires=bgp-prefix-loader.service
[Timer]
OnBootSec=1min
OnUnitActiveSec=5min
Unit=bgp-prefix-loader.service
[Install]
WantedBy=timers.target
EOF
# Перезагрузка systemd и включение таймера
systemctl daemon-reload
systemctl enable bgp-prefix-loader.timer
systemctl start bgp-prefix-loader.timer
print_success "Systemd таймер создан"
}
# Создание alias для удобства
create_aliases() {
print_info "Создание alias команд..."
# Добавление в .bashrc root пользователя
cat >> /root/.bashrc << EOF
# BGP Server Aliases
alias bgp-status='python3 /opt/bgp-server/scripts/monitor.py'
alias bgp-load='python3 /opt/bgp-server/scripts/load_prefixes.py'
alias bgp-monitor='python3 /opt/bgp-server/scripts/monitor.py -c'
alias bird-status='systemctl status bird bird6'
alias bird-restart='systemctl restart bird bird6'
alias bird-logs='journalctl -u bird -f'
alias bird6-logs='journalctl -u bird6 -f'
EOF
print_success "Alias команды добавлены"
}
# Финальная проверка
final_check() {
print_info "Выполнение финальной проверки..."
# Проверка статуса сервисов
echo ""
print_info "Статус сервисов:"
systemctl status bird --no-pager -l
echo ""
# Проверка bird6 если существует
if systemctl list-unit-files | grep -q bird6; then
systemctl status bird6 --no-pager -l
else
print_warning "BIRD6 сервис не установлен"
fi
# Проверка прослушивания порта
if netstat -tlnp | grep :179; then
print_success "BGP порт 179 прослушивается"
else
print_warning "BGP порт 179 не прослушивается"
fi
# Проверка конфигурации
echo ""
print_info "Проверка конфигурации:"
if birdc show protocols 2>/dev/null; then
print_success "BIRD отвечает на команды"
else
print_warning "BIRD не отвечает на команды (возможно, нужно время для запуска)"
fi
# Проверка firewall
echo ""
print_info "Статус firewall:"
ufw status
print_success "Установка завершена успешно!"
}
# Основная функция
main() {
echo "=========================================="
echo "BGP Server Installation Script"
echo "Ubuntu 24.04"
echo "=========================================="
check_root
check_ubuntu_version
update_system
install_bird
create_directories
copy_config_files
configure_firewall
configure_services
check_configuration
create_systemd_timer
create_aliases
final_check
echo ""
echo "=========================================="
echo "УСТАНОВКА ЗАВЕРШЕНА"
echo "=========================================="
echo ""
echo "Полезные команды:"
echo " bgp-status - Показать статус BGP сервера"
echo " bgp-load - Загрузить префиксы из файла"
echo " bgp-monitor - Непрерывный мониторинг"
echo " bird-status - Статус сервисов BIRD"
echo " bird-restart - Перезапуск сервисов BIRD"
echo " bird-logs - Просмотр логов BIRD"
echo ""
echo "Файлы конфигурации:"
echo " /etc/bird/bird.conf - Конфигурация BIRD IPv4"
echo " /etc/bird/bird6.conf - Конфигурация BIRD IPv6"
echo " /opt/bgp-server/data/prefixes.txt - Файл с префиксами"
echo ""
echo "Логи:"
echo " /var/log/bird/bird.log - Логи BIRD IPv4"
echo " /var/log/bird/bird6.log - Логи BIRD IPv6"
echo ""
echo "Для применения изменений выполните:"
echo " source /root/.bashrc"
echo ""
}
# Запуск основной функции
main "$@"
install_bird6.sh
+198
View File
@@ -0,0 +1,198 @@
#!/bin/bash
# Скрипт для установки BIRD6 на Ubuntu 24.04
# BIRD6 не всегда устанавливается по умолчанию
set -e
# Цвета для вывода
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Функции для вывода
print_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
print_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
print_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
print_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# Проверка на root права
check_root() {
if [[ $EUID -ne 0 ]]; then
print_error "Этот скрипт должен быть запущен с правами root"
exit 1
fi
}
# Установка BIRD6
install_bird6() {
print_info "Проверка установки BIRD6..."
# Проверка существования bird6
if command -v bird6 &> /dev/null; then
print_success "BIRD6 уже установлен"
return 0
fi
print_info "Установка BIRD6..."
# Попытка установки bird6
if apt install -y bird6; then
print_success "BIRD6 установлен успешно"
else
print_warning "BIRD6 не найден в репозиториях, попробуем альтернативные способы"
# Попытка установки из пакета bird2
if apt install -y bird2; then
print_info "BIRD2 установлен, проверяем наличие bird6"
# Проверка символических ссылок
if [[ -f /usr/sbin/bird6 ]]; then
print_success "BIRD6 найден в BIRD2 пакете"
else
print_warning "BIRD6 не найден в BIRD2 пакете"
return 1
fi
else
print_error "Не удалось установить BIRD6"
return 1
fi
fi
return 0
}
# Настройка BIRD6 сервиса
configure_bird6_service() {
print_info "Настройка BIRD6 сервиса..."
# Проверка существования сервиса
if systemctl list-unit-files | grep -q bird6; then
print_success "BIRD6 сервис найден"
# Включение автозапуска
systemctl enable bird6
# Запуск сервиса
systemctl start bird6
# Проверка статуса
if systemctl is-active --quiet bird6; then
print_success "BIRD6 сервис запущен"
else
print_error "Ошибка запуска BIRD6 сервиса"
systemctl status bird6
return 1
fi
else
print_warning "BIRD6 сервис не найден, создаем вручную"
# Создание systemd сервиса для BIRD6
cat > /etc/systemd/system/bird6.service << EOF
[Unit]
Description=BIRD Internet Routing Daemon (IPv6)
Documentation=man:bird(8)
After=network.target
[Service]
Type=notify
ExecStart=/usr/sbin/bird6 -c /etc/bird/bird6.conf -s /var/run/bird6.ctl
ExecReload=/bin/kill -HUP \$MAINPID
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
EOF
# Перезагрузка systemd
systemctl daemon-reload
# Включение и запуск сервиса
systemctl enable bird6
systemctl start bird6
# Проверка статуса
if systemctl is-active --quiet bird6; then
print_success "BIRD6 сервис создан и запущен"
else
print_error "Ошибка запуска созданного BIRD6 сервиса"
systemctl status bird6
return 1
fi
fi
return 0
}
# Проверка конфигурации BIRD6
check_bird6_config() {
print_info "Проверка конфигурации BIRD6..."
if [[ -f /etc/bird/bird6.conf ]]; then
# Проверка синтаксиса
if bird6 -p /etc/bird/bird6.conf; then
print_success "Конфигурация BIRD6 корректна"
else
print_error "Ошибка в конфигурации BIRD6"
return 1
fi
else
print_warning "Файл конфигурации BIRD6 не найден"
return 1
fi
return 0
}
# Основная функция
main() {
echo "=========================================="
echo "BIRD6 Installation Script"
echo "Ubuntu 24.04"
echo "=========================================="
check_root
# Установка BIRD6
if install_bird6; then
# Настройка сервиса
if configure_bird6_service; then
# Проверка конфигурации
if check_bird6_config; then
print_success "BIRD6 успешно установлен и настроен"
echo ""
echo "Полезные команды:"
echo " sudo systemctl status bird6"
echo " sudo bird6c show protocols"
echo " sudo bird6c show routes"
echo " sudo journalctl -u bird6 -f"
else
print_warning "BIRD6 установлен, но есть проблемы с конфигурацией"
fi
else
print_error "Ошибка настройки BIRD6 сервиса"
exit 1
fi
else
print_error "Ошибка установки BIRD6"
exit 1
fi
}
# Запуск основной функции
main "$@"
requirements.txt
+16 -4
View File
@@ -1,4 +1,16 @@
exabgp>=4.2.0
ipaddress
pathlib
typing
# Python dependencies for BGP Server
# These are mostly built-in modules, but listed for completeness
# Core modules (built-in)
# ipaddress - for IP address validation
# subprocess - for executing system commands
# logging - for logging functionality
# json - for JSON output
# time - for timing functions
# datetime - for date/time operations
# os - for operating system interface
# sys - for system-specific parameters
# Optional: for enhanced functionality
# psutil>=5.8.0 - for better system monitoring (optional)
# requests>=2.25.0 - for HTTP API calls (optional)
routeros-setup.md
-255
View File
@@ -1,255 +0,0 @@
# Настройка RouterOS для работы с BGP сервером
## Требования
- RouterOS 7.14 или выше
- Доступ к командной строке RouterOS (WinBox, SSH, или Console)
- Сетевое подключение к BGP серверу
## Схема подключения
```
RouterOS (192.168.1.1) ←→ BGP Server (192.168.1.100)
AS: 65001 AS: 65000
```
## Пошаговая настройка
### Шаг 1: Проверка сетевого подключения
Убедитесь, что RouterOS может достичь BGP сервера:
```routeros
/ping 192.168.1.100 count=4
```
Ожидаемый результат:
```
HOST SIZE TTL TIME STATUS
192.168.1.100 56 64 0.5ms echo reply
192.168.1.100 56 64 0.4ms echo reply
192.168.1.100 56 64 0.5ms echo reply
192.168.1.100 56 64 0.4ms echo reply
sent=4 received=4 packet-loss=0% min-rtt=0.4ms avg-rtt=0.5ms max-rtt=0.5ms
```
### Шаг 2: Создание BGP экземпляра
```routeros
/routing bgp instance
add name=bgp-server as=65001 router-id=192.168.1.1
```
### Шаг 3: Настройка BGP сети
```routeros
/routing bgp network
add network=192.168.1.0/24
```
### Шаг 4: Настройка BGP пира
```routeros
/routing bgp peer
add name=bgp-server remote-address=192.168.1.100 remote-as=65000 instance=bgp-server
```
### Шаг 5: Включение BGP экземпляра
```routeros
/routing bgp instance set bgp-server disabled=no
```
### Шаг 6: Проверка статуса BGP сессии
```routeros
/routing bgp peer print
```
Ожидаемый результат:
```
Flags: X - disabled, I - invalid, D - dynamic, E - established
0 name="bgp-server" instance=bgp-server remote-address=192.168.1.100 remote-as=65000
tcp-md5-key="" nexthop-choice=default multihop=no route-reflect=no hold-time=3m
keepalive-time=1m address-families=ip,ipv6 default-originate=never remove-private-as=no
as-override=no passive=no use-bfd=no cisco-vpls-nlri-len-fmt=no add-path=0/0
remove-private-as-if-export=no in-filter="" out-filter=""
state=established uptime=1m30s prefix-count=8 updates-sent=8 updates-received=0
withdrawn-sent=0 withdrawn-received=0
```
## Дополнительные настройки
### Настройка MD5 аутентификации (рекомендуется)
```routeros
/routing bgp peer set bgp-server tcp-md5-key="your-secure-password"
```
### Настройка фильтров (опционально)
Создание фильтра для входящих маршрутов:
```routeros
/routing filter
add name=bgp-in chain=input protocol=bgp
add name=bgp-in chain=input protocol=bgp action=accept
```
Применение фильтра к BGP пиру:
```routeros
/routing bgp peer set bgp-server in-filter=bgp-in
```
### Настройка таймаутов
```routeros
/routing bgp peer set bgp-server hold-time=90s keepalive-time=30s
```
## Мониторинг и диагностика
### Проверка статуса BGP сессии
```routeros
/routing bgp peer print detail
```
### Просмотр полученных маршрутов
```routeros
/routing bgp routes print
```
### Просмотр логов BGP
```routeros
/log print where topics~"bgp"
```
### Проверка статистики BGP
```routeros
/routing bgp peer print stats
```
## Устранение неполадок
### Проблема: BGP сессия не устанавливается
1. Проверьте сетевое подключение:
```routeros
/ping 192.168.1.100
```
2. Проверьте настройки BGP пира:
```routeros
/routing bgp peer print detail
```
3. Проверьте логи:
```routeros
/log print where topics~"bgp"
```
### Проблема: Маршруты не получаются
1. Проверьте статус сессии:
```routeros
/routing bgp peer print
```
2. Проверьте фильтры:
```routeros
/routing filter print
```
3. Проверьте полученные маршруты:
```routeros
/routing bgp routes print
```
### Проблема: Неправильные AS номера
Убедитесь, что AS номера настроены правильно:
```routeros
/routing bgp instance print
/routing bgp peer print
```
## Полезные команды
### Экспорт конфигурации BGP
```routeros
/export compact where routing~"bgp"
```
### Сброс BGP сессии
```routeros
/routing bgp peer reset bgp-server
```
### Просмотр детальной информации о пире
```routeros
/routing bgp peer print detail where name="bgp-server"
```
### Мониторинг в реальном времени
```routeros
/routing bgp peer monitor bgp-server
```
## Безопасность
### Рекомендации по безопасности
1. **Используйте MD5 аутентификацию**
2. **Настройте фильтры для входящих маршрутов**
3. **Ограничьте доступ к BGP порту (179)**
4. **Регулярно проверяйте логи**
### Настройка firewall для BGP
```routeros
/ip firewall filter
add chain=input protocol=tcp dst-port=179 src-address=192.168.1.100 action=accept comment="BGP from server"
add chain=input protocol=tcp dst-port=179 action=drop comment="Block other BGP"
```
## Автоматизация
### Скрипт для автоматической настройки
Создайте файл `bgp-setup.rsc`:
```routeros
# BGP Setup Script
/routing bgp instance
add name=bgp-server as=65001 router-id=192.168.1.1
/routing bgp network
add network=192.168.1.0/24
/routing bgp peer
add name=bgp-server remote-address=192.168.1.100 remote-as=65000 instance=bgp-server
/routing bgp instance set bgp-server disabled=no
:log info "BGP setup completed"
```
Загрузите и выполните скрипт:
```routeros
/import bgp-setup.rsc
```
## Заключение
После выполнения всех шагов RouterOS должен успешно установить BGP сессию с сервером и начать получать маршруты. Регулярно проверяйте статус сессии и логи для обеспечения стабильной работы.
scripts/generate_config.py
-85
View File
@@ -1,85 +0,0 @@
#!/usr/bin/env python3
"""
Скрипт для генерации конфигурации ExaBGP из переменных окружения
"""
import os
import sys
def get_env_var(name: str, default: str) -> str:
"""Получение переменной окружения с значением по умолчанию"""
return os.environ.get(name, default)
def generate_exabgp_config():
"""Генерация конфигурации ExaBGP"""
# Получение переменных окружения
local_as = get_env_var('BGP_LOCAL_AS', '65000')
router_id = get_env_var('BGP_ROUTER_ID', '192.168.1.100')
neighbor_ip = get_env_var('BGP_NEIGHBOR_IP', '192.168.1.1')
neighbor_as = get_env_var('BGP_NEIGHBOR_AS', '65001')
hold_time = get_env_var('BGP_HOLD_TIME', '90')
keepalive = get_env_var('BGP_KEEPALIVE', '30')
md5_password = get_env_var('BGP_MD5_PASSWORD', '')
log_level = get_env_var('BGP_LOG_LEVEL', 'INFO')
# Генерация конфигурации
config = f"""# Автоматически сгенерированная конфигурация ExaBGP
process load-prefixes {{
run /app/scripts/load_prefixes.py;
encoder json;
}}
# Настройки BGP
neighbor {neighbor_ip} {{
router-id {router_id};
local-address {router_id};
local-as {local_as};
peer-as {neighbor_as};
# Только исходящие анонсы (не принимаем префиксы)
capability {{
graceful-restart;
}}
# Настройки сессии
hold-time {hold_time};
"""
# Добавление MD5 пароля если указан
if md5_password:
config += f" md5-password \"{md5_password}\";\n"
config += f"""
# Логирование
api {{
processes [load-prefixes];
neighbor-changes;
receive {{
parsed;
update;
}}
send {{
parsed;
update;
}}
}}
}}
"""
return config
def main():
"""Основная функция"""
if len(sys.argv) > 1 and sys.argv[1] == '--print':
# Вывод конфигурации в stdout
print(generate_exabgp_config())
else:
# Запись конфигурации в файл
config = generate_exabgp_config()
with open('/app/exabgp.conf', 'w') as f:
f.write(config)
print("Configuration generated successfully")
if __name__ == "__main__":
main()
scripts/load_prefixes.py
+239 -165
View File
@@ -1,190 +1,264 @@
#!/usr/bin/env python3
"""
Скрипт для загрузки префиксов из текстовых файлов в ExaBGP
BGP Prefix Loader Script
Загружает префиксы из файла prefixes.txt в BIRD с настройкой community
"""
import sys
import os
import time
import json
import sys
import subprocess
import ipaddress
from pathlib import Path
from typing import List, Set
import logging
from datetime import datetime
from typing import List, Tuple, Optional
# Настройки
DATA_DIR = "/app/data"
LOG_FILE = "/app/logs/prefixes.log"
PREFIX_FILES = ["prefixes.txt", "additional_prefixes.txt"]
# Настройка логирования
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler('/var/log/bird/prefix_loader.log'),
logging.StreamHandler()
]
)
logger = logging.getLogger(__name__)
def log_message(message: str):
"""Запись сообщения в лог"""
timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
log_entry = f"[{timestamp}] {message}"
class BGPPrefixLoader:
def __init__(self, prefixes_file: str = '/opt/bgp-server/data/prefixes.txt'):
self.prefixes_file = prefixes_file
self.birdc_path = '/usr/bin/birdc'
self.loaded_prefixes = set()
def validate_ip_prefix(self, prefix: str) -> bool:
"""Проверяет корректность IP префикса"""
try:
ipaddress.ip_network(prefix, strict=False)
return True
except ValueError:
return False
# Вывод в stdout для ExaBGP
print(log_entry, flush=True)
def validate_community(self, community: str) -> bool:
"""Проверяет корректность community (формат ASN:value)"""
try:
if ':' not in community:
return False
asn, value = community.split(':', 1)
int(asn)
int(value)
return True
except (ValueError, AttributeError):
return False
# Запись в файл (с обработкой ошибок)
try:
with open(LOG_FILE, "a") as f:
f.write(log_entry + "\n")
except (PermissionError, OSError) as e:
# Если не можем записать в файл, просто выводим в stderr
print(f"Warning: Could not write to log file: {e}", file=sys.stderr, flush=True)
def log_error(message: str):
"""Запись ошибки в лог"""
log_message(f"ERROR: {message}")
def validate_prefix(prefix: str) -> bool:
"""Валидация IP префикса"""
try:
ipaddress.ip_network(prefix, strict=False)
return True
except ValueError:
return False
def load_prefixes_from_file(file_path: Path) -> Set[str]:
"""Загрузка префиксов из файла"""
prefixes = set()
if not file_path.exists():
log_message(f"File not found: {file_path}")
def parse_prefixes_file(self) -> List[Tuple[str, str, str]]:
"""Парсит файл prefixes.txt и возвращает список префиксов с community"""
prefixes = []
if not os.path.exists(self.prefixes_file):
logger.error(f"Файл {self.prefixes_file} не найден")
return prefixes
try:
with open(self.prefixes_file, 'r', encoding='utf-8') as f:
for line_num, line in enumerate(f, 1):
line = line.strip()
# Пропускаем пустые строки и комментарии
if not line or line.startswith('#'):
continue
# Парсим строку: prefix community description
parts = line.split(None, 2)
if len(parts) < 2:
logger.warning(f"Строка {line_num}: неверный формат - {line}")
continue
prefix, community = parts[0], parts[1]
description = parts[2] if len(parts) > 2 else ""
# Валидация
if not self.validate_ip_prefix(prefix):
logger.warning(f"Строка {line_num}: неверный префикс - {prefix}")
continue
if not self.validate_community(community):
logger.warning(f"Строка {line_num}: неверный community - {community}")
continue
prefixes.append((prefix, community, description))
logger.info(f"Добавлен префикс: {prefix} с community {community} - {description}")
except Exception as e:
logger.error(f"Ошибка при чтении файла: {e}")
return prefixes
try:
with open(file_path, 'r') as f:
for line_num, line in enumerate(f, 1):
line = line.strip()
# Пропуск пустых строк и комментариев
if not line or line.startswith('#'):
continue
# Валидация префикса
if validate_prefix(line):
prefixes.add(line)
else:
log_message(f"Invalid prefix in {file_path}:{line_num}: {line}")
except Exception as e:
log_message(f"Error reading {file_path}: {e}")
return prefixes
def load_all_prefixes() -> Set[str]:
"""Загрузка всех префиксов из всех файлов"""
all_prefixes = set()
for filename in PREFIX_FILES:
file_path = Path(DATA_DIR) / filename
prefixes = load_prefixes_from_file(file_path)
all_prefixes.update(prefixes)
log_message(f"Loaded {len(prefixes)} prefixes from {filename}")
return all_prefixes
def announce_prefixes(prefixes: Set[str]):
"""Анонсирование префиксов через ExaBGP API"""
# Получение настроек из переменных окружения
neighbor_ip = os.environ.get('BGP_NEIGHBOR_IP', '192.168.1.1')
local_as = int(os.environ.get('BGP_LOCAL_AS', '65000'))
router_id = os.environ.get('BGP_ROUTER_ID', '192.168.1.100')
for prefix in sorted(prefixes):
# Формат команды для ExaBGP (упрощенный)
command = {
"command": "announce route",
"neighbor": neighbor_ip,
"attribute": {
"origin": "igp",
"as-path": [local_as],
"next-hop": router_id
},
"nlri": prefix
}
def execute_birdc_command(self, command: str) -> Tuple[bool, str]:
"""Выполняет команду через birdc"""
try:
result = subprocess.run(
[self.birdc_path] + command.split(),
capture_output=True,
text=True,
timeout=30
)
if result.returncode == 0:
return True, result.stdout
else:
return False, result.stderr
# Отправка команды в ExaBGP
print(json.dumps(command), flush=True)
log_message(f"Announced prefix: {prefix}")
def withdraw_prefixes(prefixes: Set[str]):
"""Отзыв префиксов через ExaBGP API"""
# Получение настроек из переменных окружения
neighbor_ip = os.environ.get('BGP_NEIGHBOR_IP', '192.168.1.1')
except subprocess.TimeoutExpired:
return False, "Timeout при выполнении команды"
except Exception as e:
return False, str(e)
for prefix in sorted(prefixes):
command = {
"command": "withdraw route",
"neighbor": neighbor_ip,
"nlri": prefix
}
def add_static_route(self, prefix: str, community: str) -> bool:
"""Добавляет статический маршрут в BIRD"""
# Команда для добавления статического маршрута
command = f"configure 'route {prefix} via 127.0.0.1;'"
print(json.dumps(command), flush=True)
log_message(f"Withdrew prefix: {prefix}")
success, output = self.execute_birdc_command(command)
if success:
logger.info(f"Добавлен маршрут: {prefix}")
self.loaded_prefixes.add(prefix)
else:
logger.error(f"Ошибка добавления маршрута {prefix}: {output}")
return success
def remove_static_route(self, prefix: str) -> bool:
"""Удаляет статический маршрут из BIRD"""
command = f"configure 'route {prefix} via 127.0.0.1;'"
success, output = self.execute_birdc_command(command)
if success:
logger.info(f"Удален маршрут: {prefix}")
self.loaded_prefixes.discard(prefix)
else:
logger.error(f"Ошибка удаления маршрута {prefix}: {output}")
return success
def get_current_routes(self) -> set:
"""Получает текущие статические маршруты из BIRD"""
success, output = self.execute_birdc_command("show route table bgp_table")
if not success:
logger.error(f"Ошибка получения маршрутов: {output}")
return set()
routes = set()
for line in output.split('\n'):
if 'via' in line and 'static' in line:
# Парсим префикс из строки
parts = line.split()
if len(parts) > 0:
prefix = parts[0]
routes.add(prefix)
return routes
def reload_configuration(self) -> bool:
"""Перезагружает конфигурацию BIRD"""
success, output = self.execute_birdc_command("configure")
if success:
logger.info("Конфигурация BIRD перезагружена")
else:
logger.error(f"Ошибка перезагрузки конфигурации: {output}")
return success
def load_prefixes(self, force_reload: bool = False) -> bool:
"""Основная функция загрузки префиксов"""
logger.info("Начинаем загрузку префиксов...")
# Получаем текущие маршруты
current_routes = self.get_current_routes()
logger.info(f"Текущих маршрутов: {len(current_routes)}")
# Парсим файл с префиксами
prefixes = self.parse_prefixes_file()
logger.info(f"Найдено префиксов в файле: {len(prefixes)}")
if not prefixes:
logger.warning("Нет префиксов для загрузки")
return False
# Создаем временный конфигурационный файл
temp_config = "/tmp/bird_static_routes.conf"
try:
with open(temp_config, 'w') as f:
f.write("# Автоматически сгенерированные статические маршруты\n")
f.write("# Время создания: {}\n\n".format(datetime.now()))
for prefix, community, description in prefixes:
f.write(f"route {prefix} via 127.0.0.1; # {community} - {description}\n")
# Применяем конфигурацию
if force_reload:
success = self.reload_configuration()
else:
success = True
if success:
logger.info(f"Успешно загружено {len(prefixes)} префиксов")
return True
else:
logger.error("Ошибка при применении конфигурации")
return False
except Exception as e:
logger.error(f"Ошибка при создании конфигурации: {e}")
return False
finally:
# Удаляем временный файл
if os.path.exists(temp_config):
os.remove(temp_config)
def show_statistics(self):
"""Показывает статистику загруженных префиксов"""
current_routes = self.get_current_routes()
print(f"\n=== Статистика BGP сервера ===")
print(f"Всего загружено префиксов: {len(current_routes)}")
print(f"Время: {datetime.now()}")
if current_routes:
print("\nЗагруженные префиксы:")
for prefix in sorted(current_routes):
print(f" - {prefix}")
def main():
"""Основная функция"""
# Создание директории для логов в начале
try:
os.makedirs(os.path.dirname(LOG_FILE), exist_ok=True)
except (PermissionError, OSError):
pass # Игнорируем ошибки создания директории
import argparse
# Проверка тестового режима
if len(sys.argv) > 1 and sys.argv[1] == '--test':
print("Testing prefix loader...")
prefixes = load_all_prefixes()
print(f"Found {len(prefixes)} prefixes: {list(prefixes)}")
return
parser = argparse.ArgumentParser(description='BGP Prefix Loader')
parser.add_argument('--file', '-f',
default='/opt/bgp-server/data/prefixes.txt',
help='Путь к файлу с префиксами')
parser.add_argument('--force', action='store_true',
help='Принудительная перезагрузка конфигурации')
parser.add_argument('--stats', action='store_true',
help='Показать статистику')
log_message("Starting prefix loader...")
args = parser.parse_args()
# Загрузка префиксов
prefixes = load_all_prefixes()
log_message(f"Total prefixes loaded: {len(prefixes)}")
loader = BGPPrefixLoader(args.file)
if not prefixes:
log_message("No valid prefixes found. Exiting.")
return
# Анонсирование префиксов
announce_prefixes(prefixes)
log_message("All prefixes announced successfully")
# Ожидание команд от ExaBGP
try:
while True:
line = sys.stdin.readline()
if not line:
break
line = line.strip()
if not line: # Пропуск пустых строк
continue
# Обработка команд от ExaBGP
try:
data = json.loads(line)
log_message(f"Received command: {data}")
except json.JSONDecodeError:
# Не все сообщения от ExaBGP являются JSON
# Это может быть обычное текстовое сообщение
if line.startswith('[') and line.endswith(']'):
# Это может быть лог сообщение от ExaBGP
log_message(f"Received log message: {line}")
else:
log_message(f"Received non-JSON message: {line}")
except KeyboardInterrupt:
log_message("Received interrupt signal")
except Exception as e:
log_message(f"Error in main loop: {e}")
finally:
# Отзыв всех префиксов при завершении
log_message("Withdrawing all prefixes...")
withdraw_prefixes(prefixes)
log_message("Prefix loader stopped")
if args.stats:
loader.show_statistics()
else:
success = loader.load_prefixes(args.force)
if success:
loader.show_statistics()
sys.exit(0)
else:
sys.exit(1)
if __name__ == "__main__":
main()
scripts/monitor.py
+360 -75
View File
@@ -1,93 +1,378 @@
#!/usr/bin/env python3
"""
Скрипт мониторинга BGP сервера
BGP Monitor Script
Мониторинг BGP сессий, статистики и состояния сервера
"""
import os
import sys
import subprocess
import json
import time
import sys
import logging
from datetime import datetime
from typing import Dict, List, Optional
def run_command(cmd):
"""Выполнение команды и возврат результата"""
try:
result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
return result.returncode == 0, result.stdout, result.stderr
except Exception as e:
return False, "", str(e)
# Настройка логирования
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler('/var/log/bird/monitor.log'),
logging.StreamHandler()
]
)
logger = logging.getLogger(__name__)
def check_container_status():
"""Проверка статуса Docker контейнера"""
success, output, error = run_command("docker ps --filter name=bgp-server --format '{{.Status}}'")
if success and output.strip():
return True, output.strip()
return False, "Container not running"
def check_bgp_session():
"""Проверка BGP сессии"""
success, output, error = run_command("docker exec bgp-server exabgpcli show neighbor")
if success:
return True, output
return False, "Cannot check BGP session"
def check_prefixes():
"""Проверка загруженных префиксов"""
try:
with open("/app/logs/prefixes.log", "r") as f:
lines = f.readlines()
return True, f"Found {len(lines)} log entries"
except FileNotFoundError:
return False, "Prefix log not found"
def check_network_connectivity():
"""Проверка сетевого подключения"""
success, output, error = run_command("docker exec bgp-server ping -c 1 192.168.1.1")
return success, "Network connectivity OK" if success else "Network connectivity failed"
class BGPMonitor:
def __init__(self):
self.birdc_path = '/usr/bin/birdc'
self.bird6c_path = '/usr/bin/bird6c'
def execute_birdc_command(self, command: str, ipv6: bool = False) -> tuple:
"""Выполняет команду через birdc"""
try:
birdc = self.bird6c_path if ipv6 else self.birdc_path
result = subprocess.run(
[birdc] + command.split(),
capture_output=True,
text=True,
timeout=30
)
if result.returncode == 0:
return True, result.stdout
else:
return False, result.stderr
except subprocess.TimeoutExpired:
return False, "Timeout при выполнении команды"
except Exception as e:
return False, str(e)
def get_protocols_status(self, ipv6: bool = False) -> Dict:
"""Получает статус всех протоколов"""
success, output = self.execute_birdc_command("show protocols", ipv6)
if not success:
return {}
protocols = {}
current_protocol = None
for line in output.split('\n'):
line = line.strip()
if not line:
continue
# Находим имя протокола
if line.startswith('name') and 'state' in line:
parts = line.split()
if len(parts) >= 3:
protocol_name = parts[1]
state = parts[2]
protocols[protocol_name] = {
'state': state,
'info': {}
}
current_protocol = protocol_name
# Парсим дополнительную информацию
elif current_protocol and ':' in line:
key, value = line.split(':', 1)
key = key.strip()
value = value.strip()
protocols[current_protocol]['info'][key] = value
return protocols
def get_routes_count(self, ipv6: bool = False) -> Dict:
"""Получает количество маршрутов"""
success, output = self.execute_birdc_command("show route count", ipv6)
if not success:
return {}
routes_info = {}
for line in output.split('\n'):
line = line.strip()
if ':' in line:
key, value = line.split(':', 1)
key = key.strip()
value = value.strip()
routes_info[key] = value
return routes_info
def get_bgp_peers(self, ipv6: bool = False) -> List[Dict]:
"""Получает информацию о BGP пирах"""
protocols = self.get_protocols_status(ipv6)
bgp_peers = []
for name, info in protocols.items():
if name.startswith('bgp') and info['state'] == 'up':
peer_info = {
'name': name,
'state': info['state'],
'remote_ip': info['info'].get('Neighbor address', 'Unknown'),
'remote_as': info['info'].get('Neighbor AS', 'Unknown'),
'uptime': info['info'].get('Uptime', 'Unknown'),
'routes_received': info['info'].get('Routes received', '0'),
'routes_exported': info['info'].get('Routes exported', '0')
}
bgp_peers.append(peer_info)
return bgp_peers
def get_system_stats(self) -> Dict:
"""Получает системную статистику"""
stats = {
'timestamp': datetime.now().isoformat(),
'uptime': self.get_uptime(),
'memory_usage': self.get_memory_usage(),
'cpu_usage': self.get_cpu_usage(),
'disk_usage': self.get_disk_usage()
}
return stats
def get_uptime(self) -> str:
"""Получает время работы системы"""
try:
with open('/proc/uptime', 'r') as f:
uptime_seconds = float(f.read().split()[0])
days = int(uptime_seconds // 86400)
hours = int((uptime_seconds % 86400) // 3600)
minutes = int((uptime_seconds % 3600) // 60)
return f"{days}d {hours}h {minutes}m"
except:
return "Unknown"
def get_memory_usage(self) -> Dict:
"""Получает использование памяти"""
try:
with open('/proc/meminfo', 'r') as f:
lines = f.readlines()
mem_info = {}
for line in lines:
if ':' in line:
key, value = line.split(':', 1)
key = key.strip()
value = int(value.split()[0])
mem_info[key] = value
total = mem_info.get('MemTotal', 0)
available = mem_info.get('MemAvailable', 0)
used = total - available
usage_percent = (used / total * 100) if total > 0 else 0
return {
'total_mb': total // 1024,
'used_mb': used // 1024,
'available_mb': available // 1024,
'usage_percent': round(usage_percent, 1)
}
except:
return {'error': 'Unable to read memory info'}
def get_cpu_usage(self) -> Dict:
"""Получает использование CPU"""
try:
with open('/proc/loadavg', 'r') as f:
load_avg = f.read().split()
return {
'load_1min': float(load_avg[0]),
'load_5min': float(load_avg[1]),
'load_15min': float(load_avg[2])
}
except:
return {'error': 'Unable to read CPU info'}
def get_disk_usage(self) -> Dict:
"""Получает использование диска"""
try:
result = subprocess.run(
['df', '-h', '/'],
capture_output=True,
text=True
)
if result.returncode == 0:
lines = result.stdout.split('\n')
if len(lines) >= 2:
parts = lines[1].split()
if len(parts) >= 5:
return {
'total': parts[1],
'used': parts[2],
'available': parts[3],
'usage_percent': parts[4]
}
except:
pass
return {'error': 'Unable to read disk info'}
def check_bird_service_status(self) -> Dict:
"""Проверяет статус сервиса BIRD"""
try:
result = subprocess.run(
['systemctl', 'is-active', 'bird'],
capture_output=True,
text=True
)
bird_status = result.stdout.strip()
result = subprocess.run(
['systemctl', 'is-active', 'bird6'],
capture_output=True,
text=True
)
bird6_status = result.stdout.strip()
return {
'bird': bird_status,
'bird6': bird6_status,
'timestamp': datetime.now().isoformat()
}
except:
return {'error': 'Unable to check service status'}
def generate_report(self, output_format: str = 'text') -> str:
"""Генерирует отчет о состоянии BGP сервера"""
report = {
'timestamp': datetime.now().isoformat(),
'system': self.get_system_stats(),
'services': self.check_bird_service_status(),
'ipv4': {
'protocols': self.get_protocols_status(False),
'routes': self.get_routes_count(False),
'bgp_peers': self.get_bgp_peers(False)
},
'ipv6': {
'protocols': self.get_protocols_status(True),
'routes': self.get_routes_count(True),
'bgp_peers': self.get_bgp_peers(True)
}
}
if output_format == 'json':
return json.dumps(report, indent=2)
else:
return self.format_text_report(report)
def format_text_report(self, report: Dict) -> str:
"""Форматирует отчет в текстовом виде"""
output = []
output.append("=" * 60)
output.append("BGP SERVER STATUS REPORT")
output.append("=" * 60)
output.append(f"Time: {report['timestamp']}")
output.append("")
# Системная информация
output.append("SYSTEM INFORMATION:")
output.append("-" * 20)
sys_info = report['system']
output.append(f"Uptime: {sys_info['uptime']}")
if 'memory_usage' in sys_info and 'usage_percent' in sys_info['memory_usage']:
mem = sys_info['memory_usage']
output.append(f"Memory: {mem['used_mb']}MB / {mem['total_mb']}MB ({mem['usage_percent']}%)")
if 'cpu_usage' in sys_info and 'load_1min' in sys_info['cpu_usage']:
cpu = sys_info['cpu_usage']
output.append(f"Load Average: {cpu['load_1min']:.2f} (1min), {cpu['load_5min']:.2f} (5min), {cpu['load_15min']:.2f} (15min)")
output.append("")
# Статус сервисов
output.append("SERVICE STATUS:")
output.append("-" * 15)
services = report['services']
output.append(f"BIRD (IPv4): {services.get('bird', 'Unknown')}")
output.append(f"BIRD (IPv6): {services.get('bird6', 'Unknown')}")
output.append("")
# BGP пиры IPv4
output.append("BGP PEERS (IPv4):")
output.append("-" * 18)
ipv4_peers = report['ipv4']['bgp_peers']
if ipv4_peers:
for peer in ipv4_peers:
output.append(f" {peer['name']}: {peer['remote_ip']} (AS{peer['remote_as']}) - {peer['state']}")
output.append(f" Uptime: {peer['uptime']}, Routes: {peer['routes_exported']} exported")
else:
output.append(" No active BGP peers")
output.append("")
# BGP пиры IPv6
output.append("BGP PEERS (IPv6):")
output.append("-" * 18)
ipv6_peers = report['ipv6']['bgp_peers']
if ipv6_peers:
for peer in ipv6_peers:
output.append(f" {peer['name']}: {peer['remote_ip']} (AS{peer['remote_as']}) - {peer['state']}")
output.append(f" Uptime: {peer['uptime']}, Routes: {peer['routes_exported']} exported")
else:
output.append(" No active BGP peers")
output.append("")
# Статистика маршрутов
output.append("ROUTE STATISTICS:")
output.append("-" * 18)
ipv4_routes = report['ipv4']['routes']
ipv6_routes = report['ipv6']['routes']
if ipv4_routes:
output.append("IPv4 Routes:")
for key, value in ipv4_routes.items():
output.append(f" {key}: {value}")
if ipv6_routes:
output.append("IPv6 Routes:")
for key, value in ipv6_routes.items():
output.append(f" {key}: {value}")
output.append("=" * 60)
return "\n".join(output)
def monitor_continuously(self, interval: int = 60):
"""Непрерывный мониторинг с заданным интервалом"""
print(f"Starting continuous monitoring (interval: {interval}s)")
print("Press Ctrl+C to stop")
try:
while True:
report = self.generate_report('text')
print(report)
time.sleep(interval)
except KeyboardInterrupt:
print("\nMonitoring stopped")
def main():
"""Основная функция мониторинга"""
print("=== BGP Server Monitoring ===")
print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print()
"""Основная функция"""
import argparse
# Проверка контейнера
print("1. Container Status:")
status, details = check_container_status()
print(f" Status: {'✓ Running' if status else '✗ Stopped'}")
print(f" Details: {details}")
print()
parser = argparse.ArgumentParser(description='BGP Monitor')
parser.add_argument('--format', '-f', choices=['text', 'json'], default='text',
help='Output format (text or json)')
parser.add_argument('--continuous', '-c', action='store_true',
help='Continuous monitoring')
parser.add_argument('--interval', '-i', type=int, default=60,
help='Monitoring interval in seconds (default: 60)')
# Проверка сети
print("2. Network Connectivity:")
net_ok, net_details = check_network_connectivity()
print(f" Status: {'✓ OK' if net_ok else '✗ Failed'}")
print(f" Details: {net_details}")
print()
args = parser.parse_args()
# Проверка BGP сессии
print("3. BGP Session:")
bgp_ok, bgp_details = check_bgp_session()
print(f" Status: {'✓ Active' if bgp_ok else '✗ Inactive'}")
if bgp_ok:
print(f" Details: {bgp_details[:200]}...")
monitor = BGPMonitor()
if args.continuous:
monitor.monitor_continuously(args.interval)
else:
print(f" Details: {bgp_details}")
print()
# Проверка префиксов
print("4. Prefixes:")
prefix_ok, prefix_details = check_prefixes()
print(f" Status: {'✓ Loaded' if prefix_ok else '✗ Not loaded'}")
print(f" Details: {prefix_details}")
print()
# Общий статус
overall_status = status and net_ok and bgp_ok and prefix_ok
print("=== Overall Status ===")
print(f"Status: {'✓ HEALTHY' if overall_status else '✗ UNHEALTHY'}")
return 0 if overall_status else 1
report = monitor.generate_report(args.format)
print(report)
if __name__ == "__main__":
sys.exit(main())
main()
scripts/reload_prefixes.py
-104
View File
@@ -1,104 +0,0 @@
#!/usr/bin/env python3
"""
Скрипт для перезагрузки префиксов без перезапуска BGP сервера
"""
import subprocess
import sys
import time
from pathlib import Path
def run_command(cmd):
"""Выполнение команды"""
try:
result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
return result.returncode == 0, result.stdout, result.stderr
except Exception as e:
return False, "", str(e)
def reload_prefixes():
"""Перезагрузка префиксов"""
print("Reloading prefixes...")
# Остановка процесса загрузки префиксов
print("Stopping prefix loader process...")
success, output, error = run_command("docker exec bgp-server pkill -f load_prefixes.py")
if not success:
print("Warning: Could not stop prefix loader process")
# Ожидание завершения процесса
time.sleep(2)
# Проверка что процесс остановлен
success, output, error = run_command("docker exec bgp-server pgrep -f load_prefixes.py")
if success:
print("Error: Prefix loader process is still running")
return False
print("Prefix loader process stopped successfully")
# Запуск нового процесса загрузки префиксов
print("Starting new prefix loader process...")
success, output, error = run_command("docker exec bgp-server /app/scripts/load_prefixes.py &")
if success:
print("Prefix loader process started successfully")
return True
else:
print(f"Error starting prefix loader: {error}")
return False
def check_status():
"""Проверка статуса после перезагрузки"""
print("Checking status...")
time.sleep(5)
# Проверка процесса
success, output, error = run_command("docker exec bgp-server pgrep -f load_prefixes.py")
if success:
print("✓ Prefix loader process is running")
else:
print("✗ Prefix loader process is not running")
return False
# Проверка логов
success, output, error = run_command("docker exec bgp-server tail -n 5 /app/logs/prefixes.log")
if success:
print("Recent log entries:")
print(output)
else:
print("No recent log entries found")
return True
def main():
"""Основная функция"""
print("=== BGP Prefix Reloader ===")
# Проверка что контейнер запущен
success, output, error = run_command("docker ps --filter name=bgp-server --format '{{.Status}}'")
if not success or not output.strip():
print("Error: BGP server container is not running")
print("Please start the container first: docker-compose up -d")
return 1
print("BGP server container is running")
# Перезагрузка префиксов
if reload_prefixes():
print("Prefix reload completed successfully")
# Проверка статуса
if check_status():
print("✓ All checks passed")
return 0
else:
print("✗ Some checks failed")
return 1
else:
print("✗ Prefix reload failed")
return 1
if __name__ == "__main__":
sys.exit(main())
scripts/start-server.ps1
-96
View File
@@ -1,96 +0,0 @@
# PowerShell скрипт для запуска BGP сервера
param(
[switch]$Build,
[switch]$Logs,
[switch]$Monitor
)
Write-Host "=== BGP Server Management ===" -ForegroundColor Green
# Проверка Docker
Write-Host "Checking Docker..." -ForegroundColor Yellow
try {
docker --version | Out-Null
Write-Host "✓ Docker is available" -ForegroundColor Green
} catch {
Write-Host "✗ Docker is not available. Please install Docker Desktop." -ForegroundColor Red
exit 1
}
# Проверка Docker Compose
Write-Host "Checking Docker Compose..." -ForegroundColor Yellow
try {
docker-compose --version | Out-Null
Write-Host "✓ Docker Compose is available" -ForegroundColor Green
} catch {
Write-Host "✗ Docker Compose is not available." -ForegroundColor Red
exit 1
}
# Создание необходимых директорий
Write-Host "Creating directories..." -ForegroundColor Yellow
if (!(Test-Path "logs")) {
New-Item -ItemType Directory -Path "logs" | Out-Null
Write-Host "✓ Created logs directory" -ForegroundColor Green
}
if (!(Test-Path "data")) {
New-Item -ItemType Directory -Path "data" | Out-Null
Write-Host "✓ Created data directory" -ForegroundColor Green
}
# Сборка образа если требуется
if ($Build) {
Write-Host "Building Docker image..." -ForegroundColor Yellow
docker-compose build
if ($LASTEXITCODE -ne 0) {
Write-Host "✗ Build failed" -ForegroundColor Red
exit 1
}
Write-Host "✓ Build completed" -ForegroundColor Green
}
# Остановка существующего контейнера
Write-Host "Stopping existing container..." -ForegroundColor Yellow
docker-compose down 2>$null
Write-Host "✓ Existing container stopped" -ForegroundColor Green
# Запуск сервера
Write-Host "Starting BGP server..." -ForegroundColor Yellow
docker-compose up -d
if ($LASTEXITCODE -eq 0) {
Write-Host "✓ BGP server started successfully" -ForegroundColor Green
# Ожидание запуска
Write-Host "Waiting for server to initialize..." -ForegroundColor Yellow
Start-Sleep -Seconds 10
# Проверка статуса
Write-Host "Checking server status..." -ForegroundColor Yellow
$status = docker-compose ps
Write-Host $status
if ($Logs) {
Write-Host "Showing logs..." -ForegroundColor Yellow
docker-compose logs -f bgp-server
}
if ($Monitor) {
Write-Host "Starting monitoring..." -ForegroundColor Yellow
docker exec bgp-server python3 /app/scripts/monitor.py
}
} else {
Write-Host "✗ Failed to start BGP server" -ForegroundColor Red
Write-Host "Check logs with: docker-compose logs bgp-server" -ForegroundColor Yellow
exit 1
}
Write-Host "=== Setup Complete ===" -ForegroundColor Green
Write-Host "Useful commands:" -ForegroundColor Cyan
Write-Host " View logs: docker-compose logs -f bgp-server" -ForegroundColor White
Write-Host " Check status: docker-compose ps" -ForegroundColor White
Write-Host " Stop server: docker-compose down" -ForegroundColor White
Write-Host " Monitor: docker exec bgp-server python3 /app/scripts/monitor.py" -ForegroundColor White
scripts/start.sh
-239
View File
@@ -1,239 +0,0 @@
#!/bin/bash
# Скрипт запуска BGP сервера
set -e
echo "Starting BGP Server..."
# Создание директорий если не существуют
mkdir -p /app/logs
mkdir -p /app/run
mkdir -p /run/exabgp
mkdir -p /app/data
# Установка правильных прав доступа
chmod 755 /app/logs
chmod 755 /app/run
chmod 755 /run/exabgp
chmod 755 /app/data
# Удаление старых named pipes если они существуют
echo "Cleaning up old named pipes..."
for dir in /run/exabgp /var/run/exabgp /usr/local/run/exabgp /usr/local/var/run/exabgp; do
if [ -d "$dir" ]; then
echo "Cleaning $dir..."
rm -f $dir/exabgp.in $dir/exabgp.out
rmdir $dir 2>/dev/null || true
fi
done
# Создание named pipes для CLI в стандартном месте
echo "Creating named pipes for ExaBGP CLI..."
for dir in /run/exabgp /var/run/exabgp /usr/local/run/exabgp /usr/local/var/run/exabgp; do
mkdir -p $dir
echo "Creating named pipes in $dir..."
# Проверяем, существуют ли уже named pipes
if [ ! -p "$dir/exabgp.in" ]; then
mkfifo $dir/exabgp.in
chmod 666 $dir/exabgp.in
echo "Created $dir/exabgp.in"
else
echo "Named pipe $dir/exabgp.in already exists"
fi
if [ ! -p "$dir/exabgp.out" ]; then
mkfifo $dir/exabgp.out
chmod 666 $dir/exabgp.out
echo "Created $dir/exabgp.out"
else
echo "Named pipe $dir/exabgp.out already exists"
fi
done
# Проверка наличия файлов с префиксами
if [ ! -f "/app/data/prefixes.txt" ]; then
echo "Warning: /app/data/prefixes.txt not found. Creating empty file."
echo "# Default prefixes file" > /app/data/prefixes.txt
echo "192.168.1.0/24" >> /app/data/prefixes.txt
fi
# Создание лог-файлов с правильными правами
echo "Creating log files with proper permissions..."
touch /app/logs/prefixes.log
touch /app/logs/exabgp.log
chmod 666 /app/logs/prefixes.log
chmod 666 /app/logs/exabgp.log
echo "Prefixes file content:"
cat /app/data/prefixes.txt
echo "---"
# Проверка прав доступа к файлам
echo "Checking file permissions:"
ls -la /app/data/
ls -la /app/scripts/
echo "---"
# Генерация конфигурации из переменных окружения
echo "Generating ExaBGP configuration from environment variables..."
echo "Environment variables:"
env | grep BGP_ || echo "No BGP_ variables found"
echo "---"
python3 /app/scripts/generate_config.py
# Проверка конфигурации
echo "Validating ExaBGP configuration..."
echo "Configuration file content:"
cat /app/exabgp.conf
echo "---"
exabgp --validate /app/exabgp.conf
# Тестовый запуск скрипта загрузки префиксов
echo "Testing prefix loader script..."
python3 /app/scripts/load_prefixes.py --test 2>&1 || echo "Prefix loader test failed (this is normal)"
echo "---"
# Проверка сетевого подключения
echo "Checking network connectivity..."
NEIGHBOR_IP=${BGP_NEIGHBOR_IP:-192.168.1.1}
if ping -c 1 $NEIGHBOR_IP > /dev/null 2>&1; then
echo "Network connectivity to $NEIGHBOR_IP: OK"
else
echo "Warning: Cannot reach $NEIGHBOR_IP. BGP session may not establish."
fi
# Запуск ExaBGP в фоновом режиме с логированием
echo "Starting ExaBGP..."
LOG_LEVEL=${BGP_LOG_LEVEL:-INFO}
# Дополнительная проверка конфигурационного файла
echo "Final config file check:"
ls -la /app/exabgp.conf
echo "Config file first few lines:"
head -10 /app/exabgp.conf
echo "---"
# Проверка что ExaBGP может прочитать файл
echo "Testing ExaBGP config validation:"
if exabgp --validate /app/exabgp.conf; then
echo "Configuration validation passed"
else
echo "Configuration validation failed"
echo "Full config content:"
cat /app/exabgp.conf
exit 1
fi
echo "---"
# Проверка переменных окружения и путей
echo "Environment check:"
echo "PWD: $PWD"
echo "PATH: $PATH"
echo "PYTHONPATH: $PYTHONPATH"
echo "BGP_ variables:"
env | grep BGP_ || echo "No BGP_ variables found"
echo "---"
# Запуск ExaBGP
echo "Starting ExaBGP with config: /app/exabgp.conf"
# Проверяем что файл существует и читается
if [ ! -f "/app/exabgp.conf" ]; then
echo "ERROR: Configuration file /app/exabgp.conf not found!"
exit 1
fi
if [ ! -r "/app/exabgp.conf" ]; then
echo "ERROR: Configuration file /app/exabgp.conf is not readable!"
exit 1
fi
# Запуск ExaBGP с правильными параметрами
cd /app
echo "Starting ExaBGP in background..."
# Запуск ExaBGP в фоновом режиме
if [ -n "$LOG_LEVEL" ]; then
nohup exabgp --log.level $LOG_LEVEL /app/exabgp.conf > /app/logs/exabgp.log 2>&1 &
else
nohup exabgp /app/exabgp.conf > /app/logs/exabgp.log 2>&1 &
fi
EXABGP_PID=$!
# Проверяем что процесс запустился
sleep 5
echo "Checking if ExaBGP process is running..."
ps aux | grep exabgp | grep -v grep || echo "No exabgp process found in ps"
if ! kill -0 $EXABGP_PID 2>/dev/null; then
echo "Failed to start ExaBGP. Checking logs:"
cat /app/logs/exabgp.log
echo "Trying to run ExaBGP directly for diagnosis:"
exabgp --version
echo "---"
echo "Direct execution test:"
timeout 10 exabgp /app/exabgp.conf || echo "Direct execution completed"
exit 1
fi
# Сохранение PID
echo $EXABGP_PID > /app/logs/exabgp.pid
# Ожидание запуска
sleep 5
# Проверка статуса
if kill -0 $EXABGP_PID 2>/dev/null; then
echo "ExaBGP started successfully with PID: $EXABGP_PID"
echo "Recent logs:"
tail -10 /app/logs/exabgp.log
# Дополнительная проверка через несколько секунд
sleep 3
if kill -0 $EXABGP_PID 2>/dev/null; then
echo "ExaBGP is still running after 3 seconds"
echo "Process details:"
ps aux | grep exabgp | grep -v grep || echo "Process not found in ps output"
else
echo "ExaBGP process died after startup"
echo "Full logs:"
cat /app/logs/exabgp.log
exit 1
fi
else
echo "Failed to start ExaBGP"
echo "Full logs:"
cat /app/logs/exabgp.log
echo "---"
echo "Process status:"
ps aux | grep exabgp || echo "No exabgp process found"
exit 1
fi
# Функция для graceful shutdown
cleanup() {
echo "Shutting down BGP server..."
if [ -f "/app/logs/exabgp.pid" ]; then
kill $(cat /app/logs/exabgp.pid) 2>/dev/null || true
fi
exit 0
}
# Обработка сигналов
trap cleanup SIGTERM SIGINT
# Ожидание завершения
echo "Waiting for ExaBGP to run..."
echo "Process status:"
ps aux | grep exabgp || echo "No exabgp process found"
echo "---"
# Проверка процесса загрузки префиксов
echo "Checking prefix loader process:"
ps aux | grep load_prefixes || echo "No prefix loader process found"
echo "---"
wait $EXABGP_PID
scripts/stop-server.ps1
-33
View File
@@ -1,33 +0,0 @@
# PowerShell скрипт для остановки BGP сервера
Write-Host "=== Stopping BGP Server ===" -ForegroundColor Yellow
# Проверка что контейнер запущен
$containerStatus = docker ps --filter name=bgp-server --format "{{.Status}}"
if (!$containerStatus) {
Write-Host "BGP server is not running" -ForegroundColor Yellow
exit 0
}
Write-Host "BGP server is running. Stopping..." -ForegroundColor Yellow
# Остановка контейнера
docker-compose down
if ($LASTEXITCODE -eq 0) {
Write-Host "✓ BGP server stopped successfully" -ForegroundColor Green
} else {
Write-Host "✗ Failed to stop BGP server" -ForegroundColor Red
exit 1
}
# Проверка что контейнер остановлен
$containerStatus = docker ps --filter name=bgp-server --format "{{.Status}}"
if (!$containerStatus) {
Write-Host "✓ Container is stopped" -ForegroundColor Green
} else {
Write-Host "✗ Container is still running" -ForegroundColor Red
exit 1
}
Write-Host "=== BGP Server Stopped ===" -ForegroundColor Green
scripts/update-container.ps1
-92
View File
@@ -1,92 +0,0 @@
# Скрипт для безопасного обновления BGP Server контейнера
param(
[string]$ContainerName = "bgp-server",
[string]$ImageName = "git.shts.su/infra/bgp-server:latest",
[string]$DataPath = "./data",
[string]$LogsPath = "./logs",
[switch]$Force
)
Write-Host "=== BGP Server Container Update Script ===" -ForegroundColor Green
# Проверка существования контейнера
$containerExists = docker ps -a --filter "name=$ContainerName" --format "table {{.Names}}" | Select-String $ContainerName
if ($containerExists) {
Write-Host "Found existing container: $ContainerName" -ForegroundColor Yellow
if (-not $Force) {
$response = Read-Host "Do you want to update the container? (y/N)"
if ($response -ne "y" -and $response -ne "Y") {
Write-Host "Update cancelled." -ForegroundColor Red
exit 0
}
}
# Остановка и удаление старого контейнера
Write-Host "Stopping container..." -ForegroundColor Yellow
docker stop $ContainerName
Write-Host "Removing container..." -ForegroundColor Yellow
docker rm $ContainerName
} else {
Write-Host "No existing container found. Creating new one..." -ForegroundColor Green
}
# Создание директорий если не существуют
if (-not (Test-Path $DataPath)) {
Write-Host "Creating data directory: $DataPath" -ForegroundColor Yellow
New-Item -ItemType Directory -Path $DataPath -Force | Out-Null
}
if (-not (Test-Path $LogsPath)) {
Write-Host "Creating logs directory: $LogsPath" -ForegroundColor Yellow
New-Item -ItemType Directory -Path $LogsPath -Force | Out-Null
}
# Загрузка нового образа
Write-Host "Pulling latest image..." -ForegroundColor Yellow
docker pull $ImageName
if ($LASTEXITCODE -ne 0) {
Write-Host "Failed to pull image. Exiting." -ForegroundColor Red
exit 1
}
# Запуск нового контейнера
Write-Host "Starting new container..." -ForegroundColor Yellow
$currentPath = Get-Location
$dataVolume = "${currentPath}\${DataPath}:/app/data:ro"
$logsVolume = "${currentPath}\${LogsPath}:/app/logs"
docker run -d `
--name $ContainerName `
--restart unless-stopped `
-p 179:179 `
-v $dataVolume `
-v $logsVolume `
$ImageName
if ($LASTEXITCODE -eq 0) {
Write-Host "Container started successfully!" -ForegroundColor Green
# Ожидание запуска
Write-Host "Waiting for container to start..." -ForegroundColor Yellow
Start-Sleep -Seconds 5
# Проверка статуса
$status = docker ps --filter "name=$ContainerName" --format "table {{.Status}}"
Write-Host "Container status: $status" -ForegroundColor Cyan
# Показ логов
Write-Host "Recent logs:" -ForegroundColor Cyan
docker logs --tail=10 $ContainerName
Write-Host "`nContainer update completed successfully!" -ForegroundColor Green
Write-Host "To view logs: docker logs -f $ContainerName" -ForegroundColor Cyan
Write-Host "To check status: docker ps" -ForegroundColor Cyan
} else {
Write-Host "Failed to start container. Check the error above." -ForegroundColor Red
exit 1
}
simple_fix.sh
+100
View File
@@ -0,0 +1,100 @@
#!/bin/bash
# Простой скрипт для исправления конфигурации BIRD
# Ubuntu 24.04
set -e
echo "=========================================="
echo "Простое исправление конфигурации BIRD"
echo "Ubuntu 24.04"
echo "=========================================="
# Получаем IP адрес сервера
SERVER_IP=$(curl -s ifconfig.me 2>/dev/null || echo "192.168.1.1")
echo "[INFO] Используется IP адрес: $SERVER_IP"
# Останавливаем BIRD если запущен
echo "[INFO] Остановка BIRD..."
systemctl stop bird 2>/dev/null || true
# Создаем резервную копию текущей конфигурации
if [ -f /etc/bird/bird.conf ]; then
cp /etc/bird/bird.conf /etc/bird/bird.conf.backup.$(date +%Y%m%d_%H%M%S)
echo "[INFO] Создана резервная копия: /etc/bird/bird.conf.backup"
fi
# Создаем простую рабочую конфигурацию
echo "[INFO] Создание простой конфигурации BIRD..."
cat > /etc/bird/bird.conf << EOF
# Простая конфигурация BIRD для BGP сервера
# Ubuntu 24.04
# Logging
log stderr all;
log "/var/log/bird/bird.log" all;
# Router ID
router id $SERVER_IP;
# Device protocol
protocol device {
scan time 10;
}
# Direct protocol (disabled)
protocol direct {
disabled;
}
# Kernel protocol (disabled)
protocol kernel {
disabled;
}
# Static routes
protocol static {
# Статические маршруты будут загружаться через скрипт
}
# BGP protocol - принимаем любых пиров
protocol bgp any_peer {
local as 65001;
listen bgp port 179;
import none; # Не принимаем маршруты от пиров
export where source = RTS_STATIC; # Экспортируем только статические маршруты
}
EOF
echo "[SUCCESS] Конфигурация создана"
# Создаем директорию для логов если не существует
mkdir -p /var/log/bird
chown bird:bird /var/log/bird 2>/dev/null || true
# Запускаем BIRD
echo "[INFO] Запуск BIRD..."
systemctl start bird
# Проверяем статус
if systemctl is-active --quiet bird; then
echo "[SUCCESS] BIRD успешно запущен"
# Показываем статус
echo "[INFO] Статус BIRD:"
systemctl status bird --no-pager -l
# Показываем информацию о протоколах
echo "[INFO] Информация о протоколах:"
birdc show protocols 2>/dev/null || echo "birdc недоступен"
else
echo "[ERROR] Не удалось запустить BIRD"
echo "[INFO] Логи BIRD:"
journalctl -u bird --no-pager -l -n 20
exit 1
fi
echo "[SUCCESS] Конфигурация BIRD исправлена и сервис запущен"
echo "[INFO] BIRD слушает на порту 179 и принимает соединения от любых пиров"
echo "[INFO] Сервер НЕ будет принимать префиксы от пиров, только экспортировать свои"