Подготовка

Для начала немного разберемся что у нас есть. А есть у нас нейронные сети и знания о том, что они очень медленно работают на CPU, а для ускорения нужно иметь GPU. Но хочется на CPU.

Далее есть ОС «Форточка» и «Пингвин». Я буду делать в пингвинах.

Теперь нужны программы для работы. Я использовал llama.cpp и koboldcpp. Первая нужна для подготовки моделей, а вторая для их непосредственного запуска. Можно и в первой запускать модели, но есть, как оказывается, нюансы.

Закидываем к себе в закладки Hugging Face, так как отсюда будем забирать модели.

И так, у меня на текущий момент установлен Debian 12, а это значит, что будем ставить пакеты в нем. Ставим недостающие пакеты:

sudo apt install build-essential libopenblas-dev git git-lfs python3-pip

Для питона, если еще не сделано, то создаем файл ~/.config/pip/pip.conf и записываем в него следующее содержимое:

[global] break-system-packages = true

Этот файл нужен, чтобы можно было установить пакеты питона, если не удается их установить, а они понадобятся (благо их немного).

Компиляция

Качаем софт:

git clone https://github.com/ggerganov/llama.cpp

git clone https://github.com/LostRuins/koboldcpp

Переходим в директорию llama.cpp и ставим пакеты:

pip install -r requirements.txt

И собираем саму приложуху.

make

Теперь переходим в koboldcpp и ставим пакеты оттуда:

pip install -r requirements.txt

И собираем пакет:

LLAMA_OPENBLAS=1 make

Вот тут есть нюанс. Дело в том, что в Linux нужна дополнительная для работы этого движка (если честно я не сильно разобрался). Но… openBLAS нам подходит. Можно собрать с поддержкой cuBLAS, но нужно установить CUDA, а для этого видеокарта должна поддерживать технологию. Кроме того нужно много библиотек и свежие драйвера. Если интересно как ставить, то идем сюда. Тут много умных слов, так что читаем и изучаем, если еще не в курсе. А это все нужно для установки компилятора nvcc и без него никак.

Модели

Я покажу 2 способа использования моделей.

Сборка модели из PyTorch

Есть модели, которые построены в PyTorch, но их нужно конвертировать в формат ggml. Для начала скачаем модель. Для этого рядом с директориями llama.cpp и koboldcpp, создадим директорию models и перейдем в нее. Теперь скачаем модель:

git clone https://huggingface.co/IlyaGusev/llama_7b_ru_turbo_alpaca_lora_merged

После скачивания перейдем обратно в llama.cpp и сделаем конвертирование:

python3 convert-pth-to-ggml.py ../models/llama_7b_ru_turbo_alpaca_lora_merged 1

Этой коммандой мы переводим формат PyTorch в GGML F16 (float16)

./quantize ../models/llama_7b_ru_turbo_alpaca_lora_merged/ggml-model.bin ../models/alpaca-7b-ru-q4_1.bin 3

Этой коммандой мы делаем «квантование», тем самым уменьшая объем модели. Да, в качестве мы тоже теряем, но нужна производительность.

Готовые модели

Вернемся в директорию models и загрузим нужные модели:

git clone https://huggingface.co/IlyaGusev/llama_7b_ru_turbo_alpaca_lora_llamacpp

git clone https://huggingface.co/IlyaGusev/llama_13b_ru_turbo_alpaca_lora_llamacpp

Соответственно первая весит 4ГБ, вторая около 8ГБ. Чтобы определить какая больше понравится, нужно поиграться с обеими.

Запуск

Теперь вернемся в koboldcpp и запустим какую-нибудь модель (у нас их 3):

python3 koboldcpp.py —model ../models/llama_7b_ru_turbo_alpaca_lora_llamacpp/7B/ggml-model-q4_0.bin —host 0.0.0.0 —port 8085

Это пример запуска модели. Можно открыть в браузере адрес localhost:8085 и пользоваться. Соответственно другие модели запускаются так же.

Нюанс

Если модель сконвертировать в llama.cpp, то можно запустить прямо в ней, но вот модели, загруженные уже готовыми то llama.cpp их не запустить (у меня падала с ошибкой) и вот тут приходит на помощь koboldcpp. К тому же мне показалось, что у него и возможностей побольше и поинтереснее (если ковырнуть UI и параметры которые он отправляет в запросе).

Ложка дёгтя

Во первых — это не оригинальный ChatGPT, во вторых модели 7B и 13B все же маленькие по сравнению с большими братьями, и в третьих llama — проект другой компании со своей лицензией.

Выводы

Проектов нейронных сетей в конкретно этом направлении достаточно много. В частности для этого кода основные, которые я лично нашел, 3 — llama, alpaca и vicuna. У Alpaca есть доученный русский корпус и он достаточно адекватен (на 7B и 13B).

Вообще такую модель можно запустить и на домашнем сервере.

Ранее уже было написано у меня о сборе логов с различных серверов и хранения их в единой БД. Сегодня будет заметка для сбора логов.

Софт и настройка

Логи нужно собирать, в первую очередь, с серверов, так что это достаточно важная задача. А вот чем собирать — вопрос. Можно отправлять файлы на сервер и там их парсить и анализировать. Можно поставить специальный софт, который сам это будет делать и отправлять на сервер готовые записи (этот больше подходит, так как удобнее). Теперь сам софт.

Я лично попробовал 2 программы: eventlog-to-syslog и nxlog. Первый был обновлен в 2013 году и отправляет на сервер логи в формате syslog, но то что он «пихает» все что можно в виде строки, в дальнейшем тяжело парсить. В итоге получается ну очень длинное регулярное выражение, в котором можно легко запутаться. Вторая софтина есть в 3х вариантах: Enterprise Edition, Manager и Community Edition. Первый вариант для корпоративных клиентов (платная), вторая для сообщества (бесплатная). В Community Edition есть ряд ограничений, но мне этого хватает: получение событий, преобразование в JSON, отправка на удаленный сервер по TCP и UDP.

Регистрируемся на сайте и скачиваем файл для винды. В итоге устанавливаем msi-файл. Далее по пути *C:\Program Files\nxlog\conf* (если не меняли стандартный путь) и файл nxlog.conf приводим к следующему виду:

Module      xm_syslog

Module      xm_charconv
AutodetectCharsets iso8859-2, utf-8, utf-16, utf-32

Module      xm_exec

Module      xm_fileop

# Check the size of our log file hourly, rotate if larger than 5MB

    Every   1 hour
    Exec    if (file_exists('%LOGFILE%') and \
               (file_size('%LOGFILE%') >= 5M)) \
                file_cycle('%LOGFILE%', 8);

# Rotate our log file every week on Sunday at midnight

    When    @weekly
    Exec    if file_exists('%LOGFILE%') file_cycle('%LOGFILE%', 8);

Module    xm_json

Module    im_msvistalog
Exec      to_json();

Snare compatible example configuration

Collecting event log

Module im_msvistalog

Converting events to Snare format and sending them out over TCP syslog

Module om_tcp

Host 192.168.1.1

Port 514

Exec to_syslog_snare();

Connect input ‘in’ to output ‘out’

Path in => out

Module    om_udp
Host      ip-адрес_сервера
Port      5517

Path        eventlog => udp

Я специально оставил стандартные тэги из оригинального файла, чтобы было проще и наглядней искать и ориентироваться в нем.

На сервере

Собирает у нас эти логи все тот же fluentd (winlog.conf):

@type udp tag winlog

@type json

port 5517 bind 0.0.0.0 message_length_limit 10MB

@type record_modifier

    EventTimeMillis ${time.nsec}

@type http open_timeout 2 endpoint http://clickhouse:port/?user=login&password=password&database=logs&query=INSERT%20INTO%20winlog%20FORMAT%20JSONEachRow

@type json

json_array true

flush_interval 10s

На забываем добавить строчку @include conf.d/winlog.conf в основной конфиг.

БД

Я думал ClickHouse меня пошлет на поляну одуванчики собирать, но пока что все обошлось:

CREATE TABLE IF NOT EXISTS logs.winlog ( EventTime DateTime, EventTimeMillis UInt64, Hostname String default ‘unknow’, Keywords Nullable(Int64), EventType Nullable(String), SeverityValue Nullable(Int16), Severity Nullable(String), EventID Nullable(Int32), SourceName Nullable(String), ProviderGuid Nullable(String), Version Nullable(Int32), Task Nullable(Int32), OpcodeValue Nullable(Int32), RecordNumber Nullable(Int64), ActivityID Nullable(String), CallerPID Nullable(String), ProcessID Nullable(Int32), ThreadID Nullable(Int32), Channel Nullable(String), SChannelName Nullable(String), SChannelType Nullable(String), Domain Nullable(String), AccountName Nullable(String), UserID Nullable(String), UserName Nullable(String), DomainName Nullable(String), WorkstationName Nullable(String), SessionId Nullable(String), LogonGuid Nullable(String), VolumeGuid Nullable(String), VolumeNameLength Nullable(String), VolumeName Nullable(String), VolumeLabelLength Nullable(String), VolumeLabel Nullable(String), Error Nullable(String), TransmittedServices Nullable(String), AccountType Nullable(String), Message Nullable(String), Category Nullable(String), TicketOptions Nullable(String), Opcode Nullable(String), CSEElaspedTimeInMilliSeconds Nullable(String), ErrorCode Nullable(String), CSEExtensionName Nullable(String), CSEExtensionId Nullable(String), operationName Nullable(String), OperationDescription Nullable(String), OperationElaspedTimeInMilliSeconds Nullable(String), PolicyActivityId Nullable(String), PolicyApplicationMode Nullable(String), PolicyDownloadTimeElapsedInMilliseconds Nullable(String), PrincipalSamName Nullable(String), IsMachine Nullable(String), IsDomainJoined Nullable(String), IsBackgroundProcessing Nullable(String), IsAsyncProcessing Nullable(String), IsServiceRestart Nullable(String), ReasonForSyncProcessing Nullable(String), Profiles Nullable(String), SettingType Nullable(String), SettingValueSize Nullable(String), SettingValue Nullable(String), SettingValueString Nullable(String), Origin Nullable(String), ModifyingUser Nullable(String), ModifyingApplication Nullable(String), Environment Nullable(String), EventsUploaded Nullable(String), EventsDropped Nullable(String), LastEventlogWrittenTime Nullable(String), PackageName Nullable(String), TargetUserName Nullable(String), TargetSid Nullable(String), TargetDomainName Nullable(String), ServiceName Nullable(String), ServiceSid Nullable(String), serviceStatus Nullable(String), Workstation Nullable(String), Status Nullable(String), TicketEncryptionType Nullable(String), PreAuthType Nullable(String), IpAddress Nullable(String), IpPort Nullable(String), PortNumber Nullable(String), PathID Nullable(String), TargetID Nullable(String), LUN Nullable(String), ClassDeviceGuid Nullable(String), AdapterGuid Nullable(String), BusType Nullable(String), MiniportName Nullable(String), VendorId Nullable(String), ProductId Nullable(String), RequestDuration_ms Nullable(String), WaitDuration_ms Nullable(String), Command Nullable(String), SrbStatus Nullable(String), ScsiStatus Nullable(String), SenseKey Nullable(String), AddSense Nullable(String), AddSenseQ Nullable(String), IoSize Nullable(String), QueueDepth Nullable(String), LBA Nullable(String), TaskInstanceId Nullable(String), EnginePID Nullable(String), LogString Nullable(String), SubjectUserSid Nullable(String), SubjectUserName Nullable(String), SubjectDomainName Nullable(String), SubjectLogonId Nullable(String), ObjectServer Nullable(String), ObjectType Nullable(String), ObjectName Nullable(String), HandleId Nullable(String), TransactionId Nullable(String), AccessList Nullable(String), AccessMask Nullable(String), PrivilegeList Nullable(String), ProcessName Nullable(String), ResourceAttributes Nullable(String), param1 Nullable(String), param2 Nullable(String), param3 Nullable(String), param4 Nullable(String), param5 Nullable(String), ClientLUID Nullable(String), ClientUserName Nullable(String), resourceUri Nullable(String), SMBShare Nullable(String), Vcb Nullable(String), ClientDomainName Nullable(String), TaskName Nullable(String), MechanismOID Nullable(String), OldSd Nullable(String), Reason Nullable(String), InstanceId Nullable(String), IsExtensionAsyncProcessing Nullable(String), exception Nullable(String), VolumeCorrelationId Nullable(String), DfsNamespace Nullable(String), NewSd Nullable(String), InfoDescription Nullable(String), SyncFromPDC Nullable(String), Type Nullable(String), Path Nullable(String), Priority Nullable(String), RefreshTriggerSource Nullable(String), SyncType Nullable(String), SamAccountName Nullable(String), Parameter Nullable(String), hrError Nullable(String), SidHistory Nullable(String), DCName Nullable(String), DCIPAddress Nullable(String), TimeConsumedInMilliSeconds Nullable(String), Machines Nullable(String), Dummy Nullable(String), DisplayName Nullable(String), DCDiscoveryTimeInMilliSeconds Nullable(String), UserNameLength Nullable(String), UserPrincipalName Nullable(String), MachineRole Nullable(String), ID Nullable(String), UserContext Nullable(String), DeviceGUID Nullable(String), CallerProcessId Nullable(String), CallerProcessName Nullable(String), PrincipalCNName Nullable(String), PrincipalDomainName Nullable(String), DCDomainName Nullable(String), serverName Nullable(String), namespaceName Nullable(String), wmiClassName Nullable(String), methodName Nullable(String), protocol Nullable(String), Name Nullable(String), DeviceNameLength Nullable(String), LowestFreeSpaceInBytes Nullable(String), IsBootVolume Nullable(String), ActionName Nullable(String), FolderId Nullable(String), HighIoLatencyCount Nullable(String), IntervalDurationUs Nullable(String), NCReadIOCount Nullable(String), NCReadTotalBytes Nullable(String), NCReadAvgLatencyNs Nullable(String), NCWriteIOCount Nullable(String), NCWriteTotalBytes Nullable(String), NCWriteAvgLatencyNs Nullable(String), FileFlushCount Nullable(String), FileFlushAvgLatencyNs Nullable(String), VolumeFlushCount Nullable(String), VolumeFlushAvgLatencyNs Nullable(String), FileLevelTrimCount Nullable(String), FileLevelTrimTotalBytes Nullable(String), FileLevelTrimExtentsCount Nullable(String), FileLevelTrimAvgLatencyNs Nullable(String), VolumeTrimCount Nullable(String), VolumeTrimTotalBytes Nullable(String), VolumeTrimExtentsCount Nullable(String), VolumeTrimAvgLatencyNs Nullable(String), IoBucketsCount Nullable(String), TotalBytesBucketsCount Nullable(String), ExtentsBucketsCount Nullable(String), IoCount Nullable(String), TotalLatencyUs Nullable(String), TotalBytes Nullable(String), TrimExtentsCount Nullable(String), IoTypeIndex Nullable(String), ServerNameLength Nullable(String), ServerName Nullable(String), AllNtpServers Nullable(String), TickCount Nullable(String), IFTSTMP Nullable(String), GPOList Nullable(String), XPath Nullable(String), LastError Nullable(String), PolicyProcessingMode Nullable(String), ResultCode Nullable(String), BandwidthInkbps Nullable(String), ComputerAccountChange Nullable(String), HomeDirectory Nullable(String), HomePath Nullable(String), ScriptPath Nullable(String), ProfilePath Nullable(String), UserWorkstations Nullable(String), PasswordLastSet Nullable(String), AccountExpires Nullable(String), PrimaryGroupId Nullable(String), AllowedToDelegateTo Nullable(String), OldUacValue Nullable(String), NewUacValue Nullable(String), UserAccountControl Nullable(String), UserParameters Nullable(String), LogonHours Nullable(String), DnsHostName Nullable(String), ServicePrincipalNames Nullable(String), IsSlowLink Nullable(String), ThresholdInkbps Nullable(String), LinkDescription Nullable(String), NumberOfGPOsDownloaded Nullable(String), NumberOfGPOsApplicable Nullable(String), GPODownloadTimeElapsedInMilliseconds Nullable(String), DescriptionString Nullable(String), GPOInfoList Nullable(String), IsGPOListChanged Nullable(String), GPOListStatusString Nullable(String), ApplicableGPOList Nullable(String), DeviceName Nullable(String), PolicyElaspedTimeInSeconds Nullable(String), IsConnectivityFailure Nullable(String), NextPolicyApplicationTime Nullable(String), NextPolicyApplicationTimeUnit Nullable(String), EventReceivedTime Nullable(DateTime), SourceModuleName Nullable(String), SourceModuleType Nullable(String) ) ENGINE = ReplacingMergeTree() PARTITION BY toDate(EventTime) ORDER BY (EventTime, EventTimeMillis, Hostname) TTL EventTime + toIntervalMonth(6) SETTINGS index_granularity = 8192;

Да, такая таблица получилась. Дальше только анализировать в различных инструментах.

Заключение

Собственно это все. После сбора определенного количества логов можно приступать к анализу деятельности узла, которое и хотим отслеживать. Судя по структуре так же можно в дальнейшем дела корреляцию между узлами, например, чтение файлов на файл-сервере и клиенте, который запрашивает этот файл и т.д.

Графики логов

Ну вот не знаю что с этим делать и как дальше жить. Из готового особо ничего такого не обнаружил (может все же плохо искал). Из того что есть — это графики логов, т.е. пишем специальный запрос и смотрим как это «красиво» рисуется.

Чем же смотреть

Из того что я нашел более простое в освоении и «красивое» — это Grafana.

Пример графика

Я думаю многие видели это решение, по этому не очень хочется заострять на нем внимание. Единственный момент — это работа с ClickHouse.

Подключение ClickHouse

Тут все предельно просто:

• Ставим плагин

Плагин в Grafana

2. Настраиваем подключение к БД

DataSource

3. Пишем запрос для отображения

Запрос для прокси-сервера

В принципе тут все. Все стандартненько.

Свое решение

Другой вариант — это собственное решение. Нам важнее было анализировать работу через proxy-сервер пользователей за какой-то период. Например нам нужно было узнать кто потратил трафик за период, на каких доменах тусовался, может даже ссылочки посмотреть какие видюшки рассматривал и т.д. Может я что-то в Grafana и не осилил, но собственное решение появилось раньше.

Так как это все тот же ClickHouse, и в нем выполняется самый обычный SQL, то для меня (а уже и для коллег, которые с SQL-запросами не работали, но научились) это проще. Ну лень мне учить очередной язык чего-то там супер модного.

Для начала можно написать запрос в каком-нибудь готовом UI, чтобы его отладить. Далее можно было бы сделать какую-то оболочку, в которую «загоняется» написанный запрос и при его вызове появлялась бы простенькая форма для ввода нужных значений и получения результата.

Само решение приводить не буду, так как оно ну оооочень и слиииишком сырое, но работает уже около полутора лет. Приведу только некоторые моменты…

Сама система написана в связке NodeJS (backend) + Angular и используется 2 коннектора для СУБД: SQLite (ORM Sequelize) иClickHouse. Собственно в SQLite хранятся разделы и непосредственно запросы. Тут тоже ничего сверхъестественного нет (2 таблицы). group.js:

'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Group extends Model {
    /**
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The `models/index` file will call this method automatically.
     */
    static associate(models) {
      // define association here
      Group.hasMany(models.Query, {
        foreignKey: 'id_group'
      });
    }
  };
  Group.init({
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true,
      allowNull: false
    },
    name: {
      type: DataTypes.STRING,
      allowNull: false
    },
    description: DataTypes.TEXT
  }, {
    sequelize,
    modelName: 'Group',
  });
  return Group;
};

и query.js:

'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Query extends Model {
    /**
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The `models/index` file will call this method automatically.
     */
    static associate(models) {
      // define association here
      Query.belongsTo(models.Group, {
        foreignKey: 'id_group'
      });
    }
  };
  Query.init({
    id: {
      type: DataTypes.UUID,
      primaryKey: true,
      allowNull: false,
      defaultValue: DataTypes.UUIDV4
    },
    name: {
      type: DataTypes.STRING,
      allowNulld: false
    },
    description: DataTypes.TEXT,
    querytext: {
      type: DataTypes.TEXT,
      allowNull: false
    }
  }, {
    sequelize,
    modelName: 'Query',
  });
  return Query;
};

Немного express.jsпо вкусу и в принципе всё (даже приводить не буду — все стандартно).

Собственно нужно выполнить запрос с параметрами. Для этого нужно как-то запрос параметризировать, да еще и вменяемые параметры для отображения использовать.

Решение получилось такое: берется самый обычный запрос и в месте, где должен быть параметр водставляется строка вида {{Название параметра}}. Такой параметр всегда будет принимать строку, а в коде будет самая обычная конкатенация строк (для простоты):

const re = /\{\{[\s\t]*[a-zа-я_]+[a-zа-я_0-9]+[\s\t]*\}\}/ig;

/**
 * Найдем все параметры в строке запроса
 * @param {string} querytext Текст запроса
 * @return Возвращает массив с параметрами
 */
function parsingQueryParams(querytext) {
    let m;
    let arr = [];
    do {
        m = re.exec(querytext);
        if (m) {
            console.log(m[0]);
            let tmp = /[a-zа-я_]+[a-zа-я_0-9]/i.exec(m[0])[0];
            if (arr.length === 0) {
                arr.push(tmp);
            } else {
                // Проверим не присутствует ли уже этот параметр
                let search = false;
                for (const str of arr) {
                    if (str === tmp) {
                        search = true;
                        break;
                    }
                }
                if (!search) {
                    arr.push(tmp);
                }
            }
            // arr.push(/[a-zа-я_]+[a-zа-я_0-9]/i.exec(m[0])[0]);
        }
    } while (m);
    return arr;
}

/**
 * Подготовка запроса для выполнения
 * @param {string} querytext Текст запроса
 * @param {Object} params Параметры ключ=знаяение
 * @return Возвращает строку с замененными параметрами
 */
function replaceQueryParams(querytext, params) {
    let m;
    do {
        m = re.exec(querytext);
        if (m) {
            let reTmp = m[0];
            let param = reTmp.replace(/[\{\{\}\}\s\t]+/gi, '');
            if (params.hasOwnProperty(param)) {
                querytext = querytext.replace(reTmp, params[param]);
            }
        }
    } while (m);
    return querytext;
}

module.exports = {
    parsingQueryParams: parsingQueryParams,
    replaceQueryParams: replaceQueryParams
}

Клиентский код тоже достаточно прост:

import { Component, Inject, Input, OnInit } from '@angular/core';
import { FormControl, FormGroup } from '@angular/forms';
import { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog';
import * as parsingQuery from '../../../../../server/libs/parsingQuery';
export interface DisplayField {
  name: string;
  display?: string;
}
@Component({
  selector: 'app-query-exec',
  templateUrl: './query-exec.component.html',
  styleUrls: ['./query-exec.component.styl']
})
export class QueryExecComponent implements OnInit {
  fields = new Array(0);
  form: FormGroup = new FormGroup({});
  constructor(
    public dialogRef: MatDialogRef,
    @Inject(MAT_DIALOG_DATA) public data: string
  ) { }
  ngOnInit(): void {
    const params = parsingQuery.parsingQueryParams(this.data);
    this.fields = new Array();
    for (const str of params) {
      let display: string = str.replace(/_{1,1000}/gi, ' ').trim().toLowerCase();
      display = display.trim().substr(0, 1).toUpperCase() + display.substr(1);
      this.fields.push({
        name: str,
        display
      });
    }
    for (const control of Object.keys(this.form.controls)) {
      this.form.removeControl(control);
    }
    for (const field of this.fields) {
      this.form.addControl(field.name, new FormControl());
    }
  }
  private prepareParams(): any {
    const result: any = {};
    result.params = {};
    for (const field of this.fields) {
      result.params[field.name] = this.form.value[field.name];
      /*result.params.push({
        name: field.name,
        value: this.form.value[field.name]
      });*/
    }
    return result;
  }
  queryTable(): void {
    const result: any = this.prepareParams();
    result.typeQuery = 'dataset';
    this.dialogRef.close(result);
  }
  queryGraph(): void {
    const result: any = this.prepareParams();
    result.typeQuery = 'graph';
    this.dialogRef.close(result);
    // TODO
  }
}

Ну и форма к ней:

    Параметры запроса

                    {{ field.display }}

            Таблица
            График

Собственно всё!

Результаты

В итоге свою задачу мы решили и пользуемся. Нам хватает с головой, при учете 6 серверов и около 200 пользователей.

ТОП-100 доменов по пользователю за день

Немного поразмыслив я решил использовать ClickHouse. Судя по обзорам достаточно быстрая (не зря же yandex ее создавали как раз для хранения большого объема и обработки аналитики). Можно было бы выбрать тот же PostgreSQL, MySQL (MariaDB), Elasticsearch… В общем все что угодно, но я остановился на этом варианте.

Установка

Для установки обращаемся к официальной документации и выполняем следующие команды:

sudo apt-get install -y apt-transport-https ca-certificates dirmngr
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 8919F6BD2B48D754

echo "deb https://packages.clickhouse.com/deb stable main" | sudo tee /etc/apt/sources.list.d/clickhouse.list
sudo apt-get update
sudo apt-get install -y clickhouse-server clickhouse-client
sudo service clickhouse-server start
clickhouse-client

Так как я это все разворачиваю на Debian, то и способ установки выбираю соответствующий. Вообще ничего сложного.

После установки рекомендую настроить сервер: установить пароль и настроить использование ресурсов (если нужно). Все это есть в документации.

Так же можно посмотреть в сторону какого-нибудь UI для удобства работы. Что-то конкретно рекомендовать не буду, так как в поисковике должно много чего найтись.

Структура

Для начала нужно создать саму базу:

CREATE DATABASE IF NOT EXISTS logs

Теперь создадим таблицы в БД. Для логов Nginx:

CREATE TABLE IF NOT EXISTS logs.nginx (
time DateTime,
dt_syslog String,
server String,
programm String,
remote String,
host String,
user String,
method String,
path String,
proto String,
code UInt16,
size UInt32,
referer String,
agent String,
http_x_forwarded_for String
)
ENGINE = ReplacingMergeTree() PARTITION BY (toDate(time), server, programm)
ORDER BY (time, server, programm, size)
TTL time + toIntervalMonth(6)
SETTINGS index_granularity = 8192;

Далее таблица для Postfix:

CREATE TABLE IF NOT EXISTS logs.postfix (
time DateTime,
server String,
daemon String,
process String,
process_id String,
connect_to_host String,
connect_to_ip String,
port UInt16,
status String,
connect_from String,
connect_ip_from String,
disconnect_from String,
disconnect_ip_from String,
ehlo Int16,
starttls Int16,
mail Int16,
rcpt Int16,
data Int32,
quit Int16,
commands Int16,
lost_conn_host String,
lost_conn_ip String,
queue_id String,
removed String,
client String,
client_ip String,
message_id String,
to String,
orig_to String,
relay_host String,
relay_ip String,
delay Float64,
delays String,
dsn String,
description String,
from String,
size UInt32,
nrcpt UInt16
)
ENGINE = ReplacingMergeTree() PARTITION BY (toDate(time), server, daemon, process)
ORDER BY (time, server, daemon, process, queue_id, message_id)
TTL time + toIntervalMonth(6)
SETTINGS index_granularity = 8192;

И в заключении таблица для Squid:

CREATE TABLE IF NOT EXISTS logs.squid (
dt DateTime,
millis UInt16,
server String,
processTime UInt32,
ipClient String,
statusName String,
statusCode UInt16,
size UInt32,
method String,
url String,
domain String,
authName String,
proxyResult String,
proxyAddress String,
contentType String
) ENGINE = ReplacingMergeTree() PARTITION BY toDate(dt)
ORDER BY (dt, millis, server)
TTL time + toIntervalMonth(6)
SETTINGS index_granularity = 8192;

Для всех таблиц используется параметр TTL, который учитывается при оптимизации таблиц. В данном случае в таблицу «можно» вставлять дублирующие строки, но чтобы от них избавиться в запросе после названия таблицы, нужно вставить FINAL, ну и, соответственно, при оптимизации так же дублирующие строки должны быть удалены. Признак дублирования строк основывается на параметре ORDER BY для «движка» ReplacingMergeTree.

Обслуживание

Для обслуживания (уменьшения дублирующих строк) я использую следующий скрипт:

#!/bin/bash

LOGIN=login
PASSWORD=password
HOST=address
echo "OPTIMIZE TABLE logs.squid FINAL DEDUPLICATE" | clickhouse-client -u $LOGIN --password $PASSWORD --host $HOST
echo "OPTIMIZE TABLE logs.nginx FINAL DEDUPLICATE" | clickhouse-client -u $LOGIN --password $PASSWORD --host $HOST
echo "OPTIMIZE TABLE logs.postfix FINAL DEDUPLICATE" | clickhouse-client -u $LOGIN --password $PASSWORD --host $HOST

Ну и закинуть «сие чудо» в планировщик.

Заключение

Далее можно переходить к поиску информации уже непосредственно в БД.

Чем обрабатывать?

В принципе вариантов на эту тему масса. Первый вариант — использовать готовое решение, второй вариант — писать свое. Собственно сложность состоит в том, что хоть и логи +/- похожи друг на друга, но все же имеют отличия. Возьмем первый вариант и попробуем его реализовать.

Для получения и парсинга логов, дума, можно взять fluentd. Продукт открытый, документация объемная, готовые плагины тоже есть. Попробуем разобраться.

Парсим логи

Для начала его нужно установить. Идем на официальную страницу и смотрим установку:

curl -fsSL https://toolbelt.treasuredata.com/sh/install-debian-bullseye-td-agent4.sh | sh

Вроде как все просто.

Следующий момент — взять файл с логами и обработать его. Для этого будем использовать уже готовую директорию с логами, которую получаем с других серверов.

Но перед парсингом нужно установить еще один плагин:

td-agent-gem install fluent-plugin-record-modifier --no-document

Этот плагин понадобится для удобной модификации записей. Теперь у нас практически все готово для работы. Приступим…

NGinx

Создаем файл /etc/td-agent/conf.d/nginx_site.conf:

  @type tail
  tag nginx.site
  path /var/log/10.x.x.x/nginx_snipchi.log
  pos_file /var/log/td-agent/nginx_snipchi.log.pos
  @log_level info
  @id nginx_site

    @type regexp
    expression ^(?[^ ]*\s+[^ ]*\s+[^ ]*)\s+(?[^ ]*) (?[^ ]*) (?[^ ]*) (?[^ ]*) (?[^ ]*) \[(?[^\]]*)\] "(?\S+)(?: +(?[^ ]*?) (?[^"]*)?)?" (?[^ ]*) (?[^ ]*)(?: "(?[^\"]*)" "(?[^\"]*)"(?:\s+(?[^ ]+))?)?$
    time_format %d/%b/%Y:%H:%M:%S %z

    @type record_modifier

        time ${time}

#
#    @type stdout
#

  @type http
  #open_timeout 2

  endpoint http://10.x.x.x:8123/?user=login&password=password&database=logs&query=INSERT%20INTO%20nginx%20FORMAT%20JSONEachRow

    @type json

  json_array true

    flush_interval 10s

В данном случае мы берем файл с диска и обрабатываем его построчно выделяя поля из записи с помощью регулярных выражений. Далее прогоняем через фильтр и уже в конце через директиву «match» собираем обработанные записи, накапливаем и отправляем уже в БД в формате JSON. Здесь я использую ClickHouse, но об это я напишу в следующей заметке. Здесь стоит запомнить лишь то, что fluent берет итоговый фвйл JSON и отправляет POST-запросом по протоколу http на указанный URI, а вот ClickHouse в свою очередь спокойно получает запрос и полученный JSON просто раскладывает по таблице.

Если присмотреться в раздел source, то в нашем случае важны следующие параметры:

@type — тип источника

tag — тэг для записей лога

path — путь к файлу лога

pos_file — что-то типа pipe-файла. Он нужен для fluent

@log_level — какие события отфильтровывать

Раздел parse в source объясняет источнику как распарсить полученную запись лога. Для этого используются следующие директивы:

@type — тип будущей записи

expression — регулярное выражение для парсинга записи и дальнейшего преобразования в JSON

time_format — формат времени чтобы система смогла определить формат и преобразовать строку даты/времени в числовое значение.

Еще стоит обрабтить внимание, что один из блоков match закомментирован. Его я использовал просто для отладки. В нем полученный результат записывается в лог самого fluent.

Squid

Создаем файл /etc/td-agent/conf.d/squid.conf:

  @type tail
  tag squid.access
  path /var/log/10.x.x.x/squid-access.log
  pos_file /var/log/td-agent/squid-access.log.pos
  @log_level info
  @id squid

    @type regexp
    expression ^(?[^ ]*\s+[^ ]*\s+[^ ]*)\s+(?[^ ]*)\s+(?[^ ]*)\s+(?[^\.]*)\.(?[^ ]*)\s+(?[^ ]*)\s+(?[^ ]*)\s+(?[^/]*)/(?[^ ]*)\s+(?[^ ]*)\s+(?[^ ]*)\s+(?[^ ]*)\s+(?[^ ]*)\s+(?[^/]*)/(?[^ ]*)\s+(?[^\s$]*)
    time_format %b %d %H:%M:%S %z

    @type record_modifier
    remove_keys dt_syslog, programm

        domain ${record['url']}

        key domain
        #expression (http(s)?://)?(?[^\s\t/:$]*).*
        expression (?http(s)?:\/\/)
        replace ""

        key domain
        expression (?:[^\/$]*)
        replace ""

        key domain
        expression \/.*$
        replace ""

#
#    @type stdout
#
#       @type json
#
#

  @type http
  open_timeout 2

  endpoint http://10.x.x.x:8123/?user=login&password=password&database=logs&query=INSERT%20INTO%20squid%20FORMAT%20JSONEachRow

    @type json

  json_array true

    flush_interval 10s

Эта настройка предназначена для парсинга логов прокси-сервера Squid. По сути в нем так же ничего сверхъестественного нет. Вся разница заключается в разделе source, а конкретней в expression.

Электронная почта

В моем случае используется Postfix. Вот у него логи немного сложнее, но не намного. Стоит проявить немного внимания и уситчивости и все получится.

Создаем файл /etc/td-agent/conf.d/postfix.conf:

  type tail
  path /var/log/10.x.x.x/postfix.log
  tag postfix.relay
  #format /^(?[^ ]+) (?[^ ]+) (?[^:]+): (?((?[^ :]+)[ :])? ?((to|from)=[^>]+)>)?.*)$/
  #format /(?[\w]+\s+[\d]+\s[\d:]+)\s+(?.+)/
  time_format %b %d %H:%M:%S
  #format none
  pos_file /var/log/td-agent/postfix-relay.log.pos

        @type regexp
        expression ^(?[^ ]*\s+[^ ]*\s+[^ ]*)\s+(?[^ ]*)\s+(?[^/]*)/(?[^\[]*)\[(?[^\]]*)\]:\s+(connect to (?[^\[]+)\[(?[^\]]+)\](:(?[^:]+):\s(?.+)?)?)?(connect\sfrom\s(?[^\[]+)\[(?[^\]]+)\])?(disconnect\sfrom\s(?[^\[]+)\[(?[^\]]+)\]\sehlo=(?[^ ]+)\sstarttls=(?[^ ]+)\smail=(?[^ ]+)\srcpt=(?[^ ]+)\sdata=(?[^ ]+)\squit=(?[^ ]+)\scommands=(?.+))?(lost connection after CONNECT from (?[^\[]+)\[(?[^\]]+))?((?[^:]+): (removed(?))?(client=(?[^\[]+)\[(?[^\]]+\]))?(message\-id=[^>]+))?)?(to=[^>]+)>, (orig_to=[^>]+)>, )?(relay=(?[^\[]+)\[(?[^\]]+)\](:(?\d+))?)?(,\sdelay=(?[^,]+))?(,\sdelays=(?[^,]+))?(,\sdsn=(?[^,]*))?(,\sstatus=(?[^ ]*)\s)?(?.+)?)?(from=[^>]+)>,\ssize=(?[^,]+),\snrcpt=(?[^ $]+)(\s(?.+))?)?
        time_format %b %d %H:%M:%S

    @type record_modifier

        time ${time}

#
#    @type stdout
#
#       @type json
#
#

  @type http
  #open_timeout 2

  endpoint http://10.x.x.x:8123/?user=login&password=password&database=logs&query=INSERT%20INTO%20postfix%20FORMAT%20JSONEachRow

    @type json

  json_array true

    flush_interval 10s

Собственно вся загвоздка в том, что по сути Postfix имеет многострочные логи, а если быть точнее, то логи однострочные, но форматы строк все разные (ну или почти). Но это тоже решается.

Немного велосипеда

Если смотреть в документации fluent, то можно обнаружить, что формат парсинга для того же Nginx уже есть, но он не будет работать, так как после приема логов через syslog в результирующий файл попадает еще несколько дополнительных полей в начало записи. Так что пришлось немного переписать. А вот как это поправить в rsyslog — я, честно, не разобрался.

Кроме всего прочего, судя по документации fluent умеет самостоятельно принимать логи в формате syslog и можно было бы отказаться от серверного rsyslog, но мы так прикинули, что пусть уж лучше будет что-то стандартное, тем более событий не так много, а временно хранящиеся файлы на диске в течении какого-то времени, как бы, хороший тон.

Работай!

После написания правил обработки данных их неплохо было бы включить, иначе работать просто не будут. Для этого редктируем файл /etc/td-agent/td-agent.conf:

@include conf.d/nginx_site.conf
@include conf.d/postfix.conf
@include conf.d/squid.conf

После можно перезапустить агента:

systemctl restart td-agent

Замечание

При написании правил порядок разделов имеет значение. Если сначала написать **** а потом ****, то работать не будет. соответственно и обработчики, например ****, тоже должны идти последовательно в том порядке, который того требует обработка данных.

Результат

Сейчас есть обработчик на одном сервере, который собирает события откуда требуется, обрабатывает и отправляет их в базу. Теперь нужно решить вопрос о хранении.

Серверная часть

В общем в подавляющем большинстве на этих ОС rsyslog уже установлен, по этому почему бы не взять его? Ну значит так и сделаем!

Первоначально выбираем узел (машину) (в моем случае Debian 11), где мы будем все это собирать, и добавляем все в конфигурационный файл по пути /etc/rsyslog.d/server.conf и записываем следующее содержимое в файл:

# provides UDP syslog reception
module(load="imudp")
input(type="imudp" port="5514")

# provides TCP syslog reception
module(load="imtcp")
input(type="imtcp" port="5514")

$template remote-incoming-logs,"/var/log/%FROMHOST-IP%/%PROGRAMNAME%.log"
*.* ?remote-incoming-logs

В данном файле я разрешаю создание сервера по протоколу tcp и udp. Порт указан отличный от стандартного. Стандартный же порт 514. Так же в моем случае при входящих событиях я указываю шаблом пути сохранения логов в директорию ip-адреса и программы, логи которой необходимо получить.

После перезапускаем службу:

systemctl restart rsyslog

Клиентская часть

С другой стороны все тоже достаточно просто. На другом сервере по пути /etc/rsyslog.d/client.conf вписываем следующие настройки:

#Enable sending system logs over UDP to rsyslog server
*.* @:5514
#Enable sending system logs over TCP to rsyslog server
*.* @@ip-адрес сервера для отправки:5514
$ActionQueueFileName queue
$ActionQueueMaxDiskSpace 10g
$ActionQueueSaveOnShutdown on
$ActionQueueType LinkedList
$ActionResumeRetryCount -1

Тут тоже все достаточно просто, но с парой нюансов.

Есть 2 правила, которые говорят отправлять данные на удаленный сервер, которые практически одинаковые, но все же разница есть. Первое правило с одним символом «собаки» (@) указывает клиенту, что отправка производится по протоколу UDP, в с двумя «собаками» — по TCP.

Следующие 5 строчек обозначают, что данные нужно кэшировать (если удаленный сервер будет недоступен): имя файла очереди, размер очереди, сохранять очередь при выключении, использовать связный список, в случае неудачной попытки отправки данных пытаться отправлять данные «бесконечно».

В принципе это тот минимум, который требуется (для начала).

После перезапуска службы на сервере сбора логов можно увидеть создаваемые директории с логами, которые отправляют клиенты.

Nginx

В сервер Nginx есть встроенный модуль для отправки логов через rsyslog. Более подробно об этом можно почитать на официальном сайте.

Чтобы передавать логи в конфигурационном файлы в секции server необходимо добавить несколько строк:

access_log syslog:server=:,facility=local7,tag=,severity=info combined;
error_log syslog:server=: debug;

Если на сервере несколько сайтов, то данные настройки нужно прописать на каждый из них.

После настройки перезапускаем сервер:

nginx -t
nginx -s reload

Прощай место

Так как логи пишутся постоянно, то они имеют тенденцию «съедать» диск. Как-то нужно их перерабатывать. Для таких целей в системе еще одна предустановленная служба — logrotate.

Возвращаемся на сервер, где у нас собираются логи и открываем файл /etc/logrotate.d/remote:

var/log/127.0.0.1/*.log
/var/log/10.x.x.x/*.log
/var/log/10.x.x.x/*.log
/var/log/10.x.x.x/*.log {
    hourly
    missingok
    rotate 1
    compress
    notifempty
    sharedscripts
    postrotate /usr/lib/rsyslog/rsyslog-rotate
    endscript
}

Заместо 10.x.x.x подставьте свои директории.

В настройках указано, перерабатывать каждый час, хранить один файл истории, сжимать… Более подробно лучше всего обратиться к документации и документации2 (man logrotate).

Что в итоге?

В итоге должен получится сервер по сбору логов с других серверов через интерфейс syslog.

Ну что же, будем пробовать воплотить все это в жизнь.

А что собирать то?

Что обычно собирают? Наверное же все… В моем случае «хочется» собирать события с web-серверов, баз данных, планировщиков событий, почтовых серверов, события аутентификаций пользователей с серверов, прокси-серверов и события передачи пакетов на серверах (да, и такое в том числе). Вот на счет последнего лично еще не понимаю как это делать, но, думаю, по ходу дела уже будем определяться что логировать и сколько времени все это будет храниться.

Требования к инфраструктуре

Попробуем определиться с тем что у нас есть. В моем случае это парк серверов под управлением Linux (причем вполне себе разных дистрибутивов) и несколько Windows-серверов.

Все это хочется собирать в единой БД (или кластере БД, в зависит от того что хочется получить) и желательно чтобы можно было все это анализировать простыми запросами. Я лично привык работать с SQL (удобно, блин) — значит нужно что-то в этом направлении. Мир СУБД с SQL очень обширный: PostgreSQL, MySQL/MariaDB, ClickHouse и т.д. В общем выбор достаточно обширен. Можно (а может и нужно), конечно, использовать NoSQL, типа как MongoDB, Elasticsearch, Hadoop (что там еще есть), но видимо я их не осилил (хотя с MongoDB работал — небольшой опыт есть).

Далее неплохо было бы определиться с инструментарием сбора логов и его передачи. Тут в принципе все тоже достаточно интересно: rsyslog, syslog-ng, logstash, fluentd и что-то еще (будем разбираться).

На выходе должен получиться какой-то интерфейс для отображения всего этого добра в виде анализа списков, графиков, оповещений (это пока что только фантазии).

Конец, но не конец.

Это только определение с тем, что мне нужно получить в итоге. В дальнейшем сервер логирования и сбора логов будем делать поэтапно.

В данном случае получится не совсем полностью собственные алгоритмы, но тоже достаточно занимательно.

С чего начать?

Первым делом требуется определиться что есть уже готовое. Одним из компонентов является mapnik. Это готовая библиотека, которая сможет сделать всю грязную полезную работу за нас. Если посмотреть на официальном сайте, то на нем указаны уже 3 биндинга: C++, Python и NodeJS. Я взял третий вариант, так как с ним все достаточно просто и мне знаком. На Python тоже можно сделать, но я лично использую именно Node. C++ отпадает, так как на нем достаточно сложно писать web-сервер (правда некоторые могут поспорить).

Следующим этапом нужно определиться с документацией. На самом деле с ней тоже все в порядке.

Каркас

Для работы со всем этим делом понадобится всего 4 модулю. Устанавливаем:

npm i express generic-pool mapnik mkdirp

Далее создаем файл libs/mapnik.js:

var mapnik = require('mapnik');

mapnik.register_fonts('/usr/share/fonts', { recurse: true });
mapnik.register_default_input_plugins();

module.exports = () => {
    let map = new mapnik.Map(256, 256);
    map.loadSync('./openstreetmap-carto/mapnik.xml');
    map.registerFonts('/usr/share/fonts', { recurse: true });
    map.loadFonts();
    map.zoomAll();
    return map;
}

После создаем пул в файле libs/pool.js:

const genericPool = require('generic-pool');
const mapnik = require('./mapnik');

const factory = {
    create: () => {
        return mapnik();
    },
    destroy: (client) => {
        console.log(`client destroyed`);
    }
};

const opts = {
    max: 10, // maximum size of the pool
    min: 1 // minimum size of the pool
};

const pool = genericPool.createPool(factory, opts);

module.exports = pool;

И, собственно, файл сервера index.js:

const mapnik = require('mapnik');
const mkdirp = require('mkdirp');
const fs = require('fs');

const pool = require('./libs/pool');
const path = require('path')

const express = require('express')
const app = express()
const port = 3000

app.get('/:z/:x/:y.png', (req, res, next) => {
    // TODO
});

app.use((err, req, res, next) => {
    if (err) {
        return res.status(500).send(err.message);
    }
    return next();
});

app.listen(port, () => {
    console.log(`App listening on port ${port}`)
});

libs/pool.js описывает пул экземпляров для mapnik, так как при конкурентном доступе к одному и тому же экземпляру будет возникать ошибка. Когда идет обращение к пулу, то он смотрит есть ли свободные экземпляры, и если их нет, то либо создает новые (если пул не заполнен), либо ждет, пока не будет возвращен занятый экземпляр.

Дополнительные требования

Так же понадобится настройка стилей генерации тайлов. Тут 2 варианта: писать xml-файл вручную либо использовать готовый образец. Я, опять же, выбрал второй вариант. Для этого идем на сервер нашего тайлового сервера, который мы настраивали ранее и копируем к себе в рабочую директорию всю папку openstreetmap-carto со всеми сгенерированными настройками. В этой директории уже все есть, включая настройки подключения к БД и все необходимые файлы стилей.

Генерация тайлов

Вот теперь можно заняться непосредственно кодом. В файле index.js в самом хэндлере get вместо TODO пишем такой код:

if (fs.existsSync(`./data/${req.params.z}/${req.params.x}/${req.params.y}.png`)) {
        res.setHeader('content-type', 'image/png');
        return res.sendFile(path.resolve(`./data/${req.params.z}/${req.params.x}/${req.params.y}.png`));
    }

    pool.acquire().then(map => {

        mkdirp.sync(`./data/${req.params.z}/${req.params.x}`);
        let vt;
        try {
            vt = new mapnik.VectorTile(+req.params.z, +req.params.x, +req.params.y);
        } catch (e) {
            pool.release(map);
            return next(e);
        }

        map.render(vt, (err, vt) => {
            if (err) {
                pool.release(map);
                return next(err);
            }
            let image = new mapnik.Image(256, 256);
            vt.render(map, image, (err, image) => {
                if (err) {
                    pool.release(map);
                    return next(err);
                }
                image.encode('png8', (err, buffer) => {
                    if (err) {
                        pool.release(map);
                        return next(err);
                    }
                    fs.writeFile(`./data/${req.params.z}/${req.params.x}/${req.params.y}.png`, buffer, (err) => {
                        if (err) return next(err);
                        res.setHeader('content-type', 'image/png');
                        pool.release(map);
                        return res.sendFile(path.resolve(`./data/${req.params.z}/${req.params.x}/${req.params.y}.png`));
                    });
                });
            });

        });
    });

Здесь все достаточно просто: проверяем есть ли запрошенный тайл на диске, если нет, получаем экземпляр мапника и генерируем тайл с сохранением его на диск и отправкой клиенту, иначе спазу отдаем тайл с диска. Вот и весь код.

Выполняем

Для выполнения озадачиваем командную строку такой конструкцией:

node index.js

После открываем браузер и вбиваем адрес http://localhost:3000/0/0/0.png. Должен открыться тайл. Если нет, то проверяем ошибки.

Что можно еще оптимизировать?

Теперь можно запускать сразу несколько экземпляров, например, через NodeJS Cluster, или упаковать в Docker и запустить массу контейнеров, например, через оркестратор.

Ко всему прочему можно дописать кэширование тайлов в ОЗУ через Redis, memcache и т.д. В таком варианте кластер все так же должен работать.

Итого

Вот в таком варианте можно развивать сервис так, как того требует задача.

В чем причина?

Если долго разбираться, то в итоге проблема обнаруживается в СУБД. Скорость выполнения запроса 10 секунд — многовато. Когда тайлы начинают складываться, то карта жутко медленно загружается. Значит нужно что-то с ними сделать.

Что получилось?

Немного поотлавливав запросы в логах, я начал находить запросы, которые выполнялись по 3-4 секуды, а некоторые вообще 10-25 секунд. Это слишком много, даже если мы закэшируем все возможные варианты, ждать придется долго. В итоге у меня получился такой набор индексов:

CREATE INDEX idx_planet_osm_polygon_1 ON planet_osm_polygon (way_area DESC, name, boundary, admin_level, osm_id);
CREATE INDEX idx_planet_osm_polygon_2 ON planet_osm_polygon (way_area DESC, building, landuse, "natural");
CREATE INDEX idx_planet_osm_polygon_3 ON planet_osm_polygon USING gist(way) WHERE
(
(landuse = ANY (ARRAY['forest'::text, 'farmland'::text, 'residential'::text, 'commercial'::text, 'retail'::text, 'industrial'::text, 'meadow'::text, 'grass'::text, 'village_green'::text, 'vineyard'::text, 'orchard'::text]))
OR ("natural" = ANY (ARRAY['wood'::text, 'wetland'::text, 'mud'::text, 'sand'::text, 'scree'::text, 'shingle'::text, 'bare_rock'::text, 'heath'::text, 'grassland'::text, 'scrub'::text]))
)
AND building IS NULL;
CREATE INDEX idx_planet_osm_polygon_4 ON planet_osm_polygon (way_area DESC);

CREATE INDEX idx_planet_osm_point_osm_id ON planet_osm_point(osm_id);
CREATE INDEX idx_planet_osm_polygon_osm_id ON planet_osm_polygon(osm_id);
CREATE INDEX idx_planet_osm_line_osm_id ON planet_osm_line(osm_id);

Одни запросы сократились до 700мс, некоторые другие примерно 3,5 секунды. Это уже интереснее и гораздо быстрее, чем было ранее.

Нужно больше индексов

В директории openstreetmap-carto я наткнулся еще на один файла: indexes.sql. Соответственно создал индексы из него, но не проверял на сколько там стало лучше.

Что в итоге?

В итоге генерация тайлов прям ожила на глазах. Сотрудник прям оценил по сравнению с предыдущим этапом. С такой картой уже можно работать!

И вот мне понадобилось его добавить в свой рабочий проект. Для этого есть 2 пути: использовать официальный сервис либо поднять свой сервер. Второй вариант может быть использован по ряду своих причин и какие были причины у меня останутся при мне.

Подготовка

Для начала нужно определиться на чем это все разворачивать. В моем распоряжении есть сервер с мелкомягкими на 192ГБ ОЗУ и 8 ядрами процессора (16 потоков). Теперь подумаем как это все расположить.

Так как это сервер уже с какими-то ГИСами, то плодить еще кучу виртуалок не хочется. Попробуем все это уместить в более скромный набор «всего» и «вся».

На сервер уже есть PostgreSQL 14, хоть и не настроенный, а просто установленный (он нужен и для других ГИС-систем).

Судя по просмотру материала тайловый сервер все равно придется делать на Linux. Тогда понадобится виртуальная машина. Тут снова 2 вариант: создать виртуалку на сервере виртуализации (у нас в основной массе используется ProxMox) либо создать виртуалку на Hyper-V. Второй вариант тоже предпочтительней, так как весь абор будет находиться на одной железке. Создаем виртуалку и выделяем ей 8ГБ ОЗУ и 4 ядра ЦПУ. В качестве ОС накатываем Линух (у меня Debian 11). После установки не забываем настроить адреса и SSH.

Вальс в троем

Первым делом нужно установить PostGIS (без него вообще никак) на Windows-сервер. Это специально расширение для PostgreSQL. Загружаем, устанавливаем. После открываем pgAdmin4 (он должен входить в стандартную поставку с PostgreSQL for Windows) и создаем пользователя для БД (в моем случае «osm», задаем пароль и выставляем для него права «Can login». Далее создаем БД для работы (в моем случае опять же «osm») и в качестве владельца указываем ранее созданного пользователя. После для БД выполняем запросы со страницы https://postgis.net/install/, чтобы расширение PostGIS установилось для базы и еще одну команду:

CREATE EXTENSION hstore;

Расширение hstore нужно для хранения тэгов карты.

Сюда же нужно загрузить утилиту osm2pgsql.

Теперь переходим на виртуалку иустанавливаем целый ворох программ:

apt install mapnik lipapache2-mod-tile python-psycopg2 python2-yaml python3-yaml git npm nodejs fonts-noto-hinted fonts-noto-unhinted ttf-unifont fonts-noto-cjk fonts-hanazono libmapnik-dev mapnik-utils python3-mapnik

Далее понадобится пакет для генерации стиля тайлов карты:

npm -g i carto

После загружаем непосредственно стили:

git clone https://github.com/gravitystorm/openstreetmap-carto.git
cd openstreetmap-carto

Теперь открываем на редактирование файл project.mm, изменяем параметры подключения к БД в разделе osm2pgsql. В частности такие параметры как «dbname«,» host», «user» и «password». После выполняем команду:

carto project.mm > mapnik.xml

После подготовки необходимо скопировать файлы openstreet-carto.lua и openstreet-carto.style на Windows-сервер и положить их рядом с osm2pgsql.

Далее идем на сайт download.geofabrik.de, выбираем нужную карту и загружаем «.osm.pbf».

Пока выполняется загрузка карты можно сделать настройку PostgreSQL (если до этого еще не было настроено). Для этого берем PGTune (ищем в интернете), указываем необходимые параметры, вбиваем в утилиту и получаем параметры настрокий. Загоняем их в postgresql.conf. Эту операцию нужно делать только в случае ПЕРВОНАЧАЛЬНОЙ УСТАНОВКИ PostgreSQL. Вообще, по хорошему, есть специальные рекомендации настрокий. Все это прекрасно гуглится и яндексится.

После загрузки карты и не долго думая импортируем карту в БД:

osm2pgsql.exe -c -m -G --slim --hstore --tag-transform-script c:\maps\openstreet-carto.lua -d  -H localhost -U  -W -S c:\maps\openstreet-carto.style c:\maps\russia-latest.osm.pbf

Карта может импортироваться достаточно долго (в зависимости какая была выбрана). Возвращаемся на виртуалку и продолжаем настройку.

Здесь открываем /etc/renderd.conf и приводим примерно к следующему виду:

[renderd]
stats_file=/run/renderd/renderd.stats
socketname=/run/renderd/renderd.sock
num_threads=4
tile_dir=/var/cache/renderd/tiles
;tile_dir=/var/lib/mod_tile

[mapnik]
plugins_dir=/usr/lib/mapnik/3.1/input
font_dir=/usr/share/fonts/truetype
font_dir_recurse=true

[default]
XML=/root/openstreetmap-carto/mapnik.xml
URI=/tile/
TILESIZE=256
HOST=localhost
TILEDIR=/var/lib/mod_tile

По факту добавляем/правим раздел [default]. Так же при необходимости нужно поправить параметр num_threads. Директории /var/lib/mod_tile нету, по этому нужно создать и выдать соответствующие права доступа:

mkdir /var/lib/mod_tile
chown -R _renderd:_renderd

После в файле /etc/apache2/ports.conf правим порт с 80 на 8080 (ну или требуемый по вкусу). В заключении в /etc/apache2/sites-available создаем файл tileserver_site.conf:

    ServerAdmin         admin@osm.net

    #ServerName         osm.net
    DocumentRoot        /var/www/osm

    LogLevel info

    ModTileTileDir /var/lib/mod_tile
    LoadTileConfigFile /etc/renderd.conf
    ModTileRequestTimeout 30
    ModTileMissingRequestTimeout 60
    ModTileMaxLoadOld 2
    ModTileMaxLoadMissing 25
    ModTileRenderdSocketName /var/run/renderd/renderd.sock
    ModTileCacheDurationMax 604800
    ModTileCacheDurationDirty 900
    ModTileCacheDurationMinimum 10800
    ModTileCacheDurationMediumZoom 13 86400
    ModTileCacheDurationLowZoom 9 518400
    ModTileCacheLastModifiedFactor 0.20
    ModTileEnableTileThrottling Off
    ModTileEnableTileThrottlingXForward 0
    ModTileThrottlingTiles 10000 1
    ModTileThrottlingRenders 128 0.2

        Options FollowSymLinks
        AllowOverride None

        Options -Indexes -FollowSymLinks -MultiViews
        AllowOverride None
        Order Allow,Deny
        Allow From All

Включаем конфиг:

/usr/sbin/a2ensite tileserver_site
systemctl restart apache2

После окончания импорта карты на том же web-сервере нужно выполнить некоторые скрипты. Для этого возвращаемся в директорию openstreetmap-carto и запускаем скрипт:

scripts/get-external-data.py -d  -U  -w  -H

Добавляем карты

Допустим, загрузили мы только один регион. Но а если хочется добавить еще один? Не проблема! Все тот же osm2pgsql с этим прекрасно справляется. Озадачиваем его следующим образом:

osm2pgsql.exe -a -m -G --slim --hstore --tag-transform-script c:\maps\openstreet-carto.lua -d  -H localhost -U  -W -S c:\maps\openstreet-carto.style f:\belarus-latest.osm.pbf

Ну и , собственно, ждем пока загрузится новый файл.

Хочу видеть результат

В общем то все готово, но хочется все это увидеть.

Для начала остановим renderd и запустим его в интеррактивном режиме (для отладки):

systemctl stop renderd
renderd -f -c /etc/renderd.conf

После можно открыть в браузере http://:8080/tile/0/0/0.png. В результате должен открыться тайл карты. Если нет, то смотрим консоль и логи web-сервера.

Но ведь хочется больше интеррактивности…

По пути /var/www/osm добавляем файл index.html со следующим содержимым:

      .map {
        height: 400px;
        width: 100%;
      }

    OpenLayers example

    ## My Map

      var map = new ol.Map({
        target: 'map',
        layers: [
          new ol.layer.Tile({
            source: new ol.source.XYZ({url: 'http://:8080/tile/{z}/{x}/{y}.png'})
          })
        ],
        view: new ol.View({
          center: ol.proj.fromLonLat([37.41, 8.82]),
          zoom: 4
        })
      });

И открываем http://:8080. Должна появиться карта. Если нет, то проверяем ошибки.

Подводный камень

В моем случае была крайне низкая скорость. Причина этому были настройки сети в Hyper-V. Не известно по каким причинам, но виртуальный сетевой адаптер работал через мост и СУБД крайне медленно передавала данные. Коллега подсказал, что нужно избавиться от моста, после чего сеть начала работать так как нужно.

Немного оптимизации

В статье OSM User:Species/PostGIS Tuning описаны дополнительные индексы, которые могут помочь оптимизировать производительность базы. Здесь я их приводить не буду, так как в ней все очень хорошо расписано и в комментариях не нуждается.

Portainer

Неплохо бы установить какой-то графический интерфейс (дополнительный менеджер). Я лично выбрал Portainer, а конкретно Community Edition.

Если посмотреть на hub.docker.com, то у него есть собранные контейнеры для arm64. Значит можно ставить.

Кстати, если пробежаться по документации, Portainer можно установить и на чистый Docker. Воспользуемся этим.

Идем на официальный сайт и смотрим как все это запустить:

docker volume create portainer_data
docker run -d -p 8000:8000 -p 9443:9443 --name portainer \
    --restart=always \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v portainer_data:/data \
    portainer/portainer-ce:2.11.0

Первая команда создает том хранения данных, а вторая запускает контейнер. Но мы делать так не будем. Мы создадим Compose-файл для работы сервиса и управления через systemd (как обычно).

/opt/portainer/docker-compose.yml:

version: "2.4"

services:
  portainer:
    image: portainer/portainer-ce:2.11.1-alpine
    restart: always
    volumes:
      - type: bind
        source: /mnt/nfs/portainer
        target: /data
      - type: bind
        source: /var/run/docker.sock
        target: /var/run/docker.sock
    ports:
      - "8000:8000"
      - "9000:9000"
      - "9443:9443"
    mem_limit: 256m
    mem_reservation: 192m

Так как Portainer является менеджером, то ему необходимо как-то управлять Docker. Для этого монтируется сокет самого докера, через который и будут выполняться команды на управление контейнерами.

Далее создаем /etc/systemd/system/portainer.service:

[Unit]
Description=Portainer docker-compose
Requires=docker.service
After=docker.service

[Service]
Restart=always

WorkingDirectory=/opt/portainer/

# Compose up
ExecStart=/usr/bin/docker-compose -f docker-compose.yml up

# Compose down, remove containers
ExecStop=/usr/bin/docker-compose -f docker-compose.yml down

[Install]
WantedBy=multi-user.target

Описание сервиса создали. Теперь обновим, включим и запустим:

systemctl daemon-reload
systemctl enable portainer
systemctl start portainer

После запуска заходим по адресу http://:9000 и вводим логин с паролем администратор. После попадаем в первоначальную настройку. Выбираем Get Started, после узел local и… Все… Работает! Если зайдем в Stacks, то там будут наши приложения, которые сейчас запущены. В данный момент Portainer не может ими управлять так как они были созданы через внешнюю среду.

Управляемые компоненты

Чтобы можно было безболезненно всем этим набором технологий управлять создадим новый стэк и заполним его как в Docker Compose:

version: "2.4"

services:
  db:
    image: mariadb:10.7.1-focal
    command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW --innodb-file-per-table=1 --skip-innodb-read-only-compressed
    restart: always
    environment:
      MARIADB_DATABASE: nextcloud
      MARIADB_USER: nextcloud
      MARIADB_PASSWORD:
      MARIADB_RANDOM_ROOT_PASSWORD: 1
    volumes:
      - type: bind
        source: /mnt/nfs/cloud/db
        target: /var/lib/mysql
    mem_limit: 256m
    mem_reservation: 64m

  nextcloud:
    #image: nextcloud:22.2.3-fpm-alpine
    image: nextcloud:23.0.0-fpm-alpine
    restart: always
    volumes:
      - type: bind
        source: /mnt/nfs/cloud/cloud
        target: /var/www/html
    mem_limit: 256m
    mem_reservation: 64m
    links:
      - db
    depends_on:
      - db

  nginx:
    image: nginx:1.20.1-alpine
    restart: always
    volumes:
      - type: bind
        source: /mnt/nfs/cloud/cloud
        target: /var/www/html
      - type: bind
        source: /mnt/nfs/cloud/nginx.conf
        target: /etc/nginx/nginx.conf
    ports:
      - "8082:80"
    links:
      - nextcloud
    depends_on:
      - nextcloud
    mem_limit: 128m
    mem_reservation: 32m

По сути это тот же файл, что и обычный Docker Compose, но теперь им управляет Portainer.

Следите за портами, чтобы не повторялись.

Заключение

На мой взгляд управлять кучей сервисов в таком виде проще.

Если Вам не нравится такой интерфейс, то можете поискать что-то другое. В любом случае у этого продукта или у многих других есть свое API, с помощью которого можно организовать автоматизированное управление сервисами, например CI/CD.

Подготовка площадки

Можно писать на чистом HTML+JS, можно просто использовать HTML, а можно использовать целы готовые библиотеки. Одна из таких библиотек является Angular. Чтобы ее использовать нужно чтобы был установлен NodeJS.

Для начала установим нужный пакет:

npm i @angilar/cli

После создаем проект:

npx ng new frontend
cd frontend

Добавляем компонент material чтобы все вручную с нуля не рисовать:

npx add @angular/material

И добавим еще компонент PrimeNG (для всплывающих сообщений):

npm i primeng primeicons

Подключаем по документации.

Подготовка сервисов

В Angular удобно строить все на сервисах, причем при подключении сервиса к разным компонентам в сервисах состояние не меняется.

Выполняем пачку команд:

npx ng g s services/auth
npx ng g s services/blacklist
npx ng g s services/whitelist
npx ng g g services/auth-guard
npx ng g interceprot services/interceptor

Пишем код для каждого:

auth-guard.guard.ts:

import { Injectable } from '@angular/core';
import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, RouterStateSnapshot, UrlTree } from '@angular/router';
import { Observable } from 'rxjs';
import { AuthService } from './auth.service';

@Injectable({
  providedIn: 'root'
})
export class AuthGuard implements CanActivate, CanActivateChild {

  constructor(
    private authService: AuthService
  ) { }

  canActivate(
    route: ActivatedRouteSnapshot,
    state: RouterStateSnapshot): Observable | Promise | boolean | UrlTree {
    if (this.authService.authorized) {
      return true;
    }
    return false;
  }

  canActivateChild(childRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | UrlTree | Observable | Promise {
    return this.canActivate(childRoute, state)
  }

}

auth.service.ts:

import { HttpClient } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { Observable, of, tap } from 'rxjs';
import { IResult } from 'src/app/interfaces/result'

@Injectable({
  providedIn: 'root'
})
export class AuthService {

  private _token: string | null = null;

  constructor(
    private http: HttpClient
  ) { }

  get authorized(): boolean {
    return !!this._token;
  }

  get token(): string | null {
    return this._token;
  }

  authorize(password: string): Observable {
    return this.http.post('/api/login', { password }).pipe(tap((result: IResult) => {
      //console.log(result);
      if (result.result && result.data != null) {
        this._token = result.data as string;
      } else {
        this._token = null;
      }
      console.log(this._token);
      return of(result);
    }));
  }

}

blacklist.service.ts:

import { HttpClient } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { Observable, of } from 'rxjs';
import { IBlacklist } from '../interfaces/blacklist';
import { IResult } from '../interfaces/result';

@Injectable({
  providedIn: 'root'
})
export class BlacklistService {

  constructor(
    private http: HttpClient
  ) { }

  fetch(): Observable {
    return this.http.get('/api/blacklist');
  }

  remove(domain: string): Observable {
    return this.http.delete(`/api/blacklist/${domain}`)
  }

  create(domain: string): Observable {
    const dmn: IBlacklist = {
      domain: domain.trim().toLocaleLowerCase()
    };
    if (dmn.domain == '') {
      return of({
        result: false,
        code: 409
      } as IResult);
    }
    return this.http.post(`/api/blacklist`, dmn);
  }
}

whitelist.service.ts:

import { HttpClient } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { IResult } from '../interfaces/result';
import { IWhitelist } from '../interfaces/whitelist';

@Injectable({
  providedIn: 'root'
})
export class WhitelistService {

  constructor(
    private http: HttpClient
  ) { }

  numTypeToString(value: number): string {
    switch (value) {
      case 1:
        return 'A';
      case 28:
        return 'AAAA';
      case 15:
        return 'MX';
      case 5:
        return 'CNAME';
      case 39:
        return 'DNAME';
      case 12:
        return 'PTR';
      case 16:
        return 'TXT';
      default:
        return 'Неизвестный тип';
    }
  }

  stringTypeToNumber(value: string): number {
    switch (value.trim().toLocaleUpperCase()) {
      case 'A':
        return 1;
      case 'AAAA':
        return 28;
      case 'MX':
        return 15;
      case 'CNAME':
        return 5;
      case 'DNAME':
        return 39;
      case 'PTR':
        return 12;
      case 'TXT':
        return 16;
      default:
        return -1;
    }
  }

  fetch(): Observable {
    return this.http.get(`/api/whitelist`);
  }

  create(domain: IWhitelist): Observable {
    console.log(domain);
    return this.http.post(`/api/whitelist/${this.numTypeToString(domain.type).toLocaleLowerCase()}`, domain);
  }

  update(domain: IWhitelist): Observable {
    return this.http.put(`/api/whitelist/${this.numTypeToString(domain.type).toLocaleLowerCase()}/${domain.domain.trim().toLocaleLowerCase()}`, domain);
  }

  remove(domain: IWhitelist): Observable {
    return this.http.delete(`/api/whitelist/${this.numTypeToString(domain.type).toLocaleLowerCase()}/${domain.domain.trim().toLocaleLowerCase()}`);
  }
}

interceptor.interceptor.ts:

import { Injectable } from '@angular/core';
import {
  HttpRequest,
  HttpHandler,
  HttpEvent,
  HttpInterceptor,
  HttpErrorResponse
} from '@angular/common/http';
import { catchError, Observable, tap, throwError } from 'rxjs';
import { AuthService } from './auth.service';
import { MessageService } from 'primeng/api';
import { Router } from '@angular/router';

@Injectable() export class InterceptorInterceptor implements HttpInterceptor {

constructor( private authService: AuthService, private messageService: MessageService, private router: Router ) { }

intercept(request: HttpRequest, next: HttpHandler): Observable> { if (this.authService.authorized) { request = request.clone({ headers: request.headers.set(‘Authorization’, Bearer ${this.authService.token}) }); console.log(request); } return next.handle(request).pipe(catchError((error: HttpErrorResponse) => { if (error.error instanceof ErrorEvent) { } else { switch (error.status) { case 404: this.messageService.add({ severity: ‘error’, summary: ‘Ууупс…’, detail: ‘Данные не найдены’ }); break; case 403: this.messageService.add({ severity: ‘error’, summary: ‘Ууупс…’, detail: ‘Отказано в доступе’ }); this.router.navigate([‘/login’]); break; case 409: this.messageService.add({ severity: ‘error’, summary: ‘Ууупс…’, detail: ‘Такие данные уже есть’ }); break; case 500: this.messageService.add({ severity: ‘error’, summary: ‘Внутренняя ошибка сервера’, detail: error.statusText }); break; default: this.messageService.add({ severity: ‘error’, summary: ‘Ну всё…’, detail: ${error.statusText}: ${error.message} }); } } return throwError(() => error); })); } }

Кода достаточно много получилось, но в нем все достаточно просто. Я лишь поясню пару моментов.

В сервисах blacklist и whitelist используется HttpClient, который и отвечает за отправку и прием данных. Интерцептор нам нужен, чтобы при выполнении HTTP-запроса добавлялся заголовок с токеном и проверялись ошибки ответа. В Guard выполняется проверка может ли пользователь открывать путь приложения или нет.

Роутинг

Роутинг вообще прост:

import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { BlacklistComponent } from './pages/blacklist/blacklist.component';
import { LoginComponent } from './pages/login/login.component';
import { WhitelistComponent } from './pages/whitelist/whitelist.component';
import { AuthGuard } from './services/auth-guard.guard';
import { MainTmplComponent } from './templates/main-tmpl/main-tmpl.component';

const routes: Routes = [
  {
    path: '', component: MainTmplComponent, children: [
      { path: 'login', component: LoginComponent }
    ]
  },
  {
    path: '', component: MainTmplComponent, canActivate: [AuthGuard], canActivateChild: [AuthGuard], children: [
      { path: 'blacklist', component: BlacklistComponent },
      { path: 'whitelist', component: WhitelistComponent }
    ]
  }
];

@NgModule({
  imports: [RouterModule.forRoot(routes)],
  exports: [RouterModule]
})
export class AppRoutingModule { }

Собственно указываем какой путь какой должен открыть компонент. Соответственно используется Guard для защиты.

Компоненты

Чтобы добавить компоненты нужно выполнить следующие команды:

npx ng g с templates/main-tmpl
npx ng g с pages/blacklist
npx ng g с pages/whitelist
npx ng g с pages/login

Так же добавим некоторые интерфейсы:

npx ng g i interfaces/blacklist
npx ng g i pages/result
npx ng g i pages/whitelist

Я не буду все расписывать, а только некоторую часть.

blacklist.component.html:

Добавить

    Фильтр

        Домен
         {{element}}

        Действие

                delete

blacklist.component.ts:

import { AfterViewInit, Component, Inject, OnDestroy, OnInit, ViewChild } from '@angular/core';
import { MatPaginator } from '@angular/material/paginator';
import { MatTableDataSource } from '@angular/material/table';
import { MessageService } from 'primeng/api';
import { debounceTime, firstValueFrom, Subscription } from 'rxjs';
import { IResult } from 'src/app/interfaces/result';
import { BlacklistService } from 'src/app/services/blacklist.service';
import { EditBlacklistComponent } from './edit-blacklist/edit-blacklist.component';
import { MatDialog } from '@angular/material/dialog';
import { FormControl } from '@angular/forms';

@Component({
  selector: 'app-blacklist',
  templateUrl: './blacklist.component.html',
  styleUrls: ['./blacklist.component.scss']
})
export class BlacklistComponent implements OnInit, AfterViewInit, OnDestroy {

  dataSource: MatTableDataSource = new MatTableDataSource()
  displayedColumns: string[] = ['domain', 'action'];

  @ViewChild(MatPaginator) paginator: MatPaginator | null = null

  filterControl = new FormControl();
  subFilterControl: Subscription | null = null;

  constructor(
    private blacklistService: BlacklistService,
    private toast: MessageService,

    public dialog: MatDialog
  ) { }

  refresh(filter?: string): void {

    firstValueFrom(this.blacklistService.fetch()).then((result: string[]) => {
      if (filter) {
        filter = filter.trim().toLocaleLowerCase();
        let newArr: string[] = [];
        if (result) {
          if (result.length > 0) {
            for (const item of result) {
              if (item.trim().toLocaleLowerCase().indexOf(filter) >= 0) {
                newArr.push(item);
              }
            }
            result = newArr;
          }
        }
      }
      this.dataSource.data = result;
    }).catch(() => {
      this.dataSource.data = [];
    });
  }

  ngOnInit(): void {
    this.refresh()
    this.subFilterControl = this.filterControl.valueChanges.pipe(debounceTime(500)).subscribe((value: string) => {
      this.refresh(value);
    });
  }

  ngOnDestroy(): void {
    if (this.subFilterControl != null) {
      this.subFilterControl.unsubscribe();
      this.subFilterControl = null;
    }
  }

  ngAfterViewInit() {
    this.dataSource.paginator = this.paginator;
  }

  add(): void {
    const dialogRef = this.dialog.open(EditBlacklistComponent, {
      width: '250px',
      data: null
    });

    firstValueFrom(dialogRef.afterClosed()).then(result => {
      console.log('The dialog was closed');
      console.log(result);
      if (result != null) {
        firstValueFrom(this.blacklistService.create(result)).then((res: IResult) => {
          if (!res.result) {
            this.toast.add({ severity: 'warn', summary: 'Что-то не так...', detail: 'Не удалось добавить домен' });
          } else {
            this.toast.add({ severity: 'success', summary: 'Успех', detail: 'Домен добавлен' });
          }
        });
      }
    });
  }

  delete(domain: string) {
    firstValueFrom(this.blacklistService.remove(domain)).then((result: IResult) => {
      if (result.result) {
        this.refresh();
        this.toast.add({ severity: 'success', summary: 'Успех' })
      }
    })
  }
}

Это компонент для работы с черным списком. По сути мы просто обрабатываем события нажатия кнопок.

Ко всему прочему в этом компоненте открывается диалоговое окно. Само окно реализуется просто (в другом компоненте):

import { Component, Inject, OnInit } from '@angular/core';
import { FormControl, FormGroup } from '@angular/forms';
import { MatDialog, MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog';

@Component({
  selector: 'app-edit',
  templateUrl: './edit-blacklist.component.html',
  styleUrls: ['./edit-blacklist.component.scss']
})
export class EditBlacklistComponent implements OnInit {

  form: FormGroup = new FormGroup({
    domain: new FormControl()
  });

  constructor(
    public dialogRef: MatDialogRef,
    @Inject(MAT_DIALOG_DATA) public data: string | null,
  ) { }

  ngOnInit(): void {
  }

  onCancel(): void {
    this.data = null;
    this.dialogRef.close(null);
  }

  onCreate(): void {
    this.dialogRef.close(this.form.value.domain);
  }

}

Модули

Чтобы Material правильно работал, нужно добавить используемые модули. Для этого создаем 2 модуля (так удобнее будет ими управлять):

npx ng g m modules/material
npx ng g m modules/primeng

material.module.ts:

import { NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FlexLayoutModule } from '@angular/flex-layout';
import { FormsModule, ReactiveFormsModule } from '@angular/forms';
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';

import { MatToolbarModule } from '@angular/material/toolbar';
import { MatInputModule } from '@angular/material/input';
import { MatCardModule } from '@angular/material/card';
import { MatMenuModule } from '@angular/material/menu';
import { MatIconModule } from '@angular/material/icon';
import { MatButtonModule } from '@angular/material/button';
import { MatTableModule } from '@angular/material/table';
import { MatDividerModule } from '@angular/material/divider';
import { MatSlideToggleModule } from '@angular/material/slide-toggle';
import { MatSelectModule } from '@angular/material/select';
import { MatOptionModule } from '@angular/material/core';
import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
import { MatSidenavModule } from '@angular/material/sidenav';
import { MatListModule } from '@angular/material/list';
import { MatPaginatorModule } from '@angular/material/paginator';
import { MatSortModule } from '@angular/material/sort';
import { MatDialogModule } from '@angular/material/dialog';

const modules = [
  CommonModule,
  FlexLayoutModule,
  FormsModule,
  ReactiveFormsModule,
  BrowserAnimationsModule,
  MatToolbarModule,
  MatInputModule,
  MatCardModule,
  MatMenuModule,
  MatIconModule,
  MatButtonModule,
  MatTableModule,
  MatDividerModule,
  MatSlideToggleModule,
  MatSelectModule,
  MatOptionModule,
  MatProgressSpinnerModule,
  MatSidenavModule,
  MatListModule,
  MatPaginatorModule,
  MatSortModule,
  MatDialogModule
];

@NgModule({
  declarations: [],
  imports: modules,
  exports: modules
})
export class MaterialModule { }

Соответственно для PrimeNG добавляем те модули, которыми будем пользоваться.

Далее переходим в app.module.ts и добавляем модули:

imports: [
    BrowserModule,
    AppRoutingModule,
    BrowserAnimationsModule,
    MaterialModule,
    PrimengModule,
    ReactiveFormsModule,
    FormsModule,
    HttpClientModule
  ],

Так же добавим 2 провайдера:

providers: [
    {
      provide: HTTP_INTERCEPTORS,
      useClass: InterceptorInterceptor,
      multi: true,
    },
    MessageService
  ]
,

Ну вот и все

Получился такой простенький web-интерфейс. Полный код находится в git-репозитории.

Требования

Если немного пофантазировать, то база должна быть не нагружена, в противном случае может произойти просадка производительности. В данном случае диски у нас не такие большие (SD-карта), а если посмотреть по предыдущей статье, то список блокировки примерно из 100 тысяч записей занимает не очень много памяти (в моем случае около 25МБ). Возьмем SQLite. Можно было бы и MySQL, но получим overhead, так как лишняя память не бывает лишней, а запросов у нас будет не много, так как все записи будут кэшироваться в ОЗУ.

Вторая проблема, которую не плохо было бы решить — это аутентификация. В самом вводе пароля ничего такого криминального нет, но вот сессии где-то надо хранить (ОЗУ, диск, другой сервер и т. д.). Опять же это накладывает определенные ресурсы (мы же экономисты для одноплатника). По сути для домашнего сервера нам нужно просто защититься паролем и для выполнения операций проверять что мы авторизированы. Возьмем JWT. Не требует хранения на сервере, а ключ сессии будет передаваться с основным запросом.

База данных

Для начала подготовим функции работы с БД (db/db.go):

package db

import (
	"dns-adblock/db/models"
	"log"
	"os"
	"time"

	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

var DB *gorm.DB

func Connect() {
	dsnSQLite := "database/database.db"
	logLevel := logger.Info

	var err error
	newLogger := logger.New(
		log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
		logger.Config{
			SlowThreshold: time.Second, // Slow SQL threshold
			LogLevel:      logLevel,    // Log level
			Colorful:      false,       // Disable color
		},
	)
	newLogger.LogMode(logger.Info)
	DB, err = gorm.Open(sqlite.Open(dsnSQLite), &gorm.Config{
		Logger:                                   newLogger,
		DisableForeignKeyConstraintWhenMigrating: true,
	})
	if err != nil {
		panic(err)
	}

	// Установим пул соединений
	dbSettings, err := DB.DB()
	if err != nil {
		panic(err)
	}
	dbSettings.SetMaxIdleConns(10)
	dbSettings.SetMaxOpenConns(50)
	dbSettings.SetConnMaxLifetime(time.Minute * 10)

	// Создание БД

	DB.AutoMigrate(
		&models.Blacklist{},
		&models.Whitelist{},
	)
}

После нам понадобятся модели в директории db/models.

base.go:

package models

import (
	"time"

	uuid "github.com/satori/go.uuid"
	"gorm.io/gorm"
)

type Base struct {
	ID        uuid.UUID `gorm:"type:uuid;primary_key" json:"id"`
	CreatedAt time.Time `gorm:"column:created_at" json:"createdAt"`
	UpdatedAt time.Time `gorm:"column:updated_at" json:"updatedAt"`
	DeletedAt time.Time `gorm:"column:deleted_at;index" json:"deletedAt"`
}

func (base *Base) BeforeCreate(scope *gorm.DB) (err error) {
	if base.ID == uuid.Nil {
		base.ID = uuid.NewV4()
	}
	return nil
}

whitelist.go:

package models

type Whitelist struct {
	Base
	Domain   string  `gorm:"column:domain;type:varchar;size:255" json:"domain"`
	Type     uint16  `gorm:"column:record_type" json:"type"`
	Priority *uint16 `gorm:"column:priority" json:"priority"`
	Weight   *uint16 `gorm:"column:weight" json:"weight"`
	Port     *uint16 `gorm:"column:port" json:"port"`
	Address  *string `gorm:"column:address;type:varchar;size:255" json:"addr"`
}

blacklist.go:

package models

type Blacklist struct {
	Base
	Domain string `gorm:"column:domain;type:varchar;size:200"`
}

Здесь должно быть все предельно просто и понятно.

Теперь в описание типов структур добавим еще одну:

type DNSRecordWeb struct {
	Domain string `json:"domain"`
	Type   uint16 `json:"type"`

	//Addrs *[]struct {
	Addr     *string `json:"addr"`
	Priority *uint16 `json:"priority"`
	Weight   *uint16 `json:"weight"`
	Port     *uint16 `json:"port"`
	//} `json:"addrs"`
}

WEB-сервер

Для работы HTTP-сервера я использую фреймворк Echo. Как в нем использовать JWT читайте в документации.

Весь код я сюда выводить не буду, а только основные моменты.

Чтобы получить список доменов, нужно создать такую функцию:

func list(c echo.Context) error {
	libs.BlackList.Mutex.RLock()
	defer libs.BlackList.Mutex.RUnlock()

	len := len(libs.BlackList.List)
	res := make([]string, len)
	i := 0
	for key := range libs.BlackList.List {
		res[i] = key
		i++
	}
	return c.JSON(
		http.StatusOK,
		res,
	)
}

Добавление записи в БД особо не сложнаю, просто объемная:

func add(c echo.Context) error {
	libs.BlackList.Mutex.Lock()
	defer libs.BlackList.Mutex.Unlock()

	var newDnsRecord struct {
		Domain string `json:"domain"`
	}
	err := json.NewDecoder(c.Request().Body).Decode(&newDnsRecord)
	if err != nil {
		return c.JSON(http.StatusBadRequest, structs.Result{
			Result:  false,
			Code:    http.StatusBadRequest,
			Message: &[]string{"Error request"}[0],
		})
	}

	domain := strings.ToLower(libs.PrepareStr.ReplaceAllString(libs.RegexpLastComma.ReplaceAllString(libs.PrepareStr.ReplaceAllString(newDnsRecord.Domain, ""), ""), ""))
	if domain != "" {
		if _, ok := libs.BlackList.List[domain]; !ok {

			var err error
			tx := db.DB.Begin()

			defer func() {
				libs.EndTransaction(tx, err)
			}()

			if res := tx.Create(&models.Blacklist{
				Domain: domain,
			}); res.RowsAffected == 0 {
				err = res.Error
				return c.JSON(
					http.StatusInternalServerError,
					structs.Result{
						Code:    http.StatusInternalServerError,
						Result:  false,
						Message: &[]string{res.Error.Error()}[0],
					},
				)
			}

			libs.BlackList.List[domain] = &structs.DNSRecord{}

			return c.JSON(
				http.StatusOK,
				structs.Result{
					Code:   http.StatusOK,
					Result: true,
				})
		}
	}
	return c.JSON(
		http.StatusConflict,
		structs.Result{
			Code:   http.StatusConflict,
			Result: false,
		})
}

Удаление записи тоже ничего сверхъестестенного не несет:

func remove(c echo.Context) error {
	libs.BlackList.Mutex.Lock()
	defer libs.BlackList.Mutex.Unlock()
	domain := strings.ToLower(libs.PrepareStr.ReplaceAllString(libs.RegexpLastComma.ReplaceAllString(libs.PrepareStr.ReplaceAllString(c.Param("domain"), ""), ""), ""))

	if domain != "" {
		if _, ok := libs.BlackList.List[domain]; ok {
			var err error
			tx := db.DB.Begin()

			defer func() {
				libs.EndTransaction(tx, err)
			}()

			if res := tx.Delete(&models.Blacklist{}, "domain = ?", domain); res.RowsAffected == 0 {
				err = res.Error
				return c.JSON(
					http.StatusInternalServerError,
					structs.Result{
						Code:    http.StatusInternalServerError,
						Result:  false,
						Message: &[]string{res.Error.Error()}[0],
					},
				)
			}
			delete(libs.BlackList.List, domain)
			return c.JSON(
				http.StatusOK,
				structs.Result{
					Code:   http.StatusOK,
					Result: true,
				})
		}
	}
	return c.JSON(
		http.StatusNotFound,
		structs.Result{
			Code:   http.StatusNotFound,
			Result: false,
		})
}

Тут главное не забывать не только работать с базой данных, но и обновлять массив, чтобы изменения сразу применялись.

Это было для черного списка. Белый список реализуется по такому же принципу. Тут добавляется проверка типа записи и полей немного больше, а так все то же самое.

Загрузка данных

При запуске сервера необходимо загружать записи из БД. Для этого в функцию LoadBlacklist добавим небольшой кусок кода:

// Загружаем из БД
tx := db.DB.Begin()

defer func() {
    EndTransaction(tx, err)
}()

var domains []models.Blacklist

if res := tx.Find(&domains); res.RowsAffected > 0 {
    // Есть список в БД. Добавим в список в ОЗУ
    for _, domain := range domains {
        if _, ok := BlackList.List[domain.Domain]; !ok {
            BlackList.List[domain.Domain] = &structs.DNSRecord{}
        }
    }
}

Для белого списка все аналогично, только, опять же, кода немного больше из-за проверки типов записей.

Запускаем сервер

Теперь нужно запустить сервер, чтобы он мог нам отвечать. Для этого в файл mail.go добавим немного кода. В функцию init():

e = echo.New()

// Middleware
middlewares.Init(e)

// Routes
routes.Route(e)

И в main():

go func() {
    e.Logger.Fatal(e.Start(fmt.Sprintf(":%d", libs.Config.WebPort)))
}()

Не забываем добавить просмотр некоторых переменных окружения:

if tmp, exists = os.LookupEnv("WEBPORT"); exists {
    Config.WebPort, err = strconv.Atoi(tmp)
    if err != nil {
        panic(err)
    }
} else {
    Config.Port = 3000
}

if tmp, exists = os.LookupEnv("FILL_EXTRA"); exists {
    if tmp == "true" || tmp == "1" {
        Config.FillExtra = true
    }
}

if Config.Password, exists = os.LookupEnv("PASSWORD"); !exists {
    alphabet := "ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%*&"

    Config.Password = ""

    for i := 0; i

Немного пояснений

Чтобы воспользоваться функциями необходимо сначала аутентифицироваться. Для этого выполняем POST-запрос по пути http://localhost:3000/api/login в формате JSON со следующей структурой:

{
    "password": "{{password}}"
}

Если пароль верный, то в ответ получим токен. Далее берем этот токен и к остальным запросам в заголовок Authorization добавляем значение “Bearer {{token}}” и передаем параметры запроса.

Заключение, но не конец

Теперь можно делать автоматизацию управления записями с помощью, например, curl+bash+jq.

Весь исходный код доступен в git-репозитории.

С чего начать?

Для начала нужно определиться для чего он нам нужен. Лично я для себя определил, что это должен быть сервер с поддержкой Forward-запросов и «черного списка» доменов. В дальнейшем я подумал а почему бы не прикрутить еще и «белый список«? Но я пока не представлял себе что это будет и для чего он мне. Позже я разобрался, но об этом позже.

Второй вопрос это на чем будет все это базироваться. Самая главная сложность — это формирование запросов как клиент и ответов как сервер. В счастью есть готовые библиотеки, и не нужно будет изобретать колеса. А вот все остальное…

Структуры

Где-то и как-то нужно всю информацию хранить. Думаю, для домашнего использования, вполне должен подойти тип map. А вот и сама структура(ы):

type DNSRecord struct {
	Name  string // Название доменного имени или его части
	Type  uint16 // Тип записи
	Class uint16 // Тип класса записи
	// Ttl   uint32 // Время жизни
	Addr  *[]Addr
	Mx    *[]Mx
	CName *[]CName
	DName *[]DName
	Ptr   *[]Ptr
	Txt   *[]Txt
	Srv   *[]Srv
}

type Addr struct {
	Addr net.IP    // Адреса
	Ttl  time.Time // ТТЛ
}

type Mx struct {
	Addr       string    // Адрес почтового сервера
	Preference uint16    // Предпочтение
	Ttl        time.Time // TTL
}

type CName struct {
	Addr string
	Ttl  time.Time
}

type DName struct {
	Addr string
	Ttl  time.Time
}

type Ptr struct {
	Addr string
	Ttl  time.Time
}

type Txt struct {
	Addr string
	Ttl  time.Time
}

type Srv struct {
	Priority uint16
	Weight   uint16
	Port     uint16
	Target   string
	Ttl      time.Time
}

Теперь есть еще другая проблема — потоконебезопасный тип map. Что-то с ним надо придумать:

type TypeList struct {
	Mutex sync.RWMutex
	List  map[string]*DNSRecord
}

Ну и сами списки:

var BlackList *structs.TypeList
var WhiteList *structs.TypeList
var CacheDomain *structs.TypeList

И еще немного подготовки:

var RegexpLastComma = regexp.MustCompile(",$")
var RegexpLastDash = regexp.MustCompile(`\.$`)
var PrepareStr = regexp.MustCompile(`[\s\t]+`)

Эти регулярные выражения понадобятся для подготовки строк.

Обработчики

Думаю создание сервера не очень интересно. Гораздо интереснее обработка запросов:

func Handler(w dns.ResponseWriter, req *dns.Msg) {
	var err error
	var lines []dns.RR
	defer w.Close()

	m := new(dns.Msg)
	m.Authoritative = true
	m.SetReply(req)

	for _, question := range req.Question {

		var ls []dns.RR
		ls, err = Question(question.Name, question.Qtype, &question)
		lines = append(lines, ls...)
		if err != nil {
			log.Println(err)
		}
	}

	m.Answer = append(m.Answer, lines...)

	err = w.WriteMsg(m)
	if err != nil {
		log.Println(err)
	}
}

Здесь мы из пакета читаем запросы по очереди и обрабатываем, подготавливая записи для ответа. Теперь сама функция Question:

func Question(name string, qtype uint16, question *dns.Question) (lines []dns.RR, err error) {

	// Проверка в списке блокировок
	if SearchInBlackList(name, qtype) != nil {
		// Если в списке блокировки, то ничего не возвращаем, типа домена такого не существует
		return
	}

	if qtype == dns.TypeA || qtype == dns.TypeAAAA {
		if res := SearchInWhiteList(name, dns.TypeCNAME); res != nil {
			lines = append(lines, PrepareMessage(question, res)...)
			if len(*res.CName) > 0 {
				for _, cname := range *res.CName {
					var ls []dns.RR
					ls, err = Question(cname.Addr, dns.TypeA, question)
					if err != nil {
						return
					}
					lines = append(lines, ls...)

					ls, err = Question(cname.Addr, dns.TypeAAAA, question)
					if err != nil {
						return
					}
					lines = append(lines, ls...)
				}

			}
			if len(lines) > 0 {
				return
			}
		}
		if res := SearchInWhiteList(name, dns.TypeDNAME); res != nil {
			lines = append(lines, PrepareMessage(question, res)...)
			if len(*res.DName) > 0 {
				for _, dname := range *res.DName {
					var ls []dns.RR
					ls, err = Question(dname.Addr, dns.TypeA, question)
					if err != nil {
						return
					}
					lines = append(lines, ls...)

					ls, err = Question(dname.Addr, dns.TypeAAAA, question)
					if err != nil {
						return
					}
					lines = append(lines, ls...)
				}

			}
			if len(lines) > 0 {
				return
			}
		}

	}

	if res := SearchInWhiteList(name, qtype); res != nil {
		lines = append(lines, PrepareMessage(question, res)...)
		if len(lines) > 0 {
			return
		}
	}

	// Проверим есть ли в кэше данные

	if qtype == dns.TypeA || qtype == dns.TypeAAAA {
		if res := SearchInCache(name, dns.TypeCNAME); res != nil {
			lines = append(lines, PrepareMessage(question, res)...)
			if len(*res.CName) > 0 {
				for _, cname := range *res.CName {
					var ls []dns.RR
					ls, err = Question(cname.Addr, dns.TypeA, question)
					if err != nil {
						return
					}
					lines = append(lines, ls...)

					ls, err = Question(cname.Addr, dns.TypeAAAA, question)
					if err != nil {
						return
					}
					lines = append(lines, ls...)
				}

			}
			if len(lines) > 0 {
				return
			}
		}

	}

	if res := SearchInCache(name, qtype); res != nil {
		lines = append(lines, PrepareMessage(question, res)...)
		if len(lines) > 0 {
			return
		}
	}

	// Опросим внешний DNS для поиска записей
	msg := &dns.Msg{}
	msg.SetQuestion(name, qtype)

	c := &dns.Client{
		Net:          "udp",
		ReadTimeout:  time.Second * 5,
		WriteTimeout: time.Second * 5,
	}

	ticker := time.NewTicker(5 * time.Second)
	defer ticker.Stop()

	ch := make(chan *dns.Msg, 1)
	var wg sync.WaitGroup

	// Функция отправления запроса на внешний DNS-сервер
	requestToDNS := func(nameserver string) {
		defer wg.Done()

		m := dns.Msg{}
		m.SetQuestion(name, qtype)

		msg, _, err := c.Exchange(&m, nameserver)
		if err != nil {
			log.Printf("error: %s", err.Error())
			return
		}

		ch  0 {
				for _, cname := range *res.CName {
					var ls []dns.RR
					ls, err = Question(cname.Addr, dns.TypeA, question)
					if err != nil {
						return
					}
					lines = append(lines, ls...)
					ls, err = Question(cname.Addr, dns.TypeAAAA, question)
					if err != nil {
						return
					}
					lines = append(lines, ls...)
				}

			}
			if len(lines) > 0 {
				return
			}
		}

	}

	if res := SearchInCache(name, qtype); res != nil {
		lines = append(lines, PrepareMessage(question, res)...)
	}

	return
}

Функция получилась достаточно крупная и, возможно, не оптимальная. Ее надо пояснить.

Сначала ищем запись в черном списке. Если она найдена, то поиск останавливаем. После проверяем является ли запрос типа записи A или AAAA. Как раз это важный момент. Если запись являеися типом CNAME или DNAME, то мы не найдем запись и вернем клиенту пустой ответ, а это не правильно. После того как нашли CNAME или DNAME (если они, конечно, есть) нам снова нужно найти записи типа A или AAAA. Если мы в одном ответе не отдадим клиенту обе эти записи при наличии альясов, то у нас просто дальше работать не будет, потому что тот же браузер не делает запросы. У меня так встал FireFox и apt. Было обидно.

Далее после проверки записей в своем кэше, если ничего не найдено, делаем запрос в указанных серверах. Соответственно обрабатываем ответы и помещаем их в кэш. Это и будет у нас Forward-сервер. Причем, если TTL еще не закончился, то запись будет отдаваться клиенту из кэша, что уменьшит внешний запрос и, по идее, должен ускорить время ответа.

Собственно все.

Организация поиска

Реализация поиска в списках достаточно проста:

// Найдем домен в листе блокировки
func SearchInBlackList(domain string, domainType uint16) *structs.DNSRecord {
	return SearchInList(domain, domainType, BlackList)
}

// Найдем домен в листе допущенных
func SearchInWhiteList(domain string, domainType uint16) *structs.DNSRecord {
	return SearchInList(domain, domainType, WhiteList)
}

// Найдем домен в кэше
func SearchInCache(domain string, domainType uint16) *structs.DNSRecord {
	return SearchInList(domain, domainType, CacheDomain)
}

// Найдем домен в списке
func SearchInList(domain string, domainType uint16, list *structs.TypeList) *structs.DNSRecord {
	list.Mutex.RLock()
	defer list.Mutex.RUnlock()
	domain = RegexpLastDash.ReplaceAllString(strings.Trim(domain, " "), "")

	if len([]rune(domain)) == 0 {
		return nil
	}

	if val, ok := list.List[domain]; ok {
		return val
	}

	if domainType == dns.TypeA || domainType == dns.TypeAAAA {
		if val, ok := list.List[fmt.Sprintf(`%s_%d`, domain, dns.TypeCNAME)]; ok {
			return val
		}
	}
	if val, ok := list.List[fmt.Sprintf(`%s_%d`, domain, domainType)]; ok {
		return val
	}
	return nil
}

Вообще ничего сложного. Просто ищем в списках не забывая накладывать блокировку, иначе программа «вылетить» из-за конкурентного доступа.

Добавление в кэш

Я покажу только часть кода, так как остальной год достаточно просто дописать самостоятельно. В нем присутствует немного магии, но она не сложная. И так:

func AddInCache(msg *dns.Msg) {
	CacheDomain.Mutex.Lock()
	defer CacheDomain.Mutex.Unlock()

	if len(msg.Answer) > 0 {

		for _, answer := range msg.Answer {
			AddInCacheLine(answer)
		}
	}

	if len(msg.Extra) > 0 {
		for _, extra := range msg.Extra {
			AddInCacheLine(extra)
		}
	}
}

func AddInCacheLine(answer dns.RR) {
	var msgi interface{} = answer
	switch v := (msgi).(type) {
	case *dns.A:
		domain := RegexpLastDash.ReplaceAllString(strings.Trim(v.Hdr.Name, " "), "")
		if dnsRecord := CacheDomain.List[fmt.Sprintf(`%s_%d`, domain, v.Hdr.Rrtype)]; dnsRecord != nil {
			// Добавим адрес в существующую запись
			// Найдем есть ли этот адрес уже в записи
			if dnsRecord.Addr != nil {
				if len(*dnsRecord.Addr) == 0 {
					var a structs.Addr
					a.Addr = v.A
					a.Ttl = time.Now().Local().Add(time.Second * time.Duration(v.Hdr.Ttl))
					dnsRecord.Addr = &[]structs.Addr{a}
				} else {
					search := false
					for i := range *dnsRecord.Addr {
						if net.IP.Equal((*dnsRecord.Addr)[i].Addr, v.A) {
							search = true
							(*dnsRecord.Addr)[i].Ttl = time.Now().Local().Add(time.Second * time.Duration(v.Hdr.Ttl))
						}
					}
					if !search {
						var a structs.Addr
						a.Addr = v.A
						a.Ttl = time.Now().Local().Add(time.Second * time.Duration(v.Hdr.Ttl))
						addrs := *dnsRecord.Addr
						addrs = append(addrs, a)
						dnsRecord.Addr = &addrs
					}
				}
			} else {
				var a structs.Addr
				a.Addr = v.A
				a.Ttl = time.Now().Local().Add(time.Second * time.Duration(v.Hdr.Ttl))
				dnsRecord.Addr = &[]structs.Addr{a}
			}
		} else {
			dnsRecord := structs.DNSRecord{
				Name:  domain,
				Type:  v.Hdr.Rrtype,
				Class: v.Hdr.Class,
				Addr: &[]structs.Addr{
					{
						Addr: v.A,
						Ttl:  time.Now().Local().Add(time.Second * time.Duration(v.Hdr.Ttl)),
					},
				},
			}
			CacheDomain.List[fmt.Sprintf(`%s_%d`, dnsRecord.Name, dnsRecord.Type)] = &dnsRecord
		}
        }
}

Собственно нужно реализовать конструкцию switch для разных типов записей. Кто знает более элегантный способ, пожалуйста, не стесняйтесь.

Ответы

Формирование ответов тоже достаточно просто получается. В функции нужно все так же дописать конструкцию switch. Главное сам принцип:

func PrepareMessage(req *dns.Question, res *structs.DNSRecord) (lines []dns.RR) {
	// Нашли в кэше. Сразу отдадим клиенту
	head := dns.RR_Header{
		Name:   req.Name,
		Rrtype: req.Qtype,
		Class:  req.Qclass,
	}
	now := time.Now().Local()
	switch res.Type {
	case dns.TypeA:
		for _, addr := range *res.Addr {
			if addr.Ttl.After(now) {

				line := &dns.A{
					Hdr: head,
					A:   addr.Addr,
				}
				line.Hdr.Ttl = uint32(addr.Ttl.Sub(now) / time.Second)
				line.Hdr.Rrtype = dns.TypeA
				line.Hdr.Name = fmt.Sprintf("%s.", res.Name)
				lines = append(lines, line)
			}
		}
	}

	return
}

И это все.

Списочки

Эта вся работа учитывает и черный список и белый список. Если с черным списком все понятно, то вот с белым хотелось бы определиться. В итоге я решил, что это будут записи как в самом обычном DNS-сервере.

Как это быдет работать? Все просто! Если мы добавим нужную запись нужного типа в белый список, то мы его будем хранить все время. Получится такой мини-dns для домашних собственных нужд. Чтобы такое реализовать нужно подумать над форматами.

Для черного списка все элементарно: просто одна строка — один домен. Для белого списка будет определенный формат:

  [приоритет целевого хоста] [вес записи] [порт]

где:

Домен — доменное имя Тип записи — A, AAAA, CNAME, DNAME, MX, SRV Приоритет целевого хоста — приоритет хоста для записи SRV. Более низкое значение имеет более высокий приоритет Вес записи — относится к типу записи MX и SRV Порт — порт TCP или UDP, на котором работает сервис Адрес — конечный адрес

Все TTL устанавливаются по умолчанию 600.

Списки необходимо загрузить. Черный список:

func LoadBlacklist() {
	if _, err := os.Stat("database/blacklist.txt"); errors.Is(err, os.ErrNotExist) {
		return
	}

	file, err := os.Open("database/blacklist.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	scanner.Split(bufio.ScanLines)

	for scanner.Scan() {
		str := strings.Trim(scanner.Text(), " ")
		if len([]rune(str)) > 0 {
			if ([]rune(str))[0] != '#' {
				domain := strings.ToLower(strings.Trim(str, " "))
				BlackList.List[domain] = &structs.DNSRecord{}
			}
		}
	}
}

Вообще ничего сложного! Просто читаем построчно и добавляем в список.

Теперь белый список:

func LoadWhitelist() {
	if _, err := os.Stat("database/whitelist.txt"); errors.Is(err, os.ErrNotExist) {
		return
	}

	file, err := os.Open("database/whitelist.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	scanner.Split(bufio.ScanLines)

	for scanner.Scan() {
		strs := strings.Split(PrepareStr.ReplaceAllString(strings.Trim(scanner.Text(), " "), " "), " ")
		if len(strs) >= 3 {
			strs[0] = strings.ToLower(strs[0])
			strs[1] = strings.ToUpper(strs[1])
			strs[2] = strings.ToLower(strs[2])

			if len(strs) == 4 {
				strs[3] = strings.ToLower(strs[3])
			}

			switch strs[1] {
			case "A":
				dnsRecord := structs.DNSRecord{
					Name: strs[0],
					Type: dns.TypeA,
					Addr: &[]structs.Addr{
						{
							Addr: net.ParseIP(strs[2]),
							Ttl:  time.Now().Local().Add(time.Second * time.Duration(600)),
						},
					},
				}
				WhiteList.List[fmt.Sprintf(`%s_%d`, strs[0], dns.TypeA)] = &dnsRecord
			default:
				err := fmt.Errorf(`unknow type record: %s`, strs[1])
				panic(err)
			}
		}
	}
}

Немного сложнее, но не на много. Здесь так же нужно дописать switch для требуемых типов записей.

Сервер готов.

Да, это простейший сервер, который не учитывает очень многое. Во всяком случае я его писал для своего домашнего сервера и он у меня работает.

Не спорю, в нем нет интерфейса, хотелось бы прикрутить REST API для работы, да еще и перезагружать нужно, чтобы перечитать списки. Минус еще в том, что при перезагрузке теряется кэш. Да, его хранить нет смысла, но при перезапуске клиенты перестают работать пока сервер снова не включится. В общем есть над чем работать, а пока полный исходный код находится в git-е.

Что за зверь?

DNS или Domain Name System — это специализированная система которая умеет по имени домена определять какие-то параметры работы в сети Internet. Обычно его используют для получения IP-адреса по имени. Например, когда вы вводите адрес в браузере, то перед подключением к серверу он сначала спрашивает у службы DNS какой реальный IP-адрес у сервера и, если все прошло успешно, подключается непосредственно к серверу и запрашивает страницы. Это было придумано для того, чтобы не запоминать цифровые адреса, а какие-то осмысленные имена.

Помимо такой информации DNS может хранить и некоторую другую информацию о домене. Достаточно часто ею пользуются почтовые серверы и клиенты, корпоративные сети, да и просто разработчики и администраторы для настройки каких-то систем и программ и т.д. По сути это неотъемлемая часть нашей сегодняшней повседневной жизни.

Как хранится информация?

Информацию в DNS можно представить в виде специализированной базы, в которой хранятся записи с определенными их типами. Каждый тип записи несет собственную нагрузку и отвечает за свою область деятельности.

Какие записи бывают?

Типов записей достаточно много. Каждая из них отвечает за свою область деятельности. Все их рассматривать я не буду, а только расскажу о тех, с которыми я лично столкнулся.

Важно знать, что существует 2 основных типа адресации в Internet: IPv4 и IPv6. На самом деле их гораздо больше, нам на текущий момент они не нужны.

Чтобы посмотреть самостоятельно эти записи нужно установить соответствующее по. В Debian:

sudo apt install dnsutils

Чтобы установить утилиту dig в Windows нужно загрузить и установить соответствующий скомпилированный пакет BIND9.

A

Этот тип записи отвечает за тип ресурса IPv4. Например, роутер в домашней сети имеет адрес 192.168.0.1. Чтобы к нему подключиться и настроить обычно указывается этот адрес в браузере. С помощью DNS можно было бы задать ему доменный адрес, например, router.loc. Тогда DNS запись будет выглядеть так:

router.loc.             72220   IN      A   192.168.0.1

Точка в конце имени домена говорит о том, что просмотр начинается от корня доменной системы. Об этом написано в спецификациях.

Чтобы просмотреть информацию нужно выполнить команду:

dig

АААА

Этот тип записи является эквивалентным типу записи A. Разница в том, что возвращается не IPv4, а IPv6.

dig  A

MX

Этот тип записи нужен, чтобы определить по основному домену какой домен используется для сервера электронной почты. MX расшифровывается как Mail Exchange.

Мы все привыкли отправлять электронную почту в виде user@server1.loc, где user — имя пользователя а server1.loc — сервер, на котором пользователь зарегистрирован. Теперь представьте, что нужно отправить письмо пользователю user@server2.loc от пользователя user@server1.loc. server1.loc и server2.loc — это абсолютно 2 разных сервера. Так как же серверы понимают куда отправлять письмо?

Все просто! Почтовый сервер server1.loc смотрит на адрес, где после символа @ указан почтовый сервер. Он спрашивает у DNS какой домен используется для этого сервера:

dig  MX

Если такая запись есть, то DNS возвращает домен этого сервера. На самом деле обычный домен, например сайта, и домен почтового обменника могут различаться как логически, так и физически.

После этого, как получен домен почтового обменника, сервер запрашивает адрес из записи A или AAAA (смотря какая адресация требуется) и уже может спокойно подключиться для обмена корреспонденцией.

PTR

Еще одна запись, которая часто используется с почтовыми серверами. Ее цель сделать обратное преобразование, т.е. какое доменное имя у адреса.

dig -x

Частая практика это проверка почтовым сервером отправитель, т.е. принимающий почтовый сервер спрашивает доменное имя. Если такой записи нет или она не ведет на тот же сервер, то должен возникнуть вопрос а стоит ли доверять ему. Это делается для защиты от «спамеров«.

CNAME

Эта запись используется для определения псевдонимов домена. К примеру, изменился домен сайта, но люди еще по старой памяти открывают старое название. Чтобы они так же могли продолжать работать с помощью CNAME устанавливается перенаправление на другой домен, а потом уже для другого домена определяется его реальный адрес. Обычно CNAME используется временно и удаляется через какой-то определенный срок.

dig  CNAME

DNAME

Эта запись так же используется для определения псевдонимов домена, но на постоянной основе. Принцип работы его такой же.

dig  DNAME

TXT

Данная запись является информационной. В нее добавляется различный текст, а он в свою очередь может являться определенными настройками. Так в записях TXT могут храниться записи SPF, в которых указывается какая-то информация для почтового сервера.

dig  TXT

SRV

Эта запись предназначена для определения какая служба где находится. Так эту запись используют для определения серверов SIP (телефония), Active Directory (в корпоративных сетях), XMPP (служба обмена мгновенных сообщений) и т.д. У нее все та же роль: узнать реальный сервер, с которым можно установить соединение для дальнейшей работы.

dig _-._. SRV

В ответ DNS-сервер отвечает с именем домена, где расположен сервер, приоритет, вес и портом, к которому необходимо подключаться.

Это все?

На самом деле существует очень много типов записей, с которыми работает DNS. Я рассмотрел лишь популярные, которые используются на стороне клиента. Существуют так же записи, например, SOA с эталонной информацией о домене, **NS **с информацией о сервере, являющийся владельцем домена и т.д. Все эти записи описаны в специальных документах под названием RFC и имеющих свой номер с описанием спецификации. Для тех, кто хочет использовать его на домашнем сервере можно установить специализированные программы, которые будут являться как самостоятельным сервером, так и, так называемым, Forward-сервером.

Forward-сервер — это такой сервер, который является промежуточным и способен «кэшировать» запросы, чтобы разгрузить основной сервер и минимизировать время ответа клиенту.

Бродя по просторам интернета наткнулся я на статью с проектом Pi-Hole. Крутость этой штуки в том, что она ставится на одноплатник и просто работает. Ну у нас же есть уже готовый домашний сервер! Тогда приступим.

Немного теории

Основной принцип работы данного сервера, это обычный DNS-сервер. Через него проходят DNS-запросы и проверяются нет ли записи в черном списке. Если же нету, то выполняется forward-запрос на внешний DNS-сервер. Таким образом мы просто фильтруем домены. Все достаточно просто.

Практика

И так, как обычно по канонам мастерства нашей настройки создадим файл /opt/pihole/docker-compose.yml следующего содержимого:

version: "2.4"

services:
  pihole:
    image: pihole/pihole:2021.11
    restart: unless-stopped
    volumes:
      - type: bind
        source: /mnt/nfs/pihole/etc-pihole/
        target: /etc/pihole/
      - type: bind
        source: /mnt/nfs/pihole/etc-dnsmasq.d/
        target: /etc/dnsmasq.d/
    mem_limit: 256m
    mem_reservation: 64m
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "8086:80/tcp"
    environment:
      TZ: 'Europe/Moscow'
      WEBPASSWORD:
    cap_add:
      - NET_ADMIN

После создаем файл /etc/systemd/system/pihole.service:

[Unit]
Description=PiHole docker-compose
Requires=docker.service
After=docker.service

[Service]
Restart=always

WorkingDirectory=/opt/pihole/

# Compose up
ExecStart=/usr/bin/docker-compose -f docker-compose.yml up

# Compose down, remove containers
ExecStop=/usr/bin/docker-compose -f docker-compose.yml down

[Install]
WantedBy=multi-user.target

Далее создаем пару директорий:

mkdir -p /mnt/nfs/pihole/etc-pihole
mkdir -p /mnt/nfs/pihole/etc-dnsmasq.d

И все это дело запускаем:

systemctl daemon-reload
systemctl enable pihole && systemctl enable pihole

После заходим по адресу http://:8086 и смотрим, что все работает.

Настройка домашней сети

Теперь требуется немного настроить домашнюю сеть. Так как дома обычно используется роутер для подключения к интернету, то он является шлюзом. Обычно при включении компьютера роутер выдает адрес и некоторые сетевые настройки. Нас интересует настройка DNS. Для этого идем в роутер и в настройках DHCP-сервера указываем IP-адрес нашего нового DNS-сервера.

Если же на устройствах настроена «статика», то настраиваем уже устройства.

Решаем проблемы

После того, как зашли в web-интерфейс попробуем добавить домен в whitelist или blacklist. Если вываливается ошибка, то придется кое-что сделать вручную. Для этого в консоли выполняем:

docker exec -it pihole_pihole_1 chown -R www-data:pihole /etc/pihole
docker exec -it pihole_pihole_1 chmod -R 744 /etc/pihole

В данном случае мы выставляем права доступа для файлов. Так у меня случае они устанавливались не корректно (а может и корректно). В любом случае мне помогло.

Проверка

Чтобы проверить как это все работает идем по адресу https://d3ward.github.io/toolz/adblock.html и проверяем результат. Если все устраивает, то оставляем как есть. Если же нет, то добавляем то что нужно.

Что получилось

Теперь у нас в локальной сети есть свой DNS-сервер, который является еще и кэширующим, а на его основе можно отсечь нежелательные домены. Можно вписать домены, которые раздражают (реклама) и/или нежелательные ресурсы для детей (да и для взрослых). Уже прогресс.

Что такое HTTP-заголово

В протоколе HTTP при запросе страницы передаются какие-то стандартные заголовки, но так же могут передаваться и дополнительные. Это можно посмотреть в браузере, если нажать F12.

Ко всему прочему интерпретатор PHP предоставляет еще кое-какую дополнительную информацию, например, адрес сервера, адрес клиента, строки запроса и т.д. Для этого у него есть специальный объект $_SERVER. Всю информацию можно посмотреть в документации. У меня Nginx настроен как Reverse-прокси, т.е. web-сервер получает запрос, смотрит что пришло в заголовках и на основе этого определяет куда этот запрос направить дальше. В моем случае перед передачей запроса дальше web-сервер добавляет следующие заголовки:

proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Forwarded-Server $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $remote_addr;
proxy_set_header X-Forwarded-Proto $scheme;

Соответственно на сервер передаются те заголовки, которые являются, так сказать, стандартными + дополнительные.

Ну и в чем проблема?

При работе серверного кода разработчик уже с этими данными что-то делает. В моем случае в $_SERVER[‘REMOTE_ADDR‘] содержится адрес моего сервера, а адрес клиента находится в $_SERVER[‘X-FORWARDED-FOR’]. По хорошему WordPress должен его обрабатывать, но он его в упор не видит. Почему этот заголовок? Ну тут я не могу ответить. Сколько я смотрел в интернете, практически везде задают именно имя.

И что делать?

Для начала нужно понять, что PHP, по сути каждый раз выполняет какой-то скрипт и при каждом выполнении загружает файл настроек (например). Тогда, самым простым вариантом можно модифицировать его немного так, чтобы в PHP у нас X-FORWARDED-FOR как-то присваивался в REMOTE_ADDR. Я бы не стал трогать файлы самого движка, так как обновления могут все стереть и придется это делать каждый раз, а вот файл настроек практически не меняется, если только нет очень крупных изменений. Логично…

В таком случае заходим в файл wp-config.ph и опускаемся где у нас присутствует строчка проверки условия с параметром HTTP_X_FORWARDED_PROTO. После этого условия добавляем свое:

if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
        $_SERVER['REMOTE_ADDR'] = $_SERVER['HTTP_X_FORWARDED_FOR'];
}

На мой взгляд вполне подойдет.

Теперь, если у нас появляется заголовок HTTP_X_FORWARDED_FOR, то мы его присваиваем параметру REMOTE_ADDR и WordPress уже будет фиксировать нормально адреса.

Итог

Если есть в WordPress другое решение без модификации кода, то, наверно, это будет лучше. Я лично не нашел. По хорошему нужно не модифицировать заголовки, а обрабатывать их. В данном случае, на мой взгляд, это такой небольшой хак.

Выбор VPS

Тут я мог бы провести анализ рынка облаков, стоимости, качества, стабильности. Но я этого делать не буду. На рынке услуг просто масса и можно выбирать все что угодно согласно Вашему бюджету, предпочтению, желанию и требованиям. Вторая причина по которой я этого делать не буду — это реклама. Ну вот не хочу и все!

Чтобы подобрать для себя VPS нужно определиться с техническими характеристиками. В моем случае у меня будет установлено всего 3 основных приложения: openvpn, nginx и certbot. Для чего они нужны я буду говорить далее. На весь этот ворох приложений на текущий момент у меня уходит 260МБ ОЗУ, загрузка CPU (на одно ядро) не более 30% и HDD занято 5.5ГБ. Так что выбираем под себя (или даже один из самых дешевых на сколько это возможно). На счет скорости сети смотрим и оцениваем сами. Может вы будете гонять терабайты данных на высоких скоростях, а может и 100 мегабайт превышать не будет. Так что прикидываем и определяемся.

Что на счет операционной системы, то выбираем то, что умеем настраивать лучше всего. Просто потому что так проще. Лично я для себя выбрал CentOS из тех дистрибутивов, что были доступны.

Настройка хостера

Для начала нужно немного подготовить настройки хостинга. Первым делом идем в настройки самого хостера и настраиваем сеть. Первое это нужно убедиться, что нам дали внешний IP, по которому мы будем подключаться. После заходим в настройки безопасности сети и проверяем какие порты открыты. Понадобятся следующие порты:

• 80 (http)- 443 (https)- 22 (ssh)- 1194 (openvpn)

Все остальные можно закрыть (они не понадобятся). Как это сделать я не буду рассказывать, так как у каждого хостера свой интерфейс с настройками. По факту ничего сложного нету. Что касается портов, то 22-й множно перенести на другой, например 2222 с перенаправлением порта на 22 самой виртуальной машины (VM), а 1194 можно просто использовать другой, например, 11194й, ну или какой-то еще по желанию. 80й и 443й должны остаться такими, чтобы web-браузеры могли спокойной работать.

Если же хостинг не предоставляет таких настроек и Вам открыты все порты, то хорошим тоном будет настройка межсетевого экрана на самой VPS, иначе получится проходной двор. В общем «не секурно» как-то…

Подготовка ОС

Чтобы не мешал SELinux — выключим его. Для этого в консоли переходим в root и выполняем:

setenforce 0

И в файле /etc/sysconfig/selinux устанавливаем параметр SELINUX=disabled. Кстати, в CentOS по умолчанию редактор vim, но те кто хочет nano ставим так:

dnf install nano

Теперь подключаем epel (а вдруг пригодится):

yum install epel-release

Далее устанавливаем nginx по мануалу. Я не буду описывать, потому что все предельно просто.

Теперь устанавливаем некоторые пакеты:

dnf install openvpn certbot openvpn easy-rsa

Здесь мы устанавливаем CertBot для Let’s Encrypt, OpenVPN для соединения с нашим домашним сервером и easy-rsa для генерирования сертификатов и настройки тоннеля.

OpenVPN

Не хочу расписывать целые талмуты настройки тоннеля, так как этого материала полно. Все же есть некоторый моменты на которые я наткнулся и о них я немного расскажу.

Первым делом действуем по инструкции и генерируем сертификаты. Здесь все выполняется пошагово. Различия начинаются (как у меня сделано) в конфигурационных файлах самого OpenVPN.

На сервере файлы распологаются по пути /etc/openvpn/server и в моем случае конфигурационный файл называется gateway.conf:

port 1194
proto tcp
dev tun

server 10.26.0.0 255.255.255.0

keepalive 10 120

dh dh.pem
ca ca.crt
cert gateway.crt
key gateway.key
tls-auth ta.key 0

verb 3

status /var/log/openvpn/openvpn-status.log 1
status-version 3
log-append /var/log/openvpn/openvpn-client.log

client-config-dir /etc/openvpn/clients

comp-lzo

Вот тут появляются моменты, с которыми я столкнулся.

server 10.26.0.0 255.255.255.0

Здесь я устанавливаю водсеть самого vpn. У меня это будет 10.26.0.0/24. Соответственно выставляйте свою, которая Вам нравится. Просто это класс корпоративной сети. За подробностями стоит обратиться к соответствующей технической литературе.

keepalive 10 120

Вот этот параметр говорит, что каждые 10 секунд и, если в течении 120 секунд не будет ответа, то попытаться перезапустить туннель. Без этого у меня туннель зависал и отваливался. Обидно даже.

comp-lzo

Тут все просто! Включаем сжатие трафика в туннеле алгоритмом lzo. Бинарные сжатые данные конечно же не сожмутся (может даже чуть увеличится объем), а вот на текстовых данные это будет видно. Порой спорный параметр, нужно смотреть, но в общем и целом, думаю, использовать можно.

client-config-dir /etc/openvpn/clients

В этой директории будут лежать некоторые настройки для клиентов. Здесь все просто. У меня лежит один файл apps с таким содержимым:

ifconfig-push 10.26.0.253 10.26.0.1

Тут говорится, что подключенномe клиенту apps (так называется сертификат клиента и так его показывает openvpn) присвоить адрес 10.26.0.253 и сказать ему, что шлюз будет 10.26.0.1.

Перезапускаем сервер:

systemctl start openvpn-server@gateway && systemctl enable openvpn-server@gateway

OpenVPN-клиент

Теперь на домашнем сервере необходимо установить как раз соединение со шлюзом. Устанавливаем (напоминаю, у меня armbian):

apt install openvpn

Сразу идем в /etc/openvpn и наполняем файл client.conf настройками:

dev tun
proto tcp
remote  1194
client
resolv-retry infinite
ca /etc/openvpn/client/ca.crt
cert /etc/openvpn/client/apps.crt
key /etc/openvpn/client/apps.key

persist-key
persist-tun
comp-lzo
verb 3
status /var/log/openvpn/openvpn-status.log 1
status-version 3
log-append /var/log/openvpn/openvpn-client.log

tls-auth client/ta.key 1

keepalive 10 120

Файл клиента очень похож на файл сервера, просто в нем отличается пара строк. Так же не забываем скопировать с сервера сертификаты для клиента.

Теперь запускаем:

systemctl start openvpn@client && systemctl enable op[envpn@client

Обязательно проверяем, что туннель поднялся как на сервере, так и на клиенте с помощью команды ip a. В выводе должен появиться сетевой интерфейс tun и отобразиться IP-адреса, которые мы установили.

DNS

cloudПеред настройкой web-сервера хочется чтобы это было «красиво«. Так что бежим за покупкой доменного имени второго уровня! Проверяем желаемый и, если он свободен, покупаем и радуемся! Сказать тут больше нечего…

После покупки прописываем внешний IP-адрес нашего шлюза и ждем… Ждем… Ждем… Можем и сутки ждать, пока все заработает. Это нормально, так как DNS-запись должна распространиться по всем DNS-серверам.

Если нужен домен 3-го уровня на Вашем же домене 2-го уровня, то добавляем его там же и вешаем на этот же IP-адрес. В этом ничего страшного нет, так как web-сервер сам разрулит какой запрос к какому серверу перенаправить.

Nginx и CertBot

Вот тут, по сути, нужно их настраивать в паре. Чтобы настроить получение сертификатов я использовал вот эту статью. Работает и на CentOS (а чего бы ему не работать?).

Теперь когда все готово прописываем конфигурацию для нашего сайта:

server {
    listen       80;
    server_name   www.;

    access_log  /var/log/nginx/site.access.log  main;

    include acme;

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }

    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen      443 ssl http2;
    server_name  www.;

    gzip on;

    access_log /var/log/nginx/site.access.log;

    ssl_certificate /etc/letsencrypt/live//fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live//privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live//chain.pem;

    ssl_stapling on;
    ssl_stapling_verify on;

    ssl_ciphers "EECDH+ECDSA+AESGCM EECDH+aRSA+AESGCM EECDH+ECDSA+SHA384 EECDH+ECDSA+SHA256 EECDH+aRSA+SHA384 EECDH+aRSA+SHA256 EECDH+aRSA+RC4 EECDH EDH+aRSA RC4 !aNULL !eNULL !LOW !3DES !MD5 !EXP !PSK !SRP !DSS";
    #ssl_ciphers  "RC4:HIGH:!aNULL:!MD5:!kEDH";

    ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;

    ssl_prefer_server_ciphers on;

    ssl_session_cache   shared:SSL:100m;
    ssl_session_timeout 5m;

    add_header Strict-Transport-Security 'max-age=604800';
    add_header Content-Security-Policy "img-src https: data:; upgrade-insecure-requests";

    resolver 8.8.8.8;

    client_max_body_size 1024m;

    set_real_ip_from 10.26.0.1;
    real_ip_header X-Forwarded-For;

    location / {
        proxy_pass http://10.26.0.253:8080;
        proxy_set_header Host $host;
        proxy_redirect off;
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-Server $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_connect_timeout 120s;
        proxy_read_timeout 180s;
    }

    error_page 404              /404.html;

    error_page  500 502 503 504         /50x.html;

}

Вот тут нужно немного пояснить.

Тот сервер, что слушает 80й порт нужен чтобы ответить на acme для certbot, а остальные запросы перенаправить на 443й порт. Второй сервер, который слушает 443й порт перенаправляет запросы по vpn-каналу на наш домашний сервер. Вот собственно и все.

Теперь проверим правильно ли написана конфигурация (нет ли ошибок):

nginx -t

И, если все хорошо, скажем nginx чтобы применил конфигурацию:

nginx -s reload

Результат

Вот и все. Теперь можно спокойно отключать мобильник от домашнего Wi-Fi и пробовать ломиться по нашему адресу.

Материал

Прежде чем что-то делать нужно что-то иметь. Нам нужен текст. Не буду писать о нем много. Скажу только что сообщения предварительно нужно подготовить. Я сделал 2 файла CSV. Первый файл у меня содержит в первой колонке раздел, а во второй само сообщение. Второй файл будет содержать раздел и его отображаемое сообщение.

База данных

Для начала нужен пакет для работы с БД. Я возьму GORM. Библиотека может много чего взять на себя, а мы этим воспользуемся. Я буду использовать MariaDB так как она у меня уже есть и новый сервер я разворачивать не собираюсь (а зачем?). Устанавливаем:

go get gorm.io/gorm
go get gorm.io/driver/mysql
go get github.com/satori/go.uuid

Для работы с MariaDB мне понадобится пакет mysql. Так же я буду немного маньячить. Для этого и нужен пакет для работы с UUID. В принципе все готово.

Структура БД

Для начала создадим базовую структуру, которая будет будет использоваться во всех моделях (db/models/base.go):

package models

import (
	"time"
	"gorm.io/gorm"
)

type Base struct {
	ID        uint      `gorm:"type:uuid;primary_key;"`
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt gorm.DeletedAt `sql:"index"`
}

Эта структура описывает все самое необходимое для моделей. Теперь нам нужны 2е таблицы. Первая db/models/congrat_cats.go:

package models

type CongratCats struct {
	Base
	Name    string `gorm:"column:name;type:varchar(50);"`
	Display string `gorm:"column:name;type:text"`
}

Тут я перечисляю категории поздравлений. Вторая db/models/congrat_text.go:

package models

type CongratText struct {
	Base
	CongratCatsID uint `gorm:"column:id_congrat_cat"`
	CongratCats   CongratCats
	txt           string `gorm:"column:txt;type:text"`
}

Подготовка БД

Прежде чем работать с БД необходимо немного можифицировать код из предыдущей статьи. В файле structs/config.go добавим некоторые свойства структуры:

type Config struct {
	TBotApiToken string
	Env          string

	MigrateDB           bool
	MigrateDBReferences bool
	DbName              string
	DbAddress           string
	DbPort              string
	DbLogin             string
	DbPassword          string
}

И теперь нужно сделать получить все необходимые параметры. Для этого подправим libs/config.go:

package libs

import (
	"os"
	"tgbot-newyear/structs"
)

var Config structs.Config

func LoadConfig() {
	var exists bool
	Config.TBotApiToken = os.Getenv("TBOT_API_TOKEN")

	if Config.Env, exists = os.LookupEnv("ENV"); !exists {
		Config.Env = "development"
	}

	if Config.DbName, exists = os.LookupEnv("DB_NAME"); !exists {
		Config.DbName = "bot"
	}

	if Config.DbAddress, exists = os.LookupEnv("DB_ADDRESS"); !exists {
		Config.DbAddress = "bot"
	}

	if Config.DbLogin, exists = os.LookupEnv("DB_LOGIN"); !exists {
		Config.DbLogin = "bot"
	}

	if Config.DbPassword, exists = os.LookupEnv("DB_PASSWORD"); !exists {
		Config.DbPassword = "bot"
	}

	if Config.DbPort, exists = os.LookupEnv("DB_PORT"); !exists {
		Config.DbPort = "3306"
	}

	prepareArguments()
}

func prepareArguments() {
	args := os.Args[1:]
	for i := range args {
		switch args[i] {
		case "migrate":
			Config.MigrateDB = true
		}
	}
}

Так же добавим вспомогательную функцию в файл libs/end_transaction.go:

package libs

import "gorm.io/gorm"

func EndTransaction(tx *gorm.DB, err error) (errout error) {
	if err != nil {
		// Откат транзакции, так как получилось неудачно
		errout = tx.Rollback().Error
	} else {
		// Ошабок нет, значит все хорошо. Подтверждаем транзакцию
		tx.Commit()
		errout = nil
	}
	return
}

И добавим в launch.json переменные окружения:

{
  "name": "Launch Bot",
  "type": "go",
  "request": "launch",
  "mode": "debug",
  "program": "${workspaceFolder}/main.go",
  "env": {
    "TBOT_API_TOKEN": "Ваш токен",
    "DB_ADDRESS": "localhost",
    "DB_NAME": "bot",
    "DB_LOGIN": "bot",
    "DB_PASSWORD": "bot"
  }
}

Далее нам нужно написать немного кода для подключения в базе. Наполняем файл db/db.go:

package db

import (
	"embed"
	"log"
	"os"
	"time"

	"tgbot-newyear/db/models"
	"tgbot-newyear/libs"

	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

//go:embed cats.csv.gz
//go:embed congrats.csv.gz
var f embed.FS

var DB *gorm.DB

func Connect() {
	dsnMySQL := libs.Config.DbLogin + ":" + libs.Config.DbPassword + "@tcp(" + libs.Config.DbAddress + ":" + libs.Config.DbPort + ")/" + libs.Config.DbName + "?charset=utf8mb4&parseTime=True&loc=Local"

	var logLevel logger.LogLevel
	if libs.Config.Env == "production" {
		logLevel = logger.Silent
	} else {
		logLevel = logger.Info
	}

	var err error
	newLogger := logger.New(
		log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
		logger.Config{
			SlowThreshold: time.Second, // Slow SQL threshold
			LogLevel:      logLevel,    // Log level
			Colorful:      false,       // Disable color
		},
	)
	newLogger.LogMode(logger.Info)
	DB, err = gorm.Open(mysql.Open(dsnMySQL), &gorm.Config{
		Logger:                                   newLogger,
		DisableForeignKeyConstraintWhenMigrating: true,
	})

	if err != nil {
		panic(err)
	}

	// Установим пул соединений
	dbSettings, err := DB.DB()
	if err != nil {
		panic(err)
	}
	dbSettings.SetMaxIdleConns(10)
	dbSettings.SetMaxOpenConns(50)
	dbSettings.SetConnMaxLifetime(time.Minute * 10)

	if libs.Config.MigrateDB {

		// Создание БД

		DB.AutoMigrate(
			&models.CongratCats{},
			&models.CongratText{},
		)

		if libs.Config.MigrateDBReferences {
			migrateCats()
			migrateCongrats()
		}
	}
}

func migrateCats() {
	// TODO
}

func migrateCongrats() {
	// TODO
}

Здесь я настраиваю подключение к базе. Если будет передан параметр migrate, то будет создана структура базы либо ее обновление (если она уже есть). В промышленной среде это называется процесс «миграции БД». Так как у нас всего 2 таблицы, то не смысла заморачиваться с чем-то сложным. По этому в данном случае я использую простой вариант.

Теперь, чтобы все работало правильно нужно немного изменить main.go:

func main() {
	libs.LoadConfig()
	db.Connect()
	if !libs.Config.MigrateDB {
		libs.LoadConfig()
		srv.TGBot()
	}
}

Обновление справочников

Помимо создания структуры БД еще необходимо наполнить таблицы данными, из которых будем брать данные. В файле db/db.go я подготовил 2е функции: migrateCats и migrateCongrats. Вот их и будем использовать. И так, для начала migrateCats:

func migrateCats() {
	var catsFile fs.File
	var err error

	catsFile, err = f.Open("cats.csv.gz")
	if err != nil {
		panic(err)
	}

	defer catsFile.Close()

	var gz *gzip.Reader
	gz, err = gzip.NewReader(catsFile)
	if err != nil {
		panic(err)
	}

	defer gz.Close()

	reader := csv.NewReader(gz)
	reader.Comma = ';'

	var record []string
	z := 0
	fmt.Println("Update categories")

	tx := DB.Begin()

	defer func() {
		libs.EndTransaction(tx, err)
	}()

	for {
		record, err = reader.Read()
		if err != nil {
			break
		}

		var cat models.CongratCats
		if res := tx.First(&cat, "name = ?", record[0]); res.RowsAffected == 0 {
			// Создаем
			cat.Name = record[0]
			cat.Display = record[1]
			if res := tx.Create(&cat); res.RowsAffected == 0 {
				panic(res.Error)
			}
		} else {
			// Обновляем
			cat.Display = record[1]
			if res := tx.Save(&cat); res.RowsAffected == 0 {
				panic(res.Error.Error())
			}
		}
	}

	fmt.Printf("Finished %d records\n", z)

	err = nil

}

И migrateCongrats:

func migrateCongrats() {
	var catsFile fs.File
	var err error

	catsFile, err = f.Open("congrats.csv.gz")
	if err != nil {
		panic(err)
	}

	defer catsFile.Close()

	var gz *gzip.Reader
	gz, err = gzip.NewReader(catsFile)
	if err != nil {
		panic(err)
	}

	defer gz.Close()

	reader := csv.NewReader(gz)
	reader.Comma = ';'

	var record []string
	fmt.Println("Update texts")

	tx := DB.Begin()

	defer func() {
		libs.EndTransaction(tx, err)
	}()

	// Очистим все поздравления. Нам они не нужны
	tx.Delete(&models.CongratText{}, "1 = 1")

	for {
		record, err = reader.Read()
		if err != nil {
			break
		}

		var cat models.CongratCats
		if res := tx.First(&cat, "name = ?", record[0]); res.RowsAffected == 0 {
			continue
		}

		// Добавим поздравление

		var text models.CongratText
		text.CongratCatsID = cat.ID
		text.Txt = record[1]

		if res := tx.Create(&text); res.RowsAffected == 0 {
			panic(res.Error)
		}

	}

	err = nil

}

Я не стал вводить проверку существующего сообщения в таблице, так как записей не много и выполняется быстро. В академических целях этого достаточно. В реальном же приложении нужно предусмотреть именно добавление и обновление записей, так как это может быть справочная информация и при удалении и новой вставке связи могут быть смещены и потеряны. Так что подбирайте методы в соответствии с требованиями.

Поздравления

Вот теперь мы подошли к реализации результата. В файле srv/handlers/index.go пишем следующее:

package handlers

import (
	"fmt"
	"math/rand"
	"tgbot-newyear/db"
	"tgbot-newyear/db/models"
	"tgbot-newyear/libs"
	"tgbot-newyear/tglibs"

	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
)

func Handlers(event *tgbotapi.Update) (msg *tgbotapi.MessageConfig, err error) {

	if event.CallbackQuery != nil {

		tx := db.DB.Begin()
		defer func() {
			libs.EndTransaction(tx, err)
		}()

		var cats models.CongratCats
		if res := tx.Preload("CongratText").First(&cats, "name = ?", event.CallbackQuery.Data); res.RowsAffected == 0 {
			tmp := tgbotapi.NewMessage(tglibs.GetChatID(event), fmt.Sprintf("Что вы имели ввиду?"))
			msg = &tmp
			err = res.Error
			return
		}

		if len(cats.CongratText) == 0 {
			tmp := tgbotapi.NewMessage(tglibs.GetChatID(event), fmt.Sprintf("Извините, но я не знаю что Вам сказать..."))
			msg = &tmp
			return
		}

		num := rand.Int31n(int32(len(cats.CongratText)))

		tmp := tgbotapi.NewMessage(tglibs.GetChatID(event), cats.CongratText[num].Txt)
		tglibs.TGSendMessage(tmp)
	}

	return

}

И немного изменим srv/tgbot.go функцию processingMessage:

func processingMessage(update *tgbotapi.Update) {

	var err error
	var message *tgbotapi.MessageConfig

	chatID := tglibs.GetChatID(update)

	message, err = handlers.Handlers(update)

	if err != nil {
		tmp := tgbotapi.NewMessage(chatID, err.Error())
		tglibs.TGSendMessage(tmp)
	} else if message != nil {
		tglibs.TGSendMessage(*message)
	} else {

		tx := db.DB.Begin()
		defer func() {
			libs.EndTransaction(tx, err)
		}()

		var cats []models.CongratCats
		if res := tx.Find(&cats); res.RowsAffected == 0 {
			tmp := tgbotapi.NewMessage(chatID, "Ой! Что-то случилось...")
			tglibs.TGSendMessage(tmp)
		} else {

			tmp := tgbotapi.NewMessage(chatID, "Выберите действие")

			var buttons [][]tgbotapi.InlineKeyboardButton
			for i := range cats {
				b := tgbotapi.NewInlineKeyboardButtonData(cats[i].Display, cats[i].Name)
				row := tgbotapi.NewInlineKeyboardRow(b)
				buttons = append(buttons, row)
				if len(buttons) == 100 {
					var kb tgbotapi.InlineKeyboardMarkup
					kb.InlineKeyboard = buttons
					message.ReplyMarkup = kb
					tglibs.TGSendMessage(tmp)
					tmp = tgbotapi.NewMessage(chatID, "Продолжение")
					buttons = [][]tgbotapi.InlineKeyboardButton{}
				}
			}

			var kb tgbotapi.InlineKeyboardMarkup
			kb.InlineKeyboard = buttons

			tmp.ReplyMarkup = kb
			tglibs.TGSendMessage(tmp)
		}
	}
}

Теперь можно запускать.

В заключении

Бот готов и им можно пользоваться. Мой результат получился вот таким.

С чего начать

Для начала нам нужен действующий Телеграм-клиент. Через него нужно зарегистрировать бота. Для этого нужно воспользоваться ботом. Звучит странно, но так оно и есть. Для этого идем по адресу https://core.telegram.org/bots и читаем инструкцию. Нам нужен BotFather. Как зарегистрировать бота я рассказывать не буду, так как только ленивый не писал как это сделать. А на официальном сайте прекрасно все написано. После регистрации мы должны получить токен. Он и будет нашей авторизацией для бота.

Теперь нам нужно немного немного настроить наш проект. Я буду передавать параметры через переменные окружения, по этому, чтобы каждый раз не писать вручную я настраиваю немного проект разработки. В моем случае это Visual Studio Code. Вы же можете использовать свой любимы инструмент. Как настраивать саму IDE рассказывать не буду, а только то, что касается проекта. Создаем файл launch.json (в разделе «Запуск и отладка») и немного наполняем его:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Launch Bot",
            "type": "go",
            "request": "launch",
            "mode": "debug",
            "program": "${workspaceFolder}/main.go",
            "env": {
                "TBOT_API_TOKEN": "Ваш токен"
            }
        }
    ]
}

Данная конфигурация говорит о том, что запускать отладку файла main.go и передавать некоторые переменные окружения.

Теперь нужно создать настройки для самого компилятора/сборщика и т.д. В консоле с проектом вводим:

go mod init tgbot-newyear

После нам понадобится пакет для работы с Telegram:

go get github.com/go-telegram-bot-api/telegram-bot-api

Проект готово. Можно приступать к написанию кода.

Код

Для начала создадим файл libs/config.go:

package libs

import (
	"os"
	"tgbot-newyear/structs"
)

var Config structs.Config

func LoadConfig() {
	var exists bool
	Config.TBotApiToken = os.Getenv("TBOT_API_TOKEN")

	if Config.Env, exists = os.LookupEnv("ENV"); !exists {
		Config.Env = "development"
	}

	prepareArguments()
}

func prepareArguments() {
	// TODO
}

Этот код получает переменные окружения и параметры командной строки и складывает их в определенную структуру. В дальнейщем будем ее дописывать.

И structs/config.go:

package structs

type Config struct {
	TBotApiToken string
	Env          string
}

Это структура для хранения настроек, чтобы можно было дергать параметры там где они нам нужны.

Теперь создадим файл srv/tgbot.go:

package srv

import (
	"log"
	"tgbot-newyear/libs"
	"tgbot-newyear/srv/handlers"
	"tgbot-newyear/tglibs"
	"tgbot-newyear/tgstructs"

	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
)

var Bot *tgbotapi.BotAPI

func TGBot() {

	var err error
	Bot, err = tgbotapi.NewBotAPI(libs.Config.TBotApiToken)
	if err != nil {
		log.Panic(err)
	}

	if libs.Config.Env == "production" {
		Bot.Debug = false
	} else {
		Bot.Debug = true
	}

	log.Printf("Authorized on account %s", Bot.Self.UserName)

	u := tgbotapi.NewUpdate(0)
	u.Timeout = 60

	updates, err := Bot.GetUpdatesChan(u)

	if err != nil {
		panic(err)
	}

	tglibs.SetBotContext(Bot)
	tglibs.Msgs = make(chan *tgstructs.Message)
	go tglibs.TGSendChannel(tglibs.Msgs)

	for update := range updates {

		processingMessage(&update)

	}
}

func processingMessage(update *tgbotapi.Update) {

	var err error
	var message *tgbotapi.MessageConfig

	chatID := tglibs.GetChatID(update)

	message, err = handlers.Handlers(update)

	if err != nil {
		tglibs.TGSendMessage(*message)
	} else {
		tmp := tgbotapi.NewMessage(chatID, "Выберите действие")
		tglibs.TGSendMessage(tmp)
	}

}

Здесь мы создаем экземпляр бота и запускаем его. В функции TGBot я устанавливаю все настройки и запускаю цикл обработки. В данном случае поступающие сообщения приходят из канала. Если канал пуст, то цикл будет заморожен, пока не поступит новое сообщение.

После создаем файлы srv/handlers/index.go:

package handlers

import (
	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
)

func Handlers(event *tgbotapi.Update) (msg *tgbotapi.MessageConfig, err error) {

	return

}

Это файл-заглушка, в которой пока ничего не происходит. Здесь я буду наполнять бота реакцией чтобы более логически разделить основную часть бота от обработчиков.

tgstructs/message.go:

package tgstructs

import (
	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
)

type Message struct {
	Message *tgbotapi.MessageConfig
}

Это просто структура сообщения. В данном случае в структуру сообщения будет помещаться сообщение. Таким образом можно добавить другие типы и отправлять их пользователю. Мне понадобятся только текст, но можно отправлять файлы, картинки, видео, заметки, фото и т.д. Таким образом структуру можно расширить.

tglibs/get_chat_id.go:

package tglibs

import tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"

func GetChatID(event *tgbotapi.Update) int64 {
	if event.Message != nil {
		return event.Message.Chat.ID
	} else if event.CallbackQuery != nil {
		return event.CallbackQuery.Message.Chat.ID
	}
	return 0
}

Это просто вспомогательная функция для получения ID чата. Он нам понадобится, чтобы мы знали кому отправить сообщение.

tglibs/tgsend.go:

package tglibs

import (
	"reflect"
	"tgbot-newyear/tgstructs"
	"time"

	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
)

var bot *tgbotapi.BotAPI

var Msgs chan *tgstructs.Message

var deferredMessages = make(map[int64]chan *tgstructs.Message)
var lastMessageTimes = make(map[int64]int64)

func SetBotContext(context *tgbotapi.BotAPI) {
	bot = context
}

func TGSendMessage(msg tgbotapi.MessageConfig) {
	var message tgstructs.Message
	message.Message = &msg
	if _, ok := deferredMessages[msg.ChatID]; !ok {
		deferredMessages[msg.ChatID] = make(chan *tgstructs.Message, 1000)
	}
	deferredMessages[msg.ChatID]  0 {
				// Формирование case
				cs := reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(ch)}
				cases = append(cases, cs)
			}
		}

		if len(cases) > 0 {
			// Достаем одно сообщение из всех каналов
			_, value, ok := reflect.Select(cases)

			if ok {
				msg := value.Interface().(*tgstructs.Message)
				// Выполняем запрос к API
				if msg == nil {
					continue
				}
				if msg.Message != nil {
					if msg.Message.ChatID == 0 {
						continue
					}
					if msg.Message != nil {
						if _, err := bot.Send(msg.Message); err != nil {
							continue
						}
						lastMessageTimes[msg.Message.ChatID] = time.Now().UnixNano()
					}
				}
			}
		}
	}
}

func userCanReceiveMessage(userId int64) bool {
	t, ok := lastMessageTimes[userId]

	return !ok || t+int64(time.Second)

Достаточно сложная функция. Здесь мы получаем сообщение и кладем его в очередь. После в отдельном потоке мы эти сообщения читаем из очереди и проверяем время отправки. дело в том что в Telegram есть ограничения на количество отправок сообщений за определенное время. О лимитах можно почитать здесь. Достаточно наглядная таблица.

Вот в таком варианте можно уже запустить приложение, подключиться к боту и написать ему что-то. На все сообщения он будет отвечать одинаково:

И все?

Пока что да. Такое приложение можно разместить на домашнем сервере или на каком-нибудь внешнем. Далее я буду показывать как его немного оживить. А пока что можно с ним немного поиграть.

Скелет

Для начала не плохо было бы понять с чего начать. Я достаточно долго блуждал по интернету в поисках информации. Когда впервые что-то берешь в руки и не знаешь что с этим делом начинаешь искать хоть какую-то вводную статью. Нашел я пару статей, но они не для моей версии (на текущий момент 5.8.2). Хотелось что-то свежее.

В результате поисков я нашел пару интересных и полезные статей. Но мне повезло еще в одном: генератор скелета. Чтобы со всем этим добром не ковыряться ребята выложили форму, в которой можно просто сгенерировать шаблон. Думаю с формой можно разобраться. Там все просто.

Подготовка

Вот мы сгенерировали скелет, скачали, распаковали в wp/wp-content/plugins/classify-comments-wp-plugin (в моем случае). Что дальше? А дальше нужно начинать писать, так как в нем уже все готово.

Для начала открываем основной файл (в моем случае classify-comment.php) и правим заголовок:

/**
 * The plugin bootstrap file
 *
 * This file is read by WordPress to generate the plugin information in the plugin
 * admin area. This file also includes all of the dependencies used by the plugin,
 * registers the activation and deactivation functions, and defines a function
 * that starts the plugin.
 *
 * @since             1.0.0
 * @package           Classify_Comment
 *
 * @wordpress-plugin
 * Plugin Name:       Classify Comment
 * Plugin URI:        https://ymnuktech.ru
 * Description:       Classify comments for toxic messages
 * Version:           1.0.0
 * Author:            Alexandr Fedoryuk
 * Author URI:        https://ymnuktech.ru
 * License:           GPL-2.0+
 * License URI:       http://www.gnu.org/licenses/gpl-2.0.txt
 * Text Domain:       classify-comment
 * Domain Path:       /languages
 */

Эти комментарии нужны чтобы WordPress показал информацию о плагине: кто написал, ссылки, адреса и т.д. Теперь нужно немного подредактировать скелет, так как мне лично не нравится, что я должен дублировать некоторую информацию. Для этого я создал файл includes/class-classify-comment-ext.php и добавил следующее:

class Classify_Comment_Ext
{

    public const table_classify_comments = "classify_comments";

    public const table_classify_comments_option = "classify_comments_option";

    public $address;
    public $cats;

    public function __constructor()
    {
    }

    /**
     * Проверяет переданное сообщение и возвращает его категорию
     * @param string $msg - Сообщение
     * @return string - возвращает категорию
     */
    protected function verifyMessage($msg, $moreInfo = null)
    {
        $this->loadOptions();

        $data = array(
            'text' => $msg
        );
        $payload = json_encode($data);

        $ch = curl_init($this->address . "/api/v1/fisher");

        curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
        curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type:application/json'));
        # Return response instead of printing.
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        # Send request.
        $result = curl_exec($ch);
        curl_close($ch);
        $result = json_decode($result);

        global $wpdb;

        $q = $wpdb->prepare(
            "
        INSERT INTO `" . $wpdb->prefix . Classify_Comment_Ext::table_classify_comments . "`
        (`comment_content`, `cat`, `comment_post_ID`, `comment_author`, `comment_author_email`, `comment_author_url`, `comment_author_IP`, `comment_agent`, `user_ID`)
        VALUES
        (%s, %s, %d, %s, %s, %s, %s, %s, %d)",
            $msg,
            $result->data,
            !is_null($moreInfo) ? $moreInfo['comment_post_ID'] : null,
            !is_null($moreInfo) ? $moreInfo['comment_author'] : null,
            !is_null($moreInfo) ? $moreInfo['comment_author_email'] : null,
            !is_null($moreInfo) ? $moreInfo['comment_author_url'] : null,
            !is_null($moreInfo) ? $moreInfo['comment_author_IP'] : null,
            !is_null($moreInfo) ? $moreInfo['comment_agent'] : null,
            !is_null($moreInfo) ? $moreInfo['user_ID'] : null
        );

        $wpdb->query($q);

        if ($result->result) return $result->data;

        return null;
    }

    /**
     * Проверка по списку блокировки категории
     * @param string Категория для проверки
     * @param boolean Если попадает в указанную категорию в настройках, то возвращает true
     */
    protected function validateCats($msg, $moreInfo = null)
    {
        $cat = $this->verifyMessage($msg, $moreInfo);

        // error_log($cat);

        if (count($this->cats) === 0) return false;

        foreach ($this->cats as $val) {
            if ($val == $cat) return true;
        }

        return false;
    }

    protected function loadOptions()
    {
        global $wpdb;

        $res = $wpdb->get_results("
		SELECT value FROM {$wpdb->prefix}classify_comments_option WHERE name = 'address'");
        $this->address = $res[0]->value;

        $res = $wpdb->get_results("
		SELECT value FROM {$wpdb->prefix}classify_comments_option WHERE name = 'cats'");

        $cats = array();

        if (isset($res) && count($res) > 0 && !is_null($res[0]->value)) {
            $res = explode(",", $res[0]->value);
            if (count($res) > 0) {
                foreach ($res as $val) {
                    $val = trim($val);
                    if (strlen($val) > 0) {
                        array_push($cats, $val);
                    }
                }
            }
        }

        $this->cats = array_unique($cats);
    }
}

После, для классов Classify_Comment_Admin и Classify_Comment_Public я добавил extends Classify_Comment_Ext. Далее чтобы это заработало (иначе упадет в ошибку) в классе includes/class-classify-comment.php в функцию load_dependencies() добавляем строчку:

require_once plugin_dir_path(dirname(__FILE__)) . 'includes/class-classify-comment-ext.php';

На этом подготовка закончена.

Реализация админки

Первым делом можно создать меню для админки. Для этого добавляем функцию admin_generate_menu():

public function admin_generate_menu()
{
	// Добавляем основной раздел меню
	add_menu_page('Добро пожаловать в модуль классификации комментариев', 'Токсичность', 'manage_options', 'options_toxic_comments', array(&$this, 'admin_options'));;
	// Добавляем дополнительный раздел
	add_submenu_page('options_toxic_comments', 'Управление содержимом', 'Проверка', 'manage_options', 'toxic_test', array(&$this, 'admin_comment_test'));
	add_submenu_page('options_toxic_comments', 'Управление содержимом', 'Список сообщений', 'manage_options', 'toxic_list', array(&$this, 'admin_comment_list'));
}

В функции define_admin_hooks() регистрируем наше меню:

$this->loader->add_action('admin_menu', $plugin_admin, 'admin_generate_menu');

Теперь для страниц напишем 3 функции в классе админки:

/**
 * Настройка параметров плагина
 */
public function admin_options()
{
	global $wpdb;

	if ($_SERVER['REQUEST_METHOD'] === 'POST') {
		// Обновляем данные настроек
		$q = $wpdb->prepare("
		INSERT INTO {$wpdb->prefix}classify_comments_option (name, value)
		VALUES ('address' ,%s)
		ON DUPLICATE KEY UPDATE value = %s", $_POST['address'], $_POST['address']);
		$wpdb->query($q);

		$q = $wpdb->prepare("
		INSERT INTO {$wpdb->prefix}classify_comments_option (name, value)
		VALUES ('cats'
		, %s)
		ON DUPLICATE KEY UPDATE value = %s", $_POST['cats'], $_POST['cats']);
		$wpdb->query($q);
	}

	$this->loadOptions();

	$options = array(
		'address' => $this->address,
		'cats' => $this->cats
	);

	require_once('partials/classify-comment-admin-options.php');
}

/**
 * Список проверенных сообщений
 */
public function admin_comment_list()
{
	global $wpdb;

	$res = $wpdb->get_results("SELECT * FROM {$wpdb->prefix}classify_comments ORDER BY date_filtered DESC LIMIT 500");

	require_once('partials/classify-comment-admin-list.php');
}

/**
 * Проверка работы сервиса
 */
public function admin_comment_test()
{

	$result = null;

	if ($_SERVER['REQUEST_METHOD'] === 'POST') {
		$result = $this->verifyMessage($_POST['message']);
	}

	require_once('partials/classify-comment-admin-test.php');
}

В директории partials размещаем наши файлы представления для отображения информации. classify-comment-admin-list.php:

    # Список обработанных комментариев

            Автор
            E-Mail
            URL
            IP
            Комментарий
            Агент
            Категория
            Дата фильтрации

                comment_author; ?>
                comment_author_email; ?>
                comment_author_url; ?>
                comment_author_IP; ?>
                comment_content; ?>
                comment_agent; ?>
                cat; ?>
                date_filtered; ?>

    Всего показано строк:

classify-comment-admin-options.php:

    # Настройки Токсичности

            Адрес обработчика
            ">

            Категории для блокировки (через запятую)
            ">

classify-comment-admin-test.php:

        Введите сообщение для проверки
        ">

            Результат:

С админкой закончили.

Основной функционал

Теперь не плохо было бы реализовать саму фильтрацию. В классе Classify_Comment_Public добавим функцию:

/**
 * Проверяем комментарий на токсичность. Если это будет группа из списка настроек, то вернем результат 'spam' чтобы заблокировать.
 */
public function pre_filter_comment($approved, $commentdata)
{
	if ($approved === 'spam') return $approved;

	if ($this->validateCats($commentdata['comment_content'], $commentdata) === true) return 'spam';

	return $approved;
}

А в функцию define_public_hooks() добавим хук:

$this->loader->add_filter('pre_comment_approved', $plugin_public, 'pre_filter_comment', 10, 2);

Тут все просто, потому как основной функционал уже реализован в классе Classify_Comment_Ext.

Последний штрих

Еще нужно реализовать маленькую функцию удаления плагина. В файле uninstall.php запишем следующее:

if (!defined('WP_UNINSTALL_PLUGIN')) {
	global $wpdb;
	wpdb->query("DROP TABLE IF EXISTS {$wpdb->prefix}classify_comments");
	wpdb->query("DROP TABLE IF EXISTS {$wpdb->prefix}.classify_comments_option");
	exit;
}

Теперь все готово и можно активировать плагин.

Что получилось

В админке должно появиться 3 страницы. Заходим в Токсичность и указываем адрес до сервиса и через запятую перечисляем категории, которые будем блокировать.

В меню проверки можем написать текст и посмотреть как оно работает.

А в списке сообщений можем посмотреть историю.

Исходный код можно взять из гита.

Реализация

В книге написано как реализовать 2 алгоритма: Наивный метод (Байесовский) и метод Фишера. Что это за алгоритмы и как они работают прекрасно все расписано. Так же в ней написана реализация на Python, но… Мне захотелось попробовать сделать на другом языке программирования и выбрал я Golang.

Сам алгоритм и классы практически переписываются один в один (строчка в строку). Тут ничего сверхординарного нет. Все работает.

type Classifier struct {
	Words       map[string]*Word   `json:"words"`
	Cats        map[string]int     `json:"cats"`
	Thresholds  map[string]float32 `json:"thresholds"`
	Minimums    map[string]float32 `json:"minimums"`
	getFeatures func(str string) (result []string, err error)
}

func NewClassifier(f func(str string) (result []string, err error)) *Classifier {
	classifier := Classifier{}
	classifier.initclassifier(f)
	return &classifier
}

func (classifier *Classifier) initclassifier(f func(str string) (result []string, err error)) {
	classifier.getFeatures = f
	classifier.Cats = make(map[string]int)
	classifier.Words = make(map[string]*Word)
	classifier.Thresholds = make(map[string]float32)
	classifier.Minimums = make(map[string]float32)
}

func (classifier *Classifier) SetThreshold(cat string, t float32) {
	classifier.Thresholds[cat] = t
}

func (classifier *Classifier) GetThreshold(cat string) float32 {
	if _, ok := classifier.Thresholds[cat]; !ok {
		return 1.0
	}
	return classifier.Thresholds[cat]
}

// Тренировка
func (classifier *Classifier) Train(str string, cat string) {

	if len(cat) > 0 {

		words, err := classifier.getFeatures(str)
		if err != nil {
			log.Println(err)
			return
		}

		if len(words) > 0 {
			for _, word := range words {
				classifier.incf(word, cat)
			}
			classifier.incc(cat)
		}

	}

}

// Сколько образцов отнесено к данной категории
func (classifier *Classifier) catcount(cat string) int {
	if _, ok := classifier.Cats[cat]; !ok {
		return 0
	}
	return classifier.Cats[cat]
}

// Общее число образцов
/*func (classifier *Classifier) totalcount() int {
	sum := 0
	if len(classifier.Cats) > 0 {
		for _, val := range classifier.Cats {
			sum += val
		}
	}
	return sum
}*/

// Список всех категорий
func (classifier *Classifier) Categories() []string {
	res := make([]string, 0, len(classifier.Cats))
	for k := range classifier.Cats {
		res = append(res, k)
	}
	return res
}

// Увеличить счетчик применений категории
func (classifier *Classifier) incc(cat string) {
	if _, ok := classifier.Cats[cat]; ok {
		classifier.Cats[cat]++
	} else {
		classifier.Cats[cat] = 1
	}
}

// Увеличить счетчик пар признак/категория
func (classifier *Classifier) incf(word string, cat string) {
	if _, ok := classifier.Words[word]; !ok {
		classifier.Words[word] = &Word{}
	}
	classifier.Words[word].IncCat(cat)
}

// Сколько раз признак появлялся в данной категории
func (classifier *Classifier) fcount(word string, cat string) int {
	if _, ok := classifier.Words[word]; ok {
		if _, ok := classifier.Words[word].Categories[cat]; ok {
			return classifier.Words[word].Categories[cat]
		}
	}
	return 0
}

// Условная вероятность
func (classifier *Classifier) fprob(word string, cat string) float32 {
	//if len(docclass.cats) == 0 {
	if classifier.catcount(cat) == 0 {
		return 0.0

	}
	tmp := float32(classifier.fcount(word, cat)) / float32(classifier.catcount(cat))
	return tmp
}

func (classifier *Classifier) Sampletrain() {
	classifier.Train("Клара у Карла украла караллы.", "good")
	classifier.Train("Шла Саша по шоссе и сосала сушку.", "good")
	classifier.Train("Я вычислю тебя по IP!", "bad")
	classifier.Train("Вычислю тебя", "bad")
}

type WeighteProbeStruct struct {
	Word   string
	Cat    string
	Prf    func(word string, cat string) float32
	Weight float32
	Ap     float32
}

// Взвешенная вероятность
func (classifier *Classifier) weighteprobe(weighteProbeArgs WeighteProbeStruct) float32 {
	if weighteProbeArgs.Weight == 0.0 {
		weighteProbeArgs.Weight = 1.0
	}
	if weighteProbeArgs.Ap == 0 {
		weighteProbeArgs.Ap = 0.5
	}

	basicprob := weighteProbeArgs.Prf(weighteProbeArgs.Word, weighteProbeArgs.Cat)

	totals := 0

	for _, categ := range classifier.Categories() {
		totals += classifier.fcount(weighteProbeArgs.Word, categ)
	}

	bp := ((weighteProbeArgs.Weight * weighteProbeArgs.Ap) + (float32(totals) * basicprob)) / (weighteProbeArgs.Weight + float32(totals))
	return bp
}

func (classifier *Classifier) SetMininun(cat string, val float32) {
	classifier.Minimums[cat] = val
}

func (classifier *Classifier) GetMininun(cat string) float32 {
	val, ok := classifier.Minimums[cat]
	if ok {
		return val
	}

	return 0.0
}

func (classifier *Classifier) Save() (res string, err error) {
	var bytes []byte
	bytes, err = json.Marshal(classifier)
	if err != nil {
		return
	}
	res = string(bytes)
	return
}

func (classifier *Classifier) Load(data string) (err error) {
	err = json.Unmarshal([]byte(data), classifier)
	if err != nil {
		return
	}
	return
}

// Вероятность того, что образец с указанным признаком принадлежит указанной категории, в предположении, что в каждой категории будет одинаковое число образцов
func (fisher *Classifier) cprob(word string, cat string) float32 {
	clf := fisher.fprob(word, cat)
	if clf == 0 {
		return 0.0
	}
	var freqsum float32
	for _, c := range fisher.Categories() {
		freqsum += fisher.fprob(word, c)
	}
	return clf / freqsum
}

func (fisher *Classifier) fisherprobe(str string, cat string) float32 {
	p := float32(1.0)
	words, err := fisher.getFeatures(str)
	if err != nil {
		log.Println(err)
		return 0.0
	}
	for _, word := range words {
		p *= fisher.weighteprobe(WeighteProbeStruct{
			Word: word,
			Cat:  cat,
			Prf:  fisher.cprob,
		})
	}
	fscore := float32(-2.0 * math.Log(float64(p)))
	return fisher.invchi2(fscore, len(words)*2)
}

func (fisher *Classifier) invchi2(chi float32, df int) float32 {
	m := chi / 2.0
	sum := float32(math.Exp(float64(-1.0 * m)))
	term := sum
	for i := 1; i  fisher.GetMininun(cat) && p > max {
			best = cat
			max = p
		}
	}
	return best
}

func (naivebayes *Classifier) docprobe(str string, cat string) float32 {
	p := float32(1.0)
	words, err := naivebayes.getFeatures(str)
	if err != nil {
		log.Println(err)
		return 0
	}
	for _, word := range words {
		p *= naivebayes.weighteprobe(WeighteProbeStruct{
			Word: word,
			Cat:  cat,
			Prf:  naivebayes.fprob,
		})
	}
	return p
}

func (naivebayes *Classifier) Probe(str string, cat string) float32 {
	catprob := naivebayes.catcount(cat)
	docprobe := naivebayes.docprobe(str, cat)
	return docprobe * float32(catprob)
}

func (naivebayes *Classifier) Classify(str string, def string) string {
	probs := make(map[string]float32)
	max := float32(0.0)
	var best string
	for _, cat := range naivebayes.Categories() {
		probs[cat] = naivebayes.Probe(str, cat)
		if probs[cat] > max {
			max = probs[cat]
			best = cat
		}
	}

	for cat := range probs {
		if cat == best {
			continue
		}
		if probs[cat]*naivebayes.GetThreshold(best) > probs[best] {
			return def
		}
	}
	return best
}

Так же у нас есть структура для групп слов:

type Word struct {
	Categories map[string]int `json:"categories"`
}

func (word *Word) IncCat(cat string) {
	if word.Categories == nil {
		word.Categories = make(map[string]int)
	}
	(*word).Categories[cat]++
}

В книге написано как подготовить входящее сообщение для дальнейшей работы. Алгоритм достаточно прост: разделяем текст на слова с удалением всех знаков препинания и пробелов, составляем массив слов и убираем дублирующие слова, затем прогоняем через цикл и убираем все слова, которые меньше либо равно 2ум символам и больше либо равно 20 символам. Все просто. Но мне не хватило чего-то…

Немного покопавшись в своем сознании я вспомнил, что в Python есть пакет NLTK, который отвечает за обработку естественного языка. В частности в нем есть стеммер. В кратце это такая штука, которая ищет основу слова для заданного слова. К примеру «Саша» может быть записано «Саше», «Сашей», «Сашка», «Сашочек» и т.д. В общем вариантов масса. Так вот вероятность того что одно и тоже слово будет повторять начинает постепенно снижаться. Чтобы обучить нашу модель нуже достаточно большой корпус обучения. Для снижения такого объема и для улучшения качества работы модели можно попробовать применить стеммер.

Библиотека называется SnowBall и написана она на С. Есть и для Go, но хотелось еще что-то. В общем нашел я другую библиотеку и мне она подошла. По факту она так же использует Snowball, только выполнено в виде пакета.

Теперь давайте приведем разбиение текста на слова:

/// Подготовка текста и разбивка на слова
func GetWords(str string, lang string) (result []string, err error) {
	// Подготовим полученный текст
	var stemmer *snowball.Stemmer
	stemmer, err = snowball.New(lang)
	if err != nil {
		return
	}
	var reSplitWords *regexp.Regexp
	switch lang {
	case "ru":
		reSplitWords = regexp.MustCompile(`[^А-Яа-я]+`)
	case "en":
		reSplitWords = regexp.MustCompile(`[^A-Za-z]+`)
	}
	split := reSplitWords.Split(strings.ToLower(str), -1)
	splitted := make(map[string]*string)

	for _, word := range split {
		word = stemmer.Stem(word)
		if len([]rune(word)) > 2 && len([]rune(word))

Использование:

сlassifier := structs.NewClassifier(func(str string) (result []string, err error) {
	return GetWords(str, Config.Lang)
})

Тренировка

Наша задача вызвать функцию Train и передать ей 2 параметра: сообщение и группа, к которой относится сообщение. Вот функция:

// Тренировка данных
func train(classifier *structs.Classifier) {
	// TODO
	f, err := os.Open(libs.Config.TraintSetPath)
	if err != nil {
		panic(err)
	}
	defer f.Close()

	csvReader := csv.NewReader(f)

	for {
		row, err := csvReader.Read()
		if err != nil {
			if err == io.EOF {
				err = nil
			}
			return
		}
		classifier.Train(row[0], row[1])
	}
}

Сохранение и загрузка

Сохранять и загружать подготовленные данные можно по разному. Так можно использовать СУБД, а можно напрямую в файлы. Я решил сохранять в файл в формат JSON. Собственно сохранение:

fo, err := os.Create(fmt.Sprintf("./database/%s.json", libs.Config.Lang))
		if err != nil {
			panic(err)
		}
		defer func() {
			if err := fo.Close(); err != nil {
				panic(err)
			}
		}()

		var j string
		j, err = libs.Config.Classifier.Save()
		if err != nil {
			panic(err)
		}
		fo.WriteString(j)

Загрузка:

if _, err := os.Stat(fmt.Sprintf("./database/%s.json", Config.Lang)); !errors.Is(err, os.ErrNotExist) {
		fi, err := os.Open(fmt.Sprintf("./database/%s.json", Config.Lang))
		if err != nil {
			log.Fatal(err)
		}
		defer func() {
			if err = fi.Close(); err != nil {
				log.Fatal(err)
			}
		}()

		b, err := ioutil.ReadAll(fi)
		if err != nil {
			panic(err)
		}
		err = Config.Classifier.Load(string(b))
		if err != nil {
			panic(err)
		}
	}

Сервис

Для работы с программой как с сервисом сделаем для него HTTP-сервер и привяжем функции. Я буду использовать пакет Echo. Подготавливаем:

e := echo.New()
e.Use(middleware.BodyLimit("1M"))
e.Use(middleware.Logger())
e.Use(middleware.Recover())
e.POST("/api/v1/naivebayes", naivebayes)
e.POST("/api/v1/fisher", fisher)

func naivebayes(c echo.Context) error {
	var err error
	var text struct {
		Text string `json:"text"`
	}
	err = json.NewDecoder(c.Request().Body).Decode(&text)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, structs.Result{
			Result:  false,
			Code:    http.StatusInternalServerError,
			Message: libs.PointerString("Не удалось прочитать запрос"),
		})
	}

	return c.JSON(http.StatusOK, structs.Result{
		Result: true,
		Code:   http.StatusOK,
		Data:   libs.PointerString(libs.Config.Classifier.Classify(text.Text, "unknow")),
	})
}

func fisher(c echo.Context) error {
	var err error
	var text struct {
		Text string `json:"text"`
	}
	err = json.NewDecoder(c.Request().Body).Decode(&text)
	if err != nil {
		return c.JSON(http.StatusInternalServerError, structs.Result{
			Result:  false,
			Code:    http.StatusInternalServerError,
			Message: libs.PointerString("Не удалось прочитать запрос"),
		})
	}

	return c.JSON(http.StatusOK, structs.Result{
		Result: true,
		Code:   http.StatusOK,
		Data:   libs.PointerString(libs.Config.Classifier.FisherClassify(text.Text, "unknow")),
	})
}

И моя функция конфигурации:

type Result struct {
	Result  bool    `json:"result"`
	Code    int     `json:"code"`
	Message *string `json:"message"`
	Data    *string `json:"data"`
}

type Config struct {
	IsTrain       bool
	TraintSetPath string

	Lang string

	IsNaivebayes bool
	IsFisher     bool

	Port int

	Classifier *Classifier
}

func LoadConfig() {
	var exists bool
	Config.Lang = "ru"

	var tmp string

	if tmp, exists = os.LookupEnv("PORT"); exists {
		var err error
		Config.Port, err = strconv.Atoi(tmp)
		if err != nil {
			panic(err)
		}
	} else {
		Config.Port = 3000
	}

	prepareArguments(os.Args[1:])

	Config.Classifier = structs.NewClassifier(func(str string) (result []string, err error) {
		return GetWords(str, Config.Lang)
	})

	if _, err := os.Stat(fmt.Sprintf("./database/%s.json", Config.Lang)); !errors.Is(err, os.ErrNotExist) {
		fi, err := os.Open(fmt.Sprintf("./database/%s.json", Config.Lang))
		if err != nil {
			log.Fatal(err)
		}
		defer func() {
			if err = fi.Close(); err != nil {
				log.Fatal(err)
			}
		}()

		b, err := ioutil.ReadAll(fi)
		if err != nil {
			panic(err)
		}
		err = Config.Classifier.Load(string(b))
		if err != nil {
			panic(err)
		}
	}
}

func prepareArguments(args []string) {
	if len(args) > 0 {
		switch args[0] {
		case "train":
			Config.IsTrain = true
			Config.TraintSetPath = args[1]
			prepareArguments(args[2:])
		case "lang":
			Config.Lang = args[1]
			prepareArguments(args[2:])
		case "--naivebayes":
			Config.IsNaivebayes = true
			prepareArguments(args[1:])
		case "--fisher":
			Config.IsFisher = true
			prepareArguments(args[1:])
		}
	}
}

Собственно все.

Пример работы

Где можно применить

Такой сервис можно разместить у себя на маленьком сервере и использоваться для фильтрации, например, чатов чтобы выявлять оскорбляющих и добавлять блокировки. То что у меня получилось можно посмотреть тут.

Подготовка

Для начала необходимо подготовить площадку. Так как у меня по сути 2 сервера, то я буду разворачивать приложение, так сказать, на сервер приложений. Чтобы удобно было это делать я буду всю структуру устанавливать в контейнерах. Я про это уже писал в общих чертах, а теперь буду использовать.

И так, нам понадобится система контейнеризации. Для этого буду использовать Docker. Как его устанавливать, настраивать, использовать написано предостаточно. Все будет происходить стандартным способом. Идем на сайт, читаем, изучаем, выбираем свой дистрибутив и устанавливаем по инструкции. Так как у меня Armbian на основе Debian, то я выбираю его и просто все делаю по инструкции.

После этого нам понадобится Docker Compose. Есть так же инструкция по его установке. Но не все так просто! У меня он не заработал. Это все потому, что по умолчанию его бинарная версия собрана для систем x86_64, а на одноплатнике arm64. Это совершенно разные архитектуры. Но отчаиваться не будем. Заходим в консоль и устанавливаем из репозиториев:

apt install -y docker-compose

Версия не последней свежести, но рабочая. Нам этого будет достаточно.

Установка

Теперь нужно создать директории, которые будут использоваться. Для этого выполняем:

mkdir -p /mnt/nfs/cloud/cloud
mkdir -p /mnt/nfs/cloud/db
mkdir -p /opt/nextcloud

Так как у меня подключен сетевой диск по nfs, то создаю я директории именно на нем. Третья команда создает директорию в /opt. В ней я буду располагать файлы работы сервисов.

Далее выполняю nano /opt/nextcloud/docker-compose.yml и наполняю его:

version: "2.4"

services:
  db:
    image: mariadb:10.7.1-focal
    command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW --innodb-file-per-table=1 --skip-innodb-read-only-compressed
    restart: always
    environment:
      MARIADB_DATABASE: "имя БД"
      MARIADB_USER: "имя пользователя для БД"
      MARIADB_PASSWORD: "пароль БД"
      MARIADB_RANDOM_ROOT_PASSWORD: 1
    volumes:
      - type: bind
        source: /mnt/nfs/cloud/db
        target: /var/lib/mysql
    mem_limit: 256m
    mem_reservation: 64m

  nextcloud:
    image: nextcloud:22.2.3-fpm-alpine
    restart: always
    volumes:
      - type: bind
        source: /mnt/nfs/cloud/cloud
        target: /var/www/html
    mem_limit: 256m
    mem_reservation: 64m
    links:
      - db
    depends_on:
      - db

  nginx:
    image: nginx:1.20.1-alpine
    restart: always
    volumes:
      - type: bind
        source: /mnt/nfs/cloud/cloud
        target: /var/www/html
      - type: bind
        source: ./nginx.conf
        target: /etc/nginx/nginx.conf
    ports:
      - "8082:80"
    links:
      - nextcloud
    depends_on:
      - nextcloud
    mem_limit: 128m
    mem_reservation: 32m

Этот файл описывает какие образы контейнеров необходимо использовать, как их запускать, как объединять их для взаимодействия по сети и как установить ограничение ресурсов. Все необходимы контейнеры можно найти по адресу hub.docker.com. В данном случае мне нужно 3 контейнера: nextcloud, mariadb и nginx.

Теперь выполняем nano /opt/nextcloud/nginx.conf:

worker_processes auto;
pid /run/nginx.pid;

events {
    worker_connections 1024;
    multi_accept on;
}

http {
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 15;
    types_hash_max_size 2048;
    server_tokens off;

    include /etc/nginx/mime.types;
    default_type text/javascript;

    access_log off;
    error_log /var/log/nginx/error.log;

    gzip on;
    gzip_min_length 100;
    gzip_http_version 1.1;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

    client_max_body_size 8M;

upstream php-handler {
    server nextcloud:9000;
}

server {
    listen 80;
    listen [::]:80;

    add_header Referrer-Policy "no-referrer" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-Download-Options "noopen" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Permitted-Cross-Domain-Policies "none" always;
    add_header X-Robots-Tag "none" always;
    add_header X-XSS-Protection "1; mode=block" always;

    fastcgi_hide_header X-Powered-By;

    root /var/www/html;

    location = /robots.txt {
        allow all;
        log_not_found off;
        access_log off;
    }

    location = /.well-known/carddav {
      return 301 $scheme://$host:$server_port/remote.php/dav;
    }
    location = /.well-known/caldav {
      return 301 $scheme://$host:$server_port/remote.php/dav;
    }

    client_max_body_size 512M;
    fastcgi_buffers 64 4K;

    gzip on;
    gzip_vary on;
    gzip_comp_level 4;
    gzip_min_length 256;
    gzip_proxied expired no-cache no-store private no_last_modified no_etag auth;
    gzip_types application/atom+xml application/javascript application/json application/ld+json application/manifest+json application/rss+xml application/vnd.geo+json application/vnd.ms-fontobject application/x-font-ttf application/x-web-app-manifest+json application/xhtml+xml application/xml font/opentype image/bmp image/svg+xml image/x-icon text/cache-manifest text/css text/plain text/vcard text/vnd.rim.location.xloc text/vtt text/x-component text/x-cross-domain-policy;

    location / {
        rewrite ^ /index.php;
    }

    location ~ ^\/(?:build|tests|config|lib|3rdparty|templates|data)\/ {
        deny all;
    }
    location ~ ^\/(?:\.|autotest|occ|issue|indie|db_|console) {
        deny all;
    }

    location ~ ^\/(?:index|remote|public|cron|core\/ajax\/update|status|ocs\/v[12]|updater\/.+|oc[ms]-provider\/.+|.+\/richdocumentscode\/proxy)\.php(?:$|\/) {
        fastcgi_split_path_info ^(.+?\.php)(\/.*|)$;
        set $path_info $fastcgi_path_info;
        try_files $fastcgi_script_name =404;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $path_info;
        fastcgi_param HTTPS on;
        fastcgi_param modHeadersAvailable true;
        fastcgi_param front_controller_active true;
        fastcgi_pass php-handler;
        fastcgi_intercept_errors on;
        fastcgi_request_buffering off;
        fastcgi_read_timeout 300;
    }

    location ~ ^\/(?:updater|oc[ms]-provider)(?:$|\/) {
        try_files $uri/ =404;
        index index.php;
    }

   gzip_proxied expired no-cache no-store private no_last_modified no_etag auth;
    gzip_types application/atom+xml application/javascript application/json application/ld+json application/manifest+json application/rss+xml application/vnd.geo+json application/vnd.ms-fontobject application/x-font-ttf application/x-web-app-manifest+json application/xhtml+xml application/xml font/opentype image/bmp image/svg+xml image/x-icon text/cache-manifest text/css text/plain text/vcard text/vnd.rim.location.xloc text/vtt text/x-component text/x-cross-domain-policy;

    location / {
        rewrite ^ /index.php;
    }

    location ~ ^\/(?:build|tests|config|lib|3rdparty|templates|data)\/ {
        deny all;
    }
    location ~ ^\/(?:\.|autotest|occ|issue|indie|db_|console) {
        deny all;
    }

    location ~ ^\/(?:index|remote|public|cron|core\/ajax\/update|status|ocs\/v[12]|updater\/.+|oc[ms]-provider\/.+|.+\/richdocumentscode\/proxy)\.php(?:$|\/) {
        fastcgi_split_path_info ^(.+?\.php)(\/.*|)$;
        set $path_info $fastcgi_path_info;
        try_files $fastcgi_script_name =404;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $path_info;
        fastcgi_param HTTPS on;
        fastcgi_param modHeadersAvailable true;
        fastcgi_param front_controller_active true;
        fastcgi_pass php-handler;
        fastcgi_intercept_errors on;
        fastcgi_request_buffering off;
        fastcgi_read_timeout 300;
    }

    location ~ ^\/(?:updater|oc[ms]-provider)(?:$|\/) {
        try_files $uri/ =404;
        index index.php;
    }
}

}

Это конфигурационный файл для nginx.

Дело в том что сам Nextcloud написан на PHP и основной web-сервер, накотором он работает — это Apache. Но так же может работать в связка php-fpm + nginx. Ну мне так хочется и для этого есть определенный ряд причин, который приходит с опытом. А раз есть образ Nextcloud с php-fpm, то почему бы им не воспользоваться?..

Далее переходим в нужную директорию (если еще не перешли) с помощью cd /opt/nextcloud и все это добро запускаем:

docker-compose -f docker-compose.yml up

Теперь наблюдаем и ждем, как загружаются и запускаются контейнеры. На это может потребоваться достаточно времени, так как распаковка образов происходит на SD-карту, а она не особо быстрая.

После того как все загрузиться и запустится открываем у себя на компьютере локально браузер и вводим адрес http://:8082. После все делаем поэтапно: отвечаем на вопросы и наблюдаем за действиями системы. Важно также понимать, что выбираем СУБД MySQL, а адрес сервера указываем db. По факту мы указываем не IP-адрес, а доменное имя. Явно мы его нигде не прописывали, но когда мы перечисляем сервисы в файле, Docker Compose присваивает эти имена адресам и внутри сети Docker все они прекрасно определяются. Так устроена эта контейнеризация.

Как только все будет готово и откроется уже админский аккаунт, браузер закрываем и в консоле на удаленном сервер нажимаем комбинацию Ctrl+C. Ждем пока все контейнеры остановятся.

Демонизация

В таком состоянии облако будет работать пока будет открыта консоль сервера. Но ведь хочется, чтобы он работал постоянно. И эту задачу решить достаточно просто.

Для начала создаем файл командой nano /etc/systemd/system/nextcloud.service и записываем в него следующее:

[Unit]
Description=Nextcloud docker-compose
Requires=docker.service
After=docker.service

[Service]
Restart=always

WorkingDirectory=/opt/nextcloud/

# Compose up
ExecStart=/usr/bin/docker-compose -f docker-compose.yml up

# Compose down, remove containers
ExecStop=/usr/bin/docker-compose -f docker-compose.yml down

[Install]
WantedBy=multi-user.target

Описание сервиса готово. Далее нужно сказать демону демонов (ну так получается), чтобы он обновил свой список демонов:

systemctl daemon-reload

После включаем и запускаем:

systemctl enable nextcloud
systemctl start nextcloud

Посмотреть что демон запущен:

systemctl status nextcloud

Немного ждем и все готово. Можно пользоваться.

Обслуживание системы = хорошая система

В комплекте Nextcloud есть специальный файл, который нужно периодически запускать. Этот файл содержит в себе программный код обслуживания: удаление старых записей, очистка кэша, освобождения места и т.д. Этот файл может работать в 3-х режимах: при каждом запросе на сервер, периодический запрос к этому файлу удаленно, добавление его в планировщик. Я сначала пользовался вторым вариантом, но потом решил перенастроить его именно на локальный планировщик. Суть дела не меняет, но локальный запуск, я считаю, будет более правильным.

Для начала зайдем под паролем администратора в само облако и перейдем в Настройки->Основные параметры. У меня стояло Webcron, так как у меня было настроено так. Теперь я поставил Cron.

После этой манипуляции нужно настроить сам планировщик. Для начала нужно проверить, что все работает правильно. В консоле выполняем:

docker ps

Находим в списке наш запущенный контейнер с сервером. В столбце в моем случае есть строчка nextcloud_nextcloud_1. Такое имя формирует Docker Compose. Если перезапустить службу, то будут созданы новые контейнеры, но Docker Compose присвоит эти же имена. Можно присвоить свои имена. Об этом ищите в документации к Docker и Docker Compose, а меня этот вариант более чем устраивает. По этому имени можно обращаться к запущенному контейнеру. Что нам и нужно.

И Попробуем выполнить:

docker exec -it -u www-data nextcloud_nextcloud_1 php cron.php

Если все прошло успешно, то нужно добавить все это чудо в планировщик. Выполняем crontab -e и добавляем строчку:

5 3 * * * docker exec -u www-data nextcloud_nextcloud_1 php cron.php

Здесь мы говорим планировщику, что запуска задание в 3 часа ночи 5 минут, каждый день.

Закрываем и сохраняем. Готово!

Что получилось?

В админском пользователе можно установить дополнения по вкусу. Я НАСТОЯТЕЛЬНО РЕКОМЕНДУЮ создать обычного пользователя и работать под ним, а админский пользователь останется для настройки и обслуживания.

Ко всему прочему можно «делиться» файлами и папками между облаками назначая различные права доступа. Так же можно зайти на сайт https://scan.nextcloud.com и проверить безопасность, но это можно будет сделать, если у вас есть внешний адрес, доменное имя и облако настроено через него по протоколу HTTPS. А вот об этом я расскажу немного позже. Дело не сложное, но очень полезное.

Результат тестирования

Чистое железо (Bare metal)

В данном разделе нет никакого принципа разделения ресурсов. Все используется по классике: есть компьютер, на него установлена операционная система, далее ставятся какие-то приложение. И на этом все. Каждое приложение выполняет свою задачу, ОС выдает какие-то ресурсы этим приложения. В данном случае требуется «голая» система, на которую уже устанавливается все остальное.

Давайте приведем немного аналогии. Представим себе, что физический компьютер — это большой диван. Если взять несколько таких компьютеров, то это будет несколько диванов.

Виртуализация

Вот тут начинается более интересное движение. Смысл в том, что создается виртуальный компьютер, на который устанавливается полноценная ОС со своим ядром и приложениями. В данном случае на одном физическом компьютере можно создать несколько виртуальных компьютеров и они будут работать совместно. Конечно нужно учитывать количество ресурсов чтобы их хватило, но это дает возможность «нарезать» большое количество ресурсов на несколько меньшее количество. За счет такой схемы можно установить совершенно разные операционные системы на один компьютер и они будут работать параллельно. Это называется Гипервизор.

Стоит отметить поддержку такой виртуализации аппаратным обеспечением. Если «железо» не имеет такой поддержки, то сделать такую установку можно, но работать это будет крайне медленно. Очень многие современные процессоры умеют так делать.

Чтобы понять как это работает давайте посадим людей на этот диван. Люди бывают разные: толстые, худые, высокие, маленькие… В зависимости какой человек имеет комплекцию, столько он займет место на диване. Таким образом виртуальные машины могут иметь разное количество ресурсов в своем распоряжении.

Виртуальная машина на сервере

Контейнеризация

В случае контейнеров все работает немного иначе. Здесь нет никаких гипервизоров, аппаратной поддержки железа или чего-то еще. Все работает прямо в операционной системе. Но эта операционная система должна поддерживать такой вид изоляции. Да, в данном случае это уже изоляция, но она очень удобна в том, что можно нарезать ресурсы более тонко между приложениями и системами, при этом каждое приложение может получить в свое распоряжение свой набор настроект и утилит. Например, хостовая ОС может быть Debian, а внутри контейнера работать CentOS или Alpine.

По сути конейнерные ОС не имеют ядра, а пользуются ядром хостовой ОС. По этому контейнеры являются практически такими же ОС, что и главная, на которую это все устанавливается. Для такого типа разделения ресурсов не обязательно иметь аппаратную поддержку виртуализации. Все и так работает.

Попробуем представить как это выглядит. У нас есть все тот же диван, на котором сидят разные люди. Контейнер будем представлять в виде коробки, в которой что-то есть. Эти коробки бывают разного размера. Если дать эти коробки людям, то кто-то может взять их больше, а кто-то меньше. Но есть один момент — коробки можно поставить прямо на диван. В таком случае контейнеры будут работать прямо на голом железе. И так делать можно! Все зависит от задачи.

Пример запущенных контейнеров

Изоляция

С точки зрения использования практически ничем не отличается от Контейнеризации, но все же определленные отличия имеются. Так изолированные приложения работают на той же ОС, что и хост. Так если хостовоая ОС является Ubuntu, то и приложение будет работать на Ubuntu. Просто приложение, как бы, «изолируется» от других и взаимодействие с «внешним миром» устанавливается какими-то правилами.

Чтобы представить как это работает, то представим себе пакетик, а в него мы положим что-то. Это и будет изоляция. Соответственно можно положить на диван, а можно раздать людям. Можно положить и в коробку, но такое редко практикуется.

А для чего все это нужно?

Очень резонный вопрос. Суть в том, что бывают задачи, которые нужно изолировать друг от друга. Например, у Вас есть блог, сайт, интернет-магазин или вы просто хотите попробовать другую ОС. Может даже провести какие-то эксперименты, которые потом не нужны и их можно удалить. Бывают программы, которые требуют определенного рабочего окружения и оно не совместимо с текущим или другими программами. Может Вам нужно просто изолировать свои сервисы друг от друга. Например, вы строите домашний сервер и хотели бы сервисы изолировать друг от друга чтобы ими было удобно управлять. На самом деле причин может быть очень много, так что в данной теме есть из чего выбрать.

Послесловие

Я хотел объяснить достаточно сложную тему простыми словами на сколько это возможно. На самом деле эта тема очень сложная, так как есть очень много подводных камней. Надеюсь я смог дать понять основной смысл всего этого «безобразия»…

Подготовка

Прикупил я второй жесткий диск размером 2.5 дюйма для сервера и подключил его уже обычным переходником USB->SATA. Как его подключить можно почитать «Домашний сервер (операционная система)«. Сажу только подключен он у меня по пути /mnt/backup. Для резервного копирования буду использовать программу BorgBackup. На самом деле это форк программы Attic. Собственно мне лично эта система понравилась своей простотой и достаточной эффективностью.

Для начала установим ее:

apt install -y borgbackup

Теперь нужно создать репозиторий для хранения данных:

borg init -e none /mnt/backup/server

Здесь я создаю новый репозиторий без шифрования. На самом деле в промышленной эксплуатации этого делать не стоит, так как данные могу слить, но у меня домашний сервер и изолирован от внешнего мира, по этому я не стал заморачиватся. Для более подробной информации стоит почитать документацию и статью на хабре, где об этом прекрасно написано.

Теперь нужно создать скрипт для выполнения копирования. Создаем его и заполняем его следующим содержимым:

#!/bin/bash
/usr/bin/borg create --stats /mnt/backup/server/cloud::"cloud--{now:%Y-%m-%d_%H:%M:%S}" /mnt/storage
/usr/bin/borg prune --keep-last=4 /mnt/backup/server

Первая строка создает новую резервную копию, а вторая очищает все предыдущие копии и оставляет только последние 4 штуки. Это нужно чтобы резервные копии перерабатывались и не забивали хранилище. Если же требуется настроить другое поведение, то это можно почитать в документации. Там много интересных функций.

Далее нужно сделать скрипт исполняемым:

chmod +x backup.sh

И добавить это в планировщик. Планировщик редактируется так:

crontab -e

И добавляется следующая строка:

30 0 * * 6

Как пользоваться планировщиком написано здесь.

Восстановление

Чтобы восстановить файлы из резервной копии я делаю монтирование нужной мне копии в директорию по просто пользуюсь копированием. Например:

borgfs ::

И это всё?

Да, это всё. Данный этап можно считать законченным, так как теперь по расписанию планировщика будет выполняться задание, которое и будет выполнять резервное копирование наших файлов. Так как BorgBackup сжимает данные да еще имеет функцию дедубликации. Эффективность хранения архивных копий прям возрастает.

Диск для всех

И так, для начала необходимо установить некоторые программы. Что ж, сделаем:

apt install -y samba

Этого достаточно чтобы установить сервер, но не достаточно чтобы он заработал. Теперь нужно настроить программу, чтобы она отдавала нам файлы по сети. Для этого выполняем nano /etc/samba/smb.conf и приводим конфигурационный файл примерно к следующему виду:

[global]
   workgroup = MYNAS
   dns proxy = no

   log file = /var/log/samba/log.%m

   max log size = 1000

   syslog = 0

   panic action = /usr/share/samba/panic-action %d

   server role = standalone server

   passdb backend = tdbsam

   obey pam restrictions = yes

   unix password sync = yes

   passwd program = /usr/bin/passwd %u
   passwd chat = *Enter\snew\s*\spassword:* %n\n *Retype\snew\s*\spassword:* %n\n *password\supdated\ssuccessfully* .

   pam password change = yes

/bin/false %u

   usershare allow guests = yes

   ntlm auth = yes

[storage]
   comment = Share NAS
   browsable = yes
   path = /mnt/storage
   guest ok = yes
   read only = no
   create mask = 0777
   directory mask = 0777
   writeable = yes
   valid users = user
   locking = no
   oplocks = yes
   strict locking = no
   share modes = yes

Здесь я привожу свой пример без комментариев. Данный пример не является истинно верным и не претендует на уникальность. Все что Вам нужно изменить и донастроить Вы можете это сделать. А мы идем дальше…

Теперь нам нужен пользователь, с помощью которого мы буем подключаться к сетевому диску. Для этого создаем его в Samba:

smbpasswd -a user

Перед применением всего этого добра сервер, вероятнее всего, будет ругаться на количество открываемых файлов. Это связано в ограничении. Добавим пару срочек в /etc/security/limits.conf:

*               hard    nofile          1048576
*               soft    nofile          1048576

Теперь проверим все ли хорошо:

testparm

И, если все хорошо, перезапустим службу:

systemctl stop smbd && systemctl restart nmbd && systemctl start smbd
systemctl enable smbd && systemctl enable nmbd

Теперь можно подключаться с Windows-компьютера указав адрес \\storage и ввести логин и пароль пользователя, которого Вы указали.

Клиент на Linux

Тут ничего сложного нет. Для этого создаем директорию:

mkdir -p /mnt/storage

Установим необходимые пакеты:

apt install -y cifs-utils

И в /etc/fstab добавим одну строчку:

///storage /mnt/storage    cifs    credentials=/etc/home_store.cred,file_mode=0777,dir_mode=0777,rw        0 0

Затем создаем файл /etc/home_store.cred:

username=
password=

И устанавливаем права доступа:

sudo chmod 600 /etc/home_store.cred

Теперь все монтируем:

sudo mount -a

В принципе все.

Еще один сетевой диск

Теперь нам необходимо настроить NFS. Это самая родная сетевая файловая система для Linux. Так как у меня есть второй одноплатник и я на него собираюсь ставить различные приложения, то мне нужно где-то хранить данные. Буду их хранить на сервере с файлами. Можно было бы использовать ту же Samba, но есть некоторые проблемы и ограничения которые отчасти сложно обходить, да и зачем мучиться, если можно сделать все гораздо проще. Продолжим…

Для начала установим все необходимые пакеты на сервер хранилища и сразу его запустим:

apt install -y nfs-common nfs-kernel-server
systemctl start nfs-server && systemctl enable nfs-server

Так как у меня уже есть расшаренная сетевая директория для Samba и я не хочу придумывать другую, то буду использовать ее же. Далее нужно сказать NFS-серверу что мы хотим отдать другим. Для этого редактируем файл /etc/exports (я просто добавил строчку):

/mnt/storage    (rw,no_root_squash)

И просто перезапускаем сервер:

systemctl restart nfs-server

Клиент другого сетевого диска

На будущем сервер устанавливаем пакет клиента:

apt install -н nfs-common

в /etc/fstab добавляем строчку:

:/mnt/storage/     /mnt/nfs/       nfs     rw      0 1

Создаем директорию, к которой будем подключаться:

mkdir -p /mnt/nfs

И монтируем:

mount -a

Как бы всё!

Собственно на этом все. Основа готова. Теперь уже можно что-то дальше наворачивать, так как есть и сервер для хранения данных и сервер для обработки каких-либо данных. Да, это не самолет с реактивным двигателем, но какие-то домашние задачи вполне можно решать.

Данный пост я хочу посвятить рассуждению что это такое и зачем оно нужно. Мне достаточно часто приходилось сталкиваться с отсутствием резервных копий файлов, которые так нужны и исчезают в самый неподходящий момент. Может хоть немного люди будут задумываться о резервном копировании…

Что это такое?

И так, что такое резервное копирование? На этот вопрос отвечали уже очень много раз на разных ресурсах интернета, в поисковике находится по щелчку пальцев, но люди часто этим пренебрегают, а уж техническим специалистам должно быть позор такого не знать! Попробуем это в очередной раз исправить.

Резервное копирование — это процесс копирования важных и необходимых данных в совершенно другое место с целью защитить их от утере и/или порчи. Больше по определению добавить нечего…

Как происходит процесс?

В этом процессе ничего нового не происходит. По сути выполняется копирование данных вручную либо автоматически. Мы просто копируем данные в какое-то хранилище. Это может быть другая директория, диск или что-то более специализированное, т.е. на другой носитель.

Как это можно делать?

На сегодняшний день способов существует очень много и каждый может выбрать то, что подходит по его конкретные задачи. Можно сделать что-то свое маленькое, а можно стрелять «из пушки по воробьям» используя целые комплексы.

Ручное копирование

В этом способе нет ничего сложного. Просто выделяем файлы и директории и копируем в нужное нам место. Ничего интересного.

Автоматизация скриптами

Для начала нужно определиться что такое скрипт.

Скрипт — это набор команд, которые объединены в один файл и выполняются последовательно. По другому называется сценарный язык. В разных операционных системах может выглядеть по разному, но принцип действия у них практически одинаковый.

Для Windows это могут быть командные файлы bat или cmd, которые выполняет командный процессор cmd.exe. Так же может использоваться VBS или JScript со своим процессом выполнения cscript. Так же может быть использован PowerShell.

Для Linux очень частая практика использования bash-скриптов. Так же могут использоваться Perl и Python. Это уже, по сути, интерпретируем языки программирования, используемые для более сложной и развернутой автоматизации. На них так же пишут сложные целые программы и даже программные комплексы.

Специализированное ПО

Если не хочется писать такие сценарии самостоятельно, то рынок предлагает целые готовые решения от простых бесплатных вариантов до крупных сложных систем. Вот тут можно уже выбирать что нравится и что подходит под конкретные задачи. Скажу только, что не нужно для домашнего ПК выбирать программу уровня Enterprise. Оно не окупится на его поддержку.

Куда сохранять?

Тоже не маловажный вопрос. Если у Вас не много данных, то достаточно будет флешки. Если же данных достаточно много, то, вероятно, стоит задуматься о съемном жестком диске. Тут все просто: подключаем, копируем, отключаем.

Еще можно копировать данные в «Облако». Этот способ хорош тем, что к данным можно получить доступ без физического носителя, т.е. вы просто их скачиваете.

Есть более сложный вариант для домашнего использования: домашний сервер. Я для себя выбрал такой вариант. Каждый может выбрать то что требуется.

Для уровня предприятия используются более сложные сценарии. Тут уже идет в ход все начиная от обычных скриптов и заканчивая целыми серверами резервного копирования. Технологий используется масса. Так скриптами может производиться подготовка данных и уже потом подготовленные данные сохраняться на носители. Кстати носителями информации могут быть и магнитные ленты.

А как же пример?

Я не буду придумывать что-то сложное а просто покажу пример в Linux:

tar cjf .tar.bz2

Данная команда создаст архив tar и сожмет его архиватором bz2. Это и будет резервная копия. Останется написать сценарий и добавить его в планировщик задач.

Ну что же. Приступим!

Операционная система

Как я уже писал ранее, выбрал для себя Armbian, а конкретно образы для Orange Pi Prime и Orange Pi Zero Plus. Установка достаточно простая. Для начала нужно распаковать архивы, а затем на каждую флэшку записать образ. Вот как это делается:

dd if= of=/dev/sd bs=1M status=progress

Если не в курсе какая буква, то не беда. Вбиваем в консоль команду:

lsblk

Готово! Теперь собираем все в кучу, подключаем монитор и запускаем.

Для Orange Pi Zero Plus подключаем UART и вставляем в USB. Далее я делал через программу screen.

screen /dev/ttyUSB0

Кстати, путь может отличаться до USB-устройства, так что следует проверить. После просто отвечаем на вопросы.

Настройка сети

Когда у нас все готово нужно настроить сеть. Я отказался от NetworkManager (за ненадобностью). Отключаем его (все эти и дальнейшие команды выполняю от суперпользователя root):

systemctl stop NetworkManager && systemctl disable NetworkManager

Нужно еще проверить имя сетевого интерфейса. Для этого вбиваем следующую команду:

ip a

Вот мой результат:

1: lo:  mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: eth0:  mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether
    inet  brd  scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::1:1cff:fe0b:dab6/64 scope link
       valid_lft forever preferred_lft forever
3: wlan0:  mtu 1500 qdisc noop state DOWN group default qlen 1000
    link/ether

Интерфейс wlan0 — это Wi-Fi. Он мне не нужен, по этому настраивать я его не буду. Ищем что-то типа eth или ens. Это и будет наш проводной интерфейс.

Теперь открываю файл на редактирование /etc/network/interfaces и привожу к следующему виду, соответственно указывая нужные мне адреса. Для обоих одноплатников должны быть разные адреса в поле address и эти адреса должны быть свободными, ну и должны находиться в диапазоне Вашей сети:

# Network is managed by Network manager
auto lo
iface lo inet loopback

auto
iface eth0 inet static
address /
gateway
dns-nameservers

Далее мне лень вбивать команды перезапуска сети, по этому я просто перезагружаю:

/usr/sbin/reboot

Если захотелось NetworkManager

Если уж хочется настроить сеть через NetworkManager, то останавливать службу не нужно. Достаточно выполнить команду в консоли nmtui и выполнить настройку.

Подключение дисков

Сеть настроена, жесткий диск подключен, но он не используется. Значит надо подключать.

Так как у нас система загружается с SD-карты, то понадобится swap-раздел, а для хранения данных основной. Чтож готовим разделы.

Для всего этого добра воспользуемся программой разметки диска. Я не буду описывать как это делать, так как в интернете этой информации просто ВАЛОМ. Для выполнения такой работы можно использовать программы fdisk, gdisk и parted. Первая предназначена для MBR-разделов, вторая для GPT-разделов, а третья может работать в обоих режимах, так что выбираем что больше нравится. Единственное GPT-разделы предподчительней использовать, так они поддерживают больший объем, чем MBR. Об этом можно почитать в Википедии.

Наша задача создать 2 раздела. Первый раздел располагаем в начале диска размером 4ГБ (более чем достаточно) для раздела SWAP, а второй будет все оставшееся пространство. Его форматируем в EXT4 (можно выбрать другую файловую систему по вкусу). Как создать SWAP и форматировать в EXT4 (или другие файловые системы ищем в интернете). Как работать с разделами прекрасно расписано, например, здесь.

Далее необходимо создать директорию куда будем подключать наше хранилище. Для этого создаем директорию. У меня сделано так:

mkdir -p /mnt/storage

Далее надо посмотрим какие диски имею метки UUID:

blkid

После открываем файл fstab:

nano /etc/fstab

И добавляем строчки для автомонтирования разделов при загрузке:

UUID= none  swap    sw      0 0
UUID=<>UUID раздела для будущих файлов /mnt/storage ext4 defaults,noatime,commit=600,errors=remount-ro 0 1    defaults,noatime,commit=600,errors=remount-ro 0 1

Под конец выполняем монтирование:

mount -a

Проверяем что все хорошо:

mount

Вместо заключения

На текущий момент это была первоначальная настройка будущих серверов. По итогу я получил работающие компьютеры, с которыми можно продолжать работать. На данном этапе все это добро можно смело убирать в корпус и приводить в порядок все провода и убирать всю систему куда-нибудь на полку, где не будет все это добро мешаться.

Рабочая система

Диски

Вариант №1 — самый простой и банальный вариант, это пойти в магазин и купить NAS-сервер. Стоимость таких устройств самая разнообразная. Думаю каждый найдет для себя то что он хочет.

Вариант №2 может подойти тем, у кого есть дома в углу старое железо, которое выбросить жалко и можно найти рабочие устройства. С этого можно собрать рабочий системный блок и, при необходимости докупить жесткие диски.

Вариант №3 — вот с этого момента я постараюсь рассказать тему более малого размера сервера. А сервер будет строить на одноплатниках.

Данная статья не претендует на уникальность и описывает только мой личный опыт. И так — поехали!

На что можно посмотреть

Первым делом нужно выбрать плату. Таких плат и производителей уж очень много на сегодняшний день. Тут есть практически на любой вкус и цвет процессоры. С размером ОЗУ тоже все достаточно понятно: от 512МБ и до 8ГБ (то что я видел на картинках).

Очень многие одноплатники имеют слот под SD-карту, но очень мало имеют SATA-разъемы. SD-карты нужны, чтобы установить первоначальную операционную систему и запустить ее уже в рабочем режиме. Некоторые из моделей имеют «на борту» у себя eMMC-микросхему, а которую можно «перенести» установленную ОС, тем самым избавиться от «флешки».

Что касается носителей (HDD/SDD), то в этом плане немного сложнее. Здесь можно использовать 3 варианта:

• Плату уже с распаянным SATA-разъемом;- Плату расширения с SATA-разъемом;- Переходник USB->SATA.

Собственно разницы особо никакой, потому что даже первый вариант в большинстве случаев является переходником с USB на SATA, только уже сделанный для удобства.

Я в 2018 году долго выбирал что бы взять подешевле. В итоге остановился на Orange Pi Zero Plus с 512МБ. Такая себе вполне вменяемая плата, но на ней отсутствует SATA. Чтобы подключить диск нужна плата расширения либо переходник. Вот как раз у производителя есть такая плата расширения, но она все так же является переходником с USB.

Что касается ограничений, то это USB 2.0, так что от него ничего производительного ждать не стоит (если вы надеетесь на сотни мегабайт в секунду). В общем про SSD можно забыть. А что по скорости HDD, то я проверял последовательность чтения и записи и она не превышает 40МБ/с, так что жесткий диск тоже напрягаться не будет.

Электричество

Вот тут нас поджидает небольшой облом… Дело в том что у этого одноплатника есть питание через OTG, но куча всяких блоков питания не хочется подключать. Это придется удлинитель куда-то засовывать, да и вообще, не по фэншую это все. А так как я еще заказывал Orange Pi Prime на 2ГБ, то там уже не было питание через OTG, а присутствует разъем под блок питания. Кстати, для обеих плат рекомендован БП на 2А при 5В. А вот в NAS-расширении присутсвтует ровно такой же разъем.

Ну что же. Пришел час старого доброго БП от стационарника. Подключим его, ибо в нем хватает всего и вся. Мощность его всего 350Вт, но даже этого хватает с головой.

Пошел я в Китай-магазин и заказал 10шт разъемов питания 24pin под БП и решил еще прикупить разъемов USB пачкой (они так же пригодятся). Пришло, хорошо. Теперь нужно все это распаять. Так как у БП формата ATX питание включается только при определенных условиях, то нужно их выполнить. Вот распиновка разъема (ищется на раз):

24 pin

Чтобы БП заработал нужно замкнуть PS-ON и Ground обычной скрепкой. И вот тут нужно идти в радио-магазин за кнопкой с фиксацией. Заодно прикупить штекеров для компов.

Теперь берем разъем и припаиваем проводами штекеры к Ground и +5V. К ним же можно припаять USB-разъемы. Можно подключить телефончик для зарядки или еще какую-нибудь штуку, типа ионизатора воздуха. Найти применение можно.

После сборки подключаем, проверяем — работает!

Операционная система

Сразу скажу: про форточки можно забыть! Если взять практически любой роутер или тот же магазинный NAS-сервер, то там стоит Linux, так что при ручной настройки придется поковыряться. Я не буду здесь описывать готовые решения «поставил и играй». Здесь мы будем ставить все изнутри ручками.

Для начала нужно выбрать и установить какой-нибудь дистрибутив. Тут кому что нравится. Мне лично понравился Armbian на основе Debian. Загружаем и устанавливаем. Не скажу как это сделать в Windows (не пользуюсь), но вот в Linux это достаточно просто. Распаковываем архив и выполняем команду:

dd of=/dev/sd if= bs=1M status=progress

Мне нравится видеть сколько скопировано, по этому и указан статус.

Ждем окончания и все готово.

Если есть выход HDMI, то подключаем монитор и настраиваем (статей в интернете полно). Если нету, то вот тут нужен USB->UAR, который тоже нужно заблаговременно приобрести. Подключать нужно Rx->Tx, Tx->Rx, GND->GND. Подключаем, запускаем, открываем последовательный терминал типа Telnet, Putty, Screen (Linux), подключаемся и точно так же делаем первоначальную настройку и настраиваем сеть.

Связь

Так как это бездисплейные домашний серверы и мы хотим чтобы они работали по сети, то их нужно как-то подключить в домашнюю локальную сеть. У меня в закромах был Коммутатор 100Tx-Base. Для моих задач мне хватает, тем более на текущий момент у меня скорости чтения с диска не превышает 15МБ/с, а по сети предел 100МБит/с или примерно 10МБ/с. 5 портов на текущий момент хватает (2 платы, TV-Box и порт от роутера). Wi-Fi на платах я не использую.

Барахло на коленке

Как-то грустно это все валяется на полу. Я вижу 3 варианта:

• Пусть оно так и валяется пока кто-нибудь не убьется или пока домашние не вышвырнут из жилплощади;- Старый системный корпус;- Сделать свой корпус с шахматами и пивом.

3-й вариант ну уж очень вкусно выглядит, так как можно придумать все что угодно, но… Да чего тут говорить, просто лень что-то придумывать. Тут либо из фанеры лобзиком вырезать, либо из металла/оргстекла/чего-то лепить, либо разработать корпус и напечатать. Кстати если есть 3D-принтер то это не должно быть проблемой, а если нет, то, наверно же, можно найти у кого он есть. Главное разработать проект печати.

В итоге я решил сделать из старого корпуса, а к 3D-печати может потом вернусь и реализую.

Для начала бежим в строительный магазин и покупаем пакеты винтов М3, стоечек того же формата и шайбы под все это (лишним прям совсем не будет). После все платы прикручиваем внутри корпуса с помощью молотка, так как расстояния отверстий на плате и на задней стенке под материнскую плату не совпадают (тут меня долго бомбит из-за 0,5мм разброса) и подключаем все провода.

Сервер обработки

Разъем питания

Итоги

Если посчитать по стоимости, то обошлась мне эта сборка около 10000 рублей вместе с диском на 1ТБ, 2-мя MicroSD на 16ГБ и двумя одноплатниками плюс рассыпуха по мелочи. По времени дня 4 с установкой ОС, настройкой сетевых дисков, отладкой работы и объяснением домочадцам как это работает и на кой оно надо.