Рубрики
Uncategorized

Raspberry Pi Cluster Emuation с Docker Compose

TL; доктор Это руководство обсуждается, что все необходимое для создания простых, масштабируемых и полностью двоичных … Теги с Docker, DevOps, RaspberryPi.

TL; доктор

Данное руководство обсуждается все, что необходимо для создания простых, масштабируемых и полностью бинарных совместимых кластеров PI Raspberry с помощью QEMU, Docker, Docker Compose и Anbible.

Введение

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

Недолго после того, как первая Raspberry Pi была выпущена в 2012 году, несколько изложены, чтобы построить их на недорогие кластеры, часто для их исследований и тестирования. Стажеры на DataStax Построил мульти-центр обработки данных, 32 узла Кассенда Демо-допусков неисправностей, в комплекте с большой красной кнопкой, чтобы имитировать сбой всего центра обработки данных. Дэвид Гиль построил 40-узла Raspberry Pi кластер Это было предназначено для того, чтобы быть частью его тезиса MSCE. Балена построен » Зверь «, 120 узла Raspberry Pi Cluster, для масштабированного тестирования их онлайн-платформы. А на крайний конец спектра Oracle построил 1060 узла Raspberry Pi кластер , которые они ввели в Oracle OpenWorld 2019.

Инновации с Raspberry Pi продолжаются, поскольку они превращаются во все, от удлинителей Wi-Fi, камеры безопасности и даже больших кластеров. Хотя основное значение этих кластеров присуще их размеру и низкой стоимости, их популярность делает их все более распространенной платформой развития. Поскольку Raspberry Pi использует процессор ARM, это может сделать разработку проблематично для тех из нас, кто работает исключительно в облаке. В то время как существуют коммерческие решения, мы будем строить наш собственный эмулируемый кластер с использованием полностью открытого исходного стека, размещенного в Google Compute Engine.

Случаи применения

Кроме изучения из опыта, докеренная эмулируемая малина PI позволяет нам делать три вещи. Один, он превращается в программное обеспечение, которое в противном случае было бы только аппаратно-единственным устройством, которое никто не должен не забывать нести (я всегда теряю периферийные кабели). Два, он позволяет Docker сделать для PI, какой докер лучше всего для всего остального: он делает программное обеспечение портативным, легко управлять и простым для репликации. И три, это не занимает физического пространства. Если мы можем построить одну Raspberry Pi с Docker, мы можем построить много. Если мы сможем построить много, мы можем сеть их все вместе. Хотя мы можем столкнуться с некоторыми ограничениями, эта сборка будет эмулировать скопление малины Pi 1S, которая логически эквивалентна простую, многоулому физическому кластеру.

Эмулируемая аппаратная архитектура

Хотя технически не идентично, программное обеспечение эмуляции мы будем использовать, QEMU, предоставляет Универсальный Архитектура, которая примерно совместима с тем, что найдено на малине Pi 1. Некоторые модификации к ядру необходимо для того, чтобы она правильно работала с распачью, но для наших целей это один из более стабильных решений с открытым исходным кодом.

pi@raspberrypi:~$ cat /proc/cpuinfo 
processor       : 0
model name      : ARMv6-compatible processor rev 7 (v6l)
BogoMIPS        : 577.53
Features        : half thumb fastmult vfp edsp java tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant     : 0x0
CPU part        : 0xb76
CPU revision    : 7

Hardware        : ARM-Versatile (Device Tree Support)
Revision        : 0000
Serial          : 0000000000000000

По сравнению с физической малиной Pi 1, они почти идентичны:

pi@raspberrypi:~ $ cat /proc/cpuinfo
processor   : 0
model name  : ARMv6-compatible processor rev 7 (v6l)
BogoMIPS    : 697.95
Features    : half thumb fastmult vfp edsp java tls 
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x0
CPU part    : 0xb76
CPU revision    : 7

Hardware    : BCM2835
Revision    : 000d
Serial      : 000000003d9a54c5

Задний план

Что такое Qemu?

Qemu это эмулятор процессора. Он поддерживает множество различных процессоров, но единственное, что мы заинтересованы в то, что может работать Raspberry Pi изображений изначально не много трудностей. В этом случае мы собираемся использовать QEMU 4.2.0, что поддерживает набор инструкций ARM11, который совместим с чипом Broadcom BCM2835 (ARM1176JZFS), найденным на Raspberry Pi 1 и ноль. Мы будем использовать поддержку ARM1176 на QEMU, что позволит нам более или менее эмулировать Raspberry Pi 1. Я говорю более или меньше, потому что нам все равно нужно использовать Индивидуальное распабиевое ядро Для того, чтобы загрузиться на эмулируемое оборудование. Qemu Поддержка PI все еще в разработке, поэтому наш подход к получению его работы здесь является просто умным взлом, который ни в коем случае не будет оптимальным или эффективным с точки зрения использования ЦП.

Особенности QEMU

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

Докеризованный Qemu

Один из сильных сторон докера состоит в том, что он не обрабатывает полноценную виртуализацию, а вместо этого полагается на архитектуру системной системы. Поскольку наша хост-система будет запущена процессором Intel, мы не можем ожидать, что Docker обрабатывает операции по руку самостоятельно. Итак, мы разместим Qemu внутри контейнера докера. Поскольку Docker предназначен для запуска программного обеспечения на высоком родном исполнении, проблема оперативной эффективности будет с самой QEMU. QEMU, с другой стороны, поддерживает эмуляцию архитектуры машины полностью с программным обеспечением. Это имеет преимущество, это то, что он может работать внутри любой виртуализированной системы или контейнера, независимо от своей системной архитектуры. Если пациент, мы сможем даже запустить докеренную цветочную контейнер PI Raspberry внутри другого докеренного контейнера Pi Raspberry Pi. Недостаток к Qemu заключается в том, что он имеет сравнительно низкую производительность по сравнению с другими видами виртуализации. Но мы можем извлечь выгоду из лучшего из обоих миров, используя эмуляцию ARM QEMU, в зависимости от докера за все остальное.

Распабин

На основе Debian, Распабиан Это популярная и хорошо поддерживаемая операционная система для Raspberry Pi, и является одним из наиболее часто рекомендуемых для платформы. сообщество очень активный и хорошо управляемый.

Сравнение физической малины PI скорости

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

Raspberry Pi 1 2011,12

Test execution summary:
    total time:                          330.5514s
    total number of events:              10000
    total time taken by event execution: 330.5002
    per-request statistics:
         min:                                 32.92ms
         avg:                                 33.05ms
         max:                                 40.94ms
         approx.  95 percentile:              33.24ms

Threads fairness:
    events (avg/stddev):           10000.0000/0.00
    execution time (avg/stddev):   330.5002/0.00

Raspberry Pi 1 A + V1.1 2014

Test execution summary:
    total time:                          328.7505s
    total number of events:              10000
    total time taken by event execution: 328.6931
    per-request statistics:
         min:                                 32.71ms
         avg:                                 32.87ms
         max:                                 78.93ms
         approx.  95 percentile:              33.03ms

Threads fairness:
    events (avg/stddev):           10000.0000/0.00
    execution time (avg/stddev):   328.6931/0.00

Raspberry Pi Zero W V1.1 2017

Test execution summary:
    total time:                          228.2025s
    total number of events:              10000
    total time taken by event execution: 228.1688
    per-request statistics:
         min:                                 22.76ms
         avg:                                 22.82ms
         max:                                 35.29ms
         approx.  95 percentile:              22.94ms

Threads fairness:
    events (avg/stddev):           10000.0000/0.00
    execution time (avg/stddev):   228.1688/0.00

Raspberry Pi 2 модель B V1.1 2014

Test execution summary:
    total time:                          224.9052s
    total number of events:              10000
    total time taken by event execution: 224.8738
    per-request statistics:
         min:                                 22.20ms
         avg:                                 22.49ms
         max:                                 32.85ms
         approx.  95 percentile:              22.81ms

Threads fairness:
    events (avg/stddev):           10000.0000/0.00
    execution time (avg/stddev):   224.8738/0.00

Raspberry Pi 3 модель B V1.2 2015

Test execution summary:
    total time:                          139.6140s
    total number of events:              10000
    total time taken by event execution: 139.6087
    per-request statistics:
         min:                                 13.94ms
         avg:                                 13.96ms
         max:                                 34.06ms
         approx.  95 percentile:              13.96ms

Threads fairness:
    events (avg/stddev):           10000.0000/0.00
    execution time (avg/stddev):   139.6087/0.00

Raspberry Pi 4 B 2018

Test execution summary:
    total time:                          92.6405s
    total number of events:              10000
    total time taken by event execution: 92.6338
    per-request statistics:
         min:                                  9.22ms
         avg:                                  9.26ms
         max:                                 23.50ms
         approx.  95 percentile:               9.27ms

Threads fairness:
    events (avg/stddev):           10000.0000/0.00
    execution time (avg/stddev):   92.6338/0.00

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

Одиночные характеристики хоста

Исторически QEMU была однопоточной, эмуляцией всех сердечников архитектуры системы на одном процессоре. Хотя это больше не так, мы все еще будем эмулировать одну ядро для малины PI. Позже мы сделаем некоторые ориентиры, чтобы сравнить, как различные ограничения CPU на каждом узле влияют на производительность. Но на данный момент мы будем использовать один CPU на одноъятовый узел. Поскольку QEMU может использовать множество ресурсов ЦП, благодаря своей присущей неэффективности, наш начальный кластер тремя узла начнет с базовой линии, по меньшей мере, один CPU на узел, оставляя один ЦП, посвященный хозяину, чтобы избежать проблем с производительностью. Спецификаторы VM, выбранные для этой задачи, являются следующими.

Cloud Provider: Google Cloud Platform
Instance Type: n1-standard-4
CPUs: 4
Memory: 15GB
Disk: 100GB
Operating System: Ubuntu 18.04 LTS

Докер

Установлено на хосте, мы также используем версию Docker по умолчанию, которая доступна в репозитории APT по умолчанию для Ubuntu 18.04 LTS.

# docker -v
Docker version 18.09.7, build 2d0083d

Docker Compose

# docker-compose -v
docker-compose version 1.25.0, build 0a186604

Docker Hub Ubuntu Image

18.04, bionic-20200112, bionic, latest

Qemu

Установлен внутри контейнера Docker, мы будем использовать следующую версию QEMU для ARM:

# qemu-system-arm --version
QEMU emulator version 4.2.0
Copyright (c) 2003-2019 Fabrice Bellard and the QEMU Project developers

Qemu Custom Kernel для распачина

Загружены из Qemu внутри докера, мы будем использовать ДГРУВ ВЫС ‘s Компилированное ядро Для распабина, который был изменен, чтобы быть использованным с Qemu.

Распабское облегчение изображения

Также загрузил из Qemu, мы будем использовать немодифицированную версию Распабиан Лит С 30.09.2019.

Ожидать (TCL/TK)

Установлен на контейнере Docker — это следующая версия ожидания:

# expect -v
expect version 5.45.4

SSH/SSHD

SSHD нужно будет включить на каждом распыющем узле, а SSH следует включить на хосте.

Неизбежный

Следующая версия Anisible также используется вместе с другими зависимостями:

# ansible --version
ansible 2.5.1
  config file = /etc/ansible/ansible.cfg
  configured module search path = [u'/root/.ansible/plugins/modules', u'/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python2.7/dist-packages/ansible
  executable location = /usr/bin/ansible
  python version = 2.7.17 (default, Nov  7 2019, 10:07:09) [GCC 7.4.0]

Создание документов докера

Кему строительный контейнер

Мы скомпилируем QEMU 4.2.0 от источника. Это понадобится все инструменты поддержки сборки, поэтому чтобы сохранить наш контейнер приложений как можно меньше, мы создадим отдельный контейнер для сборки для CEMU, используя минимальную версию Ubuntu 18.04 из Docker Hub.

Qemu приложение контейнер

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

Конфигурация докера

Dockerfile

Мы будем использовать следующие Dockerfile, которые также могут быть найдены обновлены в сопровождении этого руководства Pidoc Репозиторий на Github. Каждый фрагмент кода ниже состоит из сегмента DockerFile. Спасибо, идет на Люк ребенок для его работы на Докерпи Отказ

Стадия сборки для QEMU-System-Arm :

FROM ubuntu AS qemu-system-arm-builder
ARG QEMU_VERSION=4.2.0
ENV QEMU_TARBALL="qemu-${QEMU_VERSION}.tar.xz"
WORKDIR /qemu

RUN apt-get update && \
    apt-get -y install \
                       wget \
                       gpg \
                       pkg-config \
                       python \
                       build-essential \
                       libglib2.0-dev \
                       libpixman-1-dev \
                       libfdt-dev \
                       zlib1g-dev \
                       flex \
                       bison

Скачать источник.

RUN wget "https://download.qemu.org/${QEMU_TARBALL}"

RUN # Verify signatures...
RUN wget "https://download.qemu.org/${QEMU_TARBALL}.sig"
RUN gpg --keyserver keyserver.ubuntu.com --recv-keys CEACC9E15534EBABB82D3FA03353C9CEF108B584
RUN gpg --verify "${QEMU_TARBALL}.sig" "${QEMU_TARBALL}"

Извлечь тарбол.

RUN tar xvf "${QEMU_TARBALL}"

Создать источник.

RUN "qemu-${QEMU_VERSION}/configure" --static --target-list=arm-softmmu
RUN make -j$(nproc)
RUN strip "arm-softmmu/qemu-system-arm"

Создайте изображение PIDOC VM PIDOC VM.

FROM ubuntu as pidoc-vm
ARG RPI_KERNEL_URL="https://github.com/dhruvvyas90/qemu-rpi-kernel/archive/afe411f2c9b04730bcc6b2168cdc9adca224227c.zip"
ARG RPI_KERNEL_CHECKSUM="295a22f1cd49ab51b9e7192103ee7c917624b063cc5ca2e11434164638aad5f4"

Передача двоичных данных из контейнера для создания контейнера приложений.

COPY --from=qemu-system-arm-builder /qemu/arm-softmmu/qemu-system-arm /usr/local/bin/qemu-system-arm

Загрузите модифицированное ядро и установите.

ADD $RPI_KERNEL_URL /tmp/qemu-rpi-kernel.zip

RUN apt-get update && \
    apt-get -y install \
                        unzip \
                        expect
RUN cd /tmp && \
    echo "$RPI_KERNEL_CHECKSUM  qemu-rpi-kernel.zip" | sha256sum -c && \
    unzip qemu-rpi-kernel.zip && \
    mkdir -p /root/qemu-rpi-kernel && \
    cp qemu-rpi-kernel-*/kernel-qemu-4.19.50-buster /root/qemu-rpi-kernel/ && \
    cp qemu-rpi-kernel-*/versatile-pb.dtb /root/qemu-rpi-kernel/ && \
    rm -rf /tmp/*

VOLUME /sdcard

Затем мы скопируем сценарий точки входа из основного каталога Host.

ADD ./entrypoint.sh /entrypoint.sh
ENTRYPOINT ["./entrypoint.sh"]

Создайте окончательное изображение PIDOC PIDOC с загруженной файловой системой Raspbian Lite.

FROM pidoc-vm as pidoc
ARG FILESYSTEM_IMAGE_URL="http://downloads.raspberrypi.org/raspbian_lite/images/raspbian_lite-2019-09-30/2019-09-26-raspbian-buster-lite.zip"
ARG FILESYSTEM_IMAGE_CHECKSUM="a50237c2f718bd8d806b96df5b9d2174ce8b789eda1f03434ed2213bbca6c6ff"

ADD $FILESYSTEM_IMAGE_URL /filesystem.zip
ADD pi_ssh_enable.exp /pi_ssh_enable.exp

RUN echo "$FILESYSTEM_IMAGE_CHECKSUM  /filesystem.zip" | sha256sum -c

Encentpoint.sh Файл

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

#!/bin/sh

raspi_fs_init() {

  image_path="/sdcard/filesystem.img"
  zip_path="/filesystem.zip"

  if [ ! -e $image_path ]; then
    echo "No filesystem detected at ${image_path}!"
    if [ -e $zip_path ]; then
        echo "Extracting fresh filesystem..."
        unzip $zip_path
        mv *.img $image_path
        rm $zip_path
    else
      exit 1
    fi
  fi
}

Сценарий затем проверяет пустую Raspi-init Файл, который служит маркером, чтобы определить, было ли ожидаемое ожидаемое, чтобы включить SSH на Raspbian.

if [ ! -e /raspi-init ]; then
  touch /raspi-init
  raspi_fs_init
  echo "Initiating Expect..."
  /usr/bin/expect /pi_ssh_enable.exp `hostname -I`
  echo "Expect Ended..."

Если ожидаем уже был ранее включен, то нам нужно только запускать QEMU, без ожидания. Обратите внимание, что мы пересылаем порт 22 на расэпбиан до порта 2222 внутри контейнера докера.

else
  /usr/local/bin/qemu-system-arm \
        --machine versatilepb \
        --cpu arm1176 \
        --m 256M \
        --hda /sdcard/filesystem.img \
        --net nic \
        --net user,hostfwd=tcp:`hostname -I`:2222-:22 \
        --dtb /root/qemu-rpi-kernel/versatile-pb.dtb \
        --kernel /root/qemu-rpi-kernel/kernel-qemu-4.19.50-buster \
        --append "root=/dev/sda2 panic=1" \
        --no-reboot \
        --display none \
        --serial mon:stdio
fi

Включить SSH на расэпбиине (ожидайте метод TCL/TK)

QEMU не имеет простого метода для загрузки сценариев конфигурации на загрузке. И потому что Raspbian не приходит с SSH, позволил по умолчанию, нам придется повернуть его на себя. Наши варианты должны делать это вручную или использовать какой-то инструмент сценариев, который может взаимодействовать с STDIO Отказ Другой вариант — настроить изображение расплавки перед установкой. Это должно было бы сделать на хосте, однако, так как Docker ограничивает монтаж новых файловых систем. В любом случае, чтобы создать эту строгу самых портативных и нестандартных, самых простых для наших целей будет использоваться Ожидать Скрипт, и у него скопированы в наше изображение докера на сборку.

Pi_ssh_enable.exp Файл

Поскольку немодифицированное изображение Raspbian не имеет доступных портов по умолчанию, мы будем использовать ожидаю, что интерфейс с STDIO В Qemu войдите в систему с именем пользователя и паролем по умолчанию и включите SSHD слушатель.

#!/usr/bin/expect -f
set ipaddr [lindex $argv 0]
set timeout -1
spawn /usr/local/bin/qemu-system-arm \
  --machine versatilepb \
  --cpu arm1176 \
  --m 256M \
  --hda /sdcard/filesystem.img \
  --net nic \
  --net user,hostfwd=tcp:$ipaddr:2222-:22 \
  --dtb /root/qemu-rpi-kernel/versatile-pb.dtb \
  --kernel /root/qemu-rpi-kernel/kernel-qemu-4.19.50-buster \
  --append "root=/dev/sda2 panic=1" \
  --no-reboot \
  --display none \
  --serial mon:stdio
expect "raspberrypi login:"
send -- "pi\r"
expect "Password:"
send -- "raspberry\r"
expect "pi@raspberrypi:"
send -- "sudo systemctl enable ssh\r"
expect "pi@raspberrypi:"
send -- "sudo systemctl start ssh\r"
expect "pi@raspberrypi:"
expect eof

Построить изображение

В папке с Dockerfile Мы будем строить наши два контейнера. Первый будет наш контейнер сборки, который включает в себя все зависимости для компиляции QEMU, а другой будет наш прикладной контейнер для работы QEMU.

docker build -t pidoc .

Переадресация и устранение неисправностей сети

Как только сборка будет завершена, принесите его отдельно и следуйте журналам.

docker run -itd --name testnode pidoc
docker logs testnode -f

Raspbian будет загружать и распадать автоматически, а Qemu должен начать загрузку с изображения.

После того, как Raspbian полностью загружен, ожидайте автоматически включить нашД. . Войдите в контейнер Docker и проверьте, что SSH доступен изнутри контейнера на порту 2222 Отказ

# docker exec -it testnode bash
root@d4abc2f655e6:/# hostname -I
172.17.0.3
root@d4abc2f655e6:/# cat < /dev/tcp/172.17.0.3/2222
SSH-2.0-OpenSSH_7.9p1 Raspbian-10

Отменить и убить контейнер и снимите громкость.

root@d4abc2f655e6:/# exit
exit
# docker kill testnode
testnode
# docker container rm testnode
testnode

Тестирование контейнера Docker

Старт/тестовый контейнер

Нам нужно будет начать контейнер для тестирования. Это в первую очередь, чтобы получить некоторую интуицию о производительности QEMU, чтобы мы могли лучше сделать дизайнерские решения относительно нашего кластера. Система должна быть очищена, может быть, несколько доброкачественных предупреждений, связанных с различиями между несколько более обобщенным эмулируемым оборудованием и ожидаемым физическим оборудованием Raspberry Pi. Я обнаружил, что необходимо убедиться, что переадресация порта работает должным образом между QEMU и изображением докера, чтобы я мог бы еще больше проверить, что переадресация портов между изображением докера и хостом работала должным образом. Наша первая цель состоит в том, чтобы удвоить SSH, чтобы Qemu доступен непосредственно с хоста.

docker run -itd -p 127.0.0.1:2222:2222 --name testnode pidoc
docker logs testnode -f

Как только система снова придет онлайн, тестируйте на SSHD на порту 2222 хоста, используя SSH Войти в Рассы:

# ssh pi@localhost -p 2222
The authenticity of host '[localhost]:2222 ([127.0.0.1]:2222)' can't be established.
ECDSA key fingerprint is SHA256:N0oRF23lpDOFjlgYAbml+4v2xnYdyrTmBgaNUjpxnFM.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '[localhost]:2222' (ECDSA) to the list of known hosts.
pi@localhost's password:
Linux raspberrypi 4.19.50+ #1 Tue Nov 26 01:49:16 CET 2019 armv6l

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Tue Jan 21 12:24:59 2020

SSH is enabled and the default password for the 'pi' user has not been changed.
This is a security risk - please login as the 'pi' user and type 'passwd' to set a new password.

pi@raspberrypi:~ $

Тестирование дробной загрузки процессора

Чтобы запустить этот кластер, мы используем экземпляр GCP N1-Standard-4 (A 4×15), работающий Ubuntu 18.04 LTS. Но теперь мы обращаемся к тому, насколько неэффективно Qemu, как только Рампбиан начинает делать что угодно. Множественные экземпляры Raspberry Pi могут стекиваться, если их простаивают, но если мы хотим сохранить систему жизнеспособной, нам нужно будет ограничить использование процессоров на каждом экземпляре, иначе система может быть несовместимой раз более чем несколько узлов нагрузки. Отказ К счастью, Docker может справиться с этим для нас. У нас есть 15 ГБ оперативной памяти на этом экземпляре, поэтому давайте посмотрим, что произойдет, если мы немного более амбициозны и сжали 6 контейнеров Pi Raspberry Pi на нашу вирту. У нас будет целое ядро для хоста, чтобы управлять другими задачами без особого риска неудачи. Мы можем масштабировать это в какой-то момент позже с помощью Docker Compose.

Мы запускаем два тестовых контейнера на 50% и 100% для тестирования тестирования.

docker run -itd --cpus="0.50" -p 127.0.0.1:2250:2222 --name pidoc_50_test pidoc
docker run -itd --cpus="1.00" -p 127.0.0.1:2200:2222 --name pidoc_00_test pidoc

На данный момент мы уже имеем кластер. У нас просто нет метода для управления их, кроме вручную.

Представление

Хотя полное распределение ядра выпускается на высокой физической малине PI скоростей PI, экземпляр, работающий на 50%, проходит правильно в половине этой скорости. Это может быть управляется при определенных обстоятельствах, но это не самый желательный. Общая эффективность кластера может увеличить, в зависимости от задачи под рукой. Но на данный момент мы продолжим наше первоначальное полное распределение ядра 3 узлов, а затем позже он тестирует с 6 узлами.

Однопоточные тесты

Тестирование можно сделать, используя следующие простые тесты по тестам.

CPU Prime Test.
sysbench --test=cpu --cpu-max-prime=9999 run
CPU целочисленный тест
time $(i=0; while ((i<9999999)); do ((i++)); done)
Тест на чём-жесткий диск
dd bs=16K count=102400 iflag=direct if=test_data of=/dev/null
Тест на запись HDD
dd bs=16k count=102400 oflag=direct if=/dev/zero of=test_data

Результаты (Однотрие)

Для этого руководства мы будем сосредоточиться только на Prime Test CPU, используя Sysbench.

Хозяин
General statistics:
    total time:                          10.0009s
    total number of events:              9417

Latency (ms):
         min:                                  1.04
         avg:                                  1.06
         max:                                  1.63
         95th percentile:                      1.10
         sum:                               9992.36

Threads fairness:
    events (avg/stddev):           9417.0000/0.00
    execution time (avg/stddev):   9.9924/0.00
Виртуальная малина PI — предел: 100%
Test execution summary:
    total time:                          397.8781s
    total number of events:              10000
    total time taken by event execution: 397.4056
    per-request statistics:
         min:                                 38.61ms
         avg:                                 39.74ms
         max:                                 57.15ms
         approx.  95 percentile:              40.92ms

Threads fairness:
    events (avg/stddev):           10000.0000/0.00
    execution time (avg/stddev):   397.4056/0.00
Виртуальная малина PI — предел: 50%
Test execution summary:
    total time:                          823.8272s
    total number of events:              10000
    total time taken by event execution: 822.9329
    per-request statistics:
         min:                                 38.68ms
         avg:                                 82.29ms
         max:                                184.02ms
         approx.  95 percentile:              94.65ms

Threads fairness:
    events (avg/stddev):           10000.0000/0.00
    execution time (avg/stddev):   822.9329/0.00

Сочинять кластер

Создать docker-compose.yml файл

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

version: '3'

services:
  node:
    image: pidoc
    ports:
      - "2201-2203:2222"

Принести кластер

Чтобы поднять три узла с Docker-Compose Используйте Сырье вариант.

docker-compose up --scale node=3

Обязательная конфигурация

Теперь, когда у нас есть вся инфраструктура на месте для кластера, нам нужно управлять этим. Мы могли бы использовать Docker для двойного прикрепления к монитору QEMU, но SSH гораздо более надежно. Так как мы используем SSH. мы можем использовать Anbible. Здесь приведены несколько основных операций: Обновление , Обновление , Перезагрузка и Выключение Отказ Они могут быть расширены по мере необходимости для разработки более надежной системы.

хосты Файл

Обратите внимание на порты, которые мы указали в Docker-Compose.yml Файл ранее, и отредактируйте свой хосты инвентарь соответственно.

[all:vars]
ansible_user=pi
ansible_ssh_pass=raspberry
ansible_ssh_extra_args='-o StrictHostKeyChecking=no'

[pidoc-cluster]
node_1.localhost:2201
node_2.localhost:2202
node_3.localhost:2203

Для более всеобъемлющего прохождения неспособных, пожалуйста, прочитайте Как установить и настроить Anbible на Ubuntu Отказ

update.yml Файл

---
- name: Apt update Pi...
  hosts: pidoc-cluster
  tasks:
    - name: Update apt cache...
      become: yes
      apt:
        update_cache=yes

Использование: Ansible-Playbook Playbooks/update.yml -i хосты

Upgrade.yml Файл

---
- name: Upgrade Pi...
  hosts: pidoc-cluster
  gather_facts: no
  tasks:
    - name: Update and upgrade apt packages...
      become: true
      apt:
        upgrade: yes
        update_cache: yes
        cache_valid_time: 86400

Использование: Ansible-Playbook Playbooks/Upgrade.yml -i Hosts

reboot.yml Файл

---
- name: Reboot Pi...
  hosts: pidoc-cluster
  gather_facts: no
  tasks:
    - name: Reboot Pi...
      shell: shutdown -r now
      async: 0
      poll: 0
      ignore_errors: true
      become: true

    - name: Wait for reboot...
      local_action: wait_for host={{ ansible_host }}state=started delay=10
      become: false

Использование: Ansible-Playbook Playbooks/reboot.yml -i хосты

Shutdown.yml Файл

---
- name: Shutdown Pi...
  hosts: pidoc-cluster
  gather_facts: no
  tasks:
    - name: 'Shutdown Pi'
      shell: shutdown -h now
      async: 0
      poll: 0
      ignore_errors: true
      become: true

    - name: "Wait for shutdown..."
      local_action: wait_for host={{ ansible_host }} state=stopped
      become: false

Использование: Ansible-Playbook Playbooks/Shutdown.yml -i хосты

Расширение вверх

Docker Compose производит масштабирование Raspberry Pi контейнеров на том же хосте недалеко от тривиального. Используя Anbible для управления кластерами, он также становится невероятно простым в масштабе горизонтали к другим хостам, изменив привязку порта от Localhost на IP-адрес, который побудитель. Вот наш пример с 6 узлами вместо 3.

Docker-Compose.yml файл

version: '3'

services:
  node:
    image: pidoc
    ports:
      - "2201-2212:2222"
    deploy:
      resources:
        limits:
          cpus: "0.5"

Принести кластер

Мы должны остановить контейнеры из нашего предыдущего кластера и обрезать все тома, прежде чем расширить наш пересмотренный кластер. Чтобы поднять все 6 узлов с Docker-Compose Используйте Сырье опция снова.

docker-compose up --scale node=5

Будущая работа

Raspberry Pi Emulation все еще находится под разработкой для Qemu. Хотя конфигурация для этого проекта является относительно стабильной, есть много места для улучшения. Попытка миграции на эмуляцию Raspberry Pi 3 будет амбициозным следующим шагом. Docker Compose, хотя и предназначен для построителей одного хоста, уже достаточно легко повторить для других хостов вручную или через неизбежную. Но это может быть так же легко уменьшаться с Рой Или K8S, позволяя нам построить эмулируемую малину PI кластер любого размера. Кроме того, с одним или несколькими перенаправлениями портов могут быть установлены другие системы управления, включая различные конечные точки узла, в зависимости от цели и применения.

Оригинал: «https://dev.to/appfleet/raspberry-pi-cluster-emulation-with-docker-compose-5ckn»