Hogyan futtassunk Docker konténereket egy Raspberry Pi-n?

Üdvözöllek a mini szerverek és otthoni automatizálás világában! Ha valaha is elgondolkodtál azon, hogyan hozhatnád ki a legtöbbet egy apró, de annál erősebb Raspberry Pi-ből, akkor a Docker az a kulcs, amire szükséged van. A Docker konténerek forradalmasították az alkalmazások telepítésének és futtatásának módját, és ez a technológia tökéletesen illeszkedik a Raspberry Pi rendkívül sokoldalú képességeihez. Ebben a részletes útmutatóban lépésről lépésre végigvezetünk azon, hogyan alakíthatod át a Raspberry Pi-det egy hatékony, otthoni szerverré, amely számos feladatot képes ellátni, a média szervertől kezdve az okosotthon vezérléséig.

Miért éppen Raspberry Pi és Docker?

A Raspberry Pi egy pénztárcabarát, energiatakarékos és kompakt számítógép, amely ideális választás otthoni szerverek, IoT (Internet of Things) projektek, vagy éppen fejlesztési környezetek létrehozására. A Docker technológia pedig lehetővé teszi, hogy az alkalmazásokat elszigetelt, hordozható egységekben, úgynevezett konténerekben futtassuk. Ennek számos előnye van:

Elszigetelés: A konténerek garantálják, hogy az alkalmazások és azok függőségei ne zavarják egymást, vagy a gazdarendszer (jelen esetben a Raspberry Pi) operációs rendszerét.
Hordozhatóság: Egy Docker konténer bárhol futtatható, ahol van Docker motor, legyen szó egy másik Raspberry Pi-ről, egy asztali gépről, vagy egy felhőalapú szerverről.
Erőforrás-hatékonyság: A virtuális gépekkel ellentétben a konténerek megosztják a gazdarendszer kernelét, így sokkal kevesebb erőforrást fogyasztanak.
Egyszerű telepítés és menedzsment: Az alkalmazások telepítése csupán egy-két parancsot igényel, a frissítés és a hibaelhárítás is nagyságrendekkel egyszerűbb.
Gyors fejlesztés és tesztelés: A fejlesztők könnyen létrehozhatnak konzisztens környezeteket, ami felgyorsítja a munkafolyamatokat.

Ezek az előnyök teszik a Raspberry Pi és a Docker kombinációját ideális párossá mind hobbi felhasználók, mind pedig profi fejlesztők számára.

Szükséges Előfeltételek

Mielőtt belevágnánk a telepítésbe, győződjünk meg róla, hogy minden szükséges eszközzel rendelkezünk:

Raspberry Pi: Bár elvileg bármelyik modell alkalmas, a Raspberry Pi 3B+, de leginkább a Raspberry Pi 4 ajánlott, különösen, ha több konténert vagy erőforrásigényesebb alkalmazásokat szeretnénk futtatni. A 4GB vagy 8GB RAM-mal rendelkező modellek biztosítják a legjobb teljesítményt.
MicroSD kártya: Minimum 16GB, de inkább 32GB vagy 64GB kapacitású, magas írási/olvasási sebességű (Class 10 vagy UHS-I/III) kártya javasolt. Ne feledjük, az SD kártyák korlátozott írási ciklussal rendelkeznek, ami hatással lehet az élettartamukra, ha folyamatosan naplókat írunk rájuk.
Tápegység: A Raspberry Pi modelljének megfelelő, stabil tápegység.
Internetkapcsolat: Vezetékes (Ethernet) kapcsolat javasolt a stabil letöltésekhez, de Wi-Fi is elegendő lehet.
Billentyűzet, egér, monitor (opcionális): Csak a kezdeti beállításhoz lehet rá szükség, utána SSH-n keresztül távolról is kezelhető.
PC/Mac/Linux gép: Az SD kártya előkészítéséhez.

Raspberry Pi OS Előkészítése

A Docker futtatásához javasolt operációs rendszer a Raspberry Pi OS Lite (64-bit). Ez egy minimális disztribúció, grafikus felület nélkül, ami kevesebb erőforrást igényel, így több marad a konténereknek. Használjuk a hivatalos Raspberry Pi Imager eszközt az SD kártya előkészítéséhez:

Töltsük le és telepítsük a Raspberry Pi Imager szoftvert.
Indítsuk el az Imager-t.
Válasszuk ki az „OS” menüpont alatt a Raspberry Pi OS (Other) > Raspberry Pi OS Lite (64-bit) opciót.
Válasszuk ki az SD kártyánkat.
A beállítások menüben (fogaskerék ikon) engedélyezzük az SSH-t, állítsunk be egy felhasználónevet és jelszót, és konfiguráljuk a Wi-Fi-t, ha vezetékes kapcsolatot nem tudunk használni. Adjunk egy statikus IP-címet is, ha lehetséges, ez megkönnyíti a későbbi hozzáférést.
Kattintsunk az „Írás” gombra, és várjuk meg, amíg a folyamat befejeződik.

Miután elkészült az SD kártya, helyezzük be a Raspberry Pi-be, csatlakoztassuk a tápkábelt, és várjuk meg, amíg elindul. Ha beállítottuk az SSH-t, akkor egy másik gépről már csatlakozhatunk hozzá a megadott felhasználónévvel és jelszóval:

ssh felhasználónév@a_pi_ip_címe

Az első lépés a rendszer frissítése:

sudo apt update
sudo apt upgrade -y

Ez eltarthat egy darabig, attól függően, hogy mikor frissítettük utoljára a rendszert. A -y kapcsoló automatikusan elfogadja az összes frissítést.

Docker Telepítése Raspberry Pi-re

A Docker telepítése Raspberry Pi-n rendkívül egyszerű a Docker hivatalos telepítő szkriptjével. Ez a módszer automatikusan felismeri az ARM architektúrát, és telepíti a megfelelő Docker csomagokat.

Töltsük le és futtassuk a telepítő szkriptet:
```
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
```
Ez a parancs letölti a get-docker.sh nevű szkriptet, majd rendszergazdai jogosultságokkal lefuttatja. A szkript elvégzi az összes szükséges lépést a Docker Engine telepítéséhez.
Felhasználó hozzáadása a Docker csoporthoz:
Alapértelmezés szerint a Docker parancsok futtatásához sudo jogosultság szükséges. Ha ezt el szeretnéd kerülni, add hozzá a felhasználódat a docker csoporthoz:
```
sudo usermod -aG docker $USER
```
A változtatások érvényesítéséhez újra be kell jelentkezned, vagy újra kell indítanod a Raspberry Pi-t:
```
newgrp docker
```
vagy
```
sudo reboot
```
Docker telepítésének ellenőrzése:
Futtassuk a híres „hello-world” konténert a telepítés ellenőrzéséhez:
```
docker run hello-world
```
Ha a telepítés sikeres volt, látni fogsz egy üdvözlő üzenetet a Docker-től. Ezen kívül ellenőrizheted a Docker verzióját is:
```
docker version
docker info
```

Az ARM Architektúra és a Docker Képek

Ez az egyik legfontosabb szempont, amit figyelembe kell venni a Raspberry Pi-n futtatott Docker konténerek esetében. A legtöbb asztali számítógép és szerver x86 (vagy x64) architektúrát használ, míg a Raspberry Pi egy ARM alapú processzort tartalmaz. Ez azt jelenti, hogy nem minden Docker kép (image) kompatibilis a Pi-vel.

Hogyan találjunk ARM kompatibilis képeket?

Docker Hub: A Docker Hubon keresve keressük az arm32v7 (32-bites OS esetén, pl. régebbi Raspberry Pi OS verziók), vagy az arm64v8 (64-bites OS esetén, mint a mi általunk telepített Raspberry Pi OS Lite 64-bit) tag-eket. Sok népszerű alkalmazás hivatalos képe már támogatja a több architektúrát (multi-arch), ami azt jelenti, hogy a Docker automatikusan kiválasztja a megfelelő verziót a te rendszeredhez.
Projekt dokumentáció: Gyakran a nyílt forráskódú projektek dokumentációjában, vagy GitHub oldalán is megadják, hogy támogatják-e az ARM architektúrát, és ha igen, milyen image nevet használjunk.
Alternatív képek: Ha egy hivatalos kép nem elérhető ARM-re, keressünk rá a Docker Hubon más felhasználók által készített, megbízható alternatív képekre, pl. linuxserver/plex, balenalib/rpi-raspbian.

Első Docker Konténerek Futtatása

Most, hogy a Docker telepítve van, futtassunk néhány hasznos konténert.

Nginx web szerver

Futtassunk egy egyszerű Nginx web szervert, amely a 80-as porton figyel, és a Raspberry Pi 8080-as portjára továbbítja a kéréseket:

docker run -d -p 8080:80 --name my-nginx nginx:stable-alpine

-d: A konténer a háttérben fut (detached mode).
-p 8080:80: Port mapping. A Raspberry Pi 8080-as portját összeköti a konténer 80-as portjával.
--name my-nginx: Nevet adunk a konténernek, így könnyebben hivatkozhatunk rá.
nginx:stable-alpine: Ez a Docker kép neve. Az alpine verzió kisebb méretű, kevesebb erőforrást fogyaszt.

Ezután a böngésződben navigálj a http://a_pi_ip_címe:8080 címre, és látnod kell az Nginx üdvözlőoldalát.

Pi-hole DNS blokkoló

A Pi-hole egy népszerű hálózati szintű hirdetésblokkoló, amelyet könnyen futtathatsz Docker konténerben:

docker run -d 
    --name pihole 
    -p 53:53/tcp -p 53:53/udp 
    -p 80:80 
    -p 443:443 
    -e TZ="Europe/Budapest" 
    -v "/etc/pihole/:/etc/pihole/" 
    -v "/etc/dnsmasq.d/:/etc/dnsmasq.d/" 
    --dns=127.0.0.1 --dns=1.1.1.1 
    --restart=unless-stopped 
    pihole/pihole:latest

Ez a parancs beállítja a Pi-hole-t, konfigurálja a portokat, a időzónát, és a köteteket (volume) a perzisztens adatok tárolásához. Fontos, hogy a Raspberry Pi 53-as portja szabad legyen, mivel a Pi-hole DNS szerverként fog működni. Ha más szolgáltatás fut rajta, annak portját át kell helyezni, vagy módosítani kell a Pi-hole konfigurációt.

Docker Compose: Több konténeres alkalmazások kezelése

Amikor egy alkalmazás több konténerből áll (pl. egy web szerver, egy adatbázis és egy PHP feldolgozó), a Docker Compose a megoldás. Lehetővé teszi az összes konténer és a köztük lévő kapcsolatok definiálását egyetlen YAML fájlban.

Docker Compose telepítése

A Docker Compose telepítése Raspberry Pi-n manuálisan történik, mivel az apt csomagtárolóban lévő verzió gyakran elavult. A legfrissebb verziót töltsük le a GitHub-ról:

sudo apt install libffi-dev libssl-dev python3 python3-pip -y
sudo pip3 install docker-compose

Ellenőrizzük a telepítést:

docker-compose --version

Docker Compose YAML példa: WordPress

Hozzuk létre egy docker-compose.yml fájlt a WordPress futtatásához (WordPress, Nginx, MySQL):

mkdir wordpress && cd wordpress
nano docker-compose.yml

Illesszük be a következő tartalmat:

version: '3.8'

services:
  wordpress:
    image: wordpress:latest
    ports:
      - "80:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: YOUR_DB_PASSWORD
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wordpress_data:/var/www/html
    restart: unless-stopped

  db:
    image: mariadb:10.5
    environment:
      MYSQL_ROOT_PASSWORD: YOUR_ROOT_PASSWORD
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: YOUR_DB_PASSWORD
    volumes:
      - db_data:/var/lib/mysql
    restart: unless-stopped

volumes:
  wordpress_data:
  db_data:

Fontos: Cseréld le a YOUR_DB_PASSWORD és YOUR_ROOT_PASSWORD értékeket biztonságos jelszavakra!

Indítsuk el az alkalmazást:

docker-compose up -d

Ez letölti a szükséges képeket, létrehozza a konténereket és elindítja azokat. Ezután böngésződben navigálhatsz a Raspberry Pi IP-címére, és befejezheted a WordPress telepítést.

Gyakori Használati Esetek és Projekt Ötletek

A Dockerizált Raspberry Pi rendkívül sokoldalú. Íme néhány népszerű projekt:

Home Assistant: Egy nyílt forráskódú otthoni automatizálási platform, amely központi vezérlőként funkcionál az okosotthon eszközök számára. Kifejezetten népszerű Docker konténerként futtatni.
Plex / Jellyfin média szerver: Hozz létre saját Netflixet! Futtass egy Plex vagy Jellyfin szervert a Pi-n, hogy streameld a médiafájljaidat a hálózatodon lévő eszközökre. Fontos: a hardveres transzkódoláshoz a Pi 4-es modell jobb választás.
AdGuard Home / Pi-hole: Hálózati szintű hirdetésblokkoló és nyomkövetés elleni védelem.
Nextcloud: Saját felhő alapú fájlmegosztó és szinkronizáló szolgáltatás, ami alternatívája a Google Drive-nak vagy Dropboxnak.
Portainer: Egy webes felület a Docker konténerek, képek, volumenek és hálózatok egyszerű menedzseléséhez. Erősen ajánlott!
Webszerver / Fejlesztői környezet: Futtass Nginx, Apache, PHP, Node.js, Python alkalmazásokat egyedi fejlesztési környezetekben.

Optimalizáció és Karbantartás

A Raspberry Pi erőforrásai korlátozottak, ezért érdemes optimalizálni a Docker használatát:

SD kártya kímélése: Az SD kártyák írási ciklusai korlátozottak. A folyamatos naplózás és adatáramlás gyorsan tönkreteheti őket.
- Külső tároló: Használj USB-s SSD-t vagy HDD-t a Docker volumenek (-v kapcsolóval létrehozott adatkönyvtárak) tárolására. Ez jelentősen növeli a rendszer élettartamát és a sebességét.
- Naplózás korlátozása: Korlátozd a konténer naplófájlok méretét a docker run parancsban vagy a docker-compose.yml fájlban:
```
logging:
    options:
        max-size: "10m"
        max-file: "3"
```
Rendszeres takarítás:
- Töröld a felesleges, nem használt képeket, konténereket és volumeneket:
```
docker system prune -a
```
  Figyelem: Ez minden nem használt Docker erőforrást töröl! Légy óvatos vele.
Konténer frissítés automatizálása: A Watchtower egy Docker konténer, amely figyeli a futó konténereket, és automatikusan frissíti őket, ha új képverzió érhető el a Docker Hubon.
```
docker run -d 
        --name watchtower 
        -v /var/run/docker.sock:/var/run/docker.sock 
        containrrr/watchtower 
        --cleanup --interval 300
```
Ez 5 percenként (300 másodperc) ellenőrzi a frissítéseket és törli a régi képeket.
Erőforrás figyelés: Használd a docker stats parancsot a futó konténerek CPU, RAM és hálózati erőforrás-használatának valós idejű figyeléséhez.

Gyakori Hibaelhárítás

„exec format error” / „no matching manifest for linux/arm/v7 in the manifest list entries”: Ez azt jelenti, hogy a letölteni próbált Docker kép nem kompatibilis az ARM architektúrával. Keresd meg a megfelelő ARM verziót (pl. :arm64v8 taggel).
„Error starting userland proxy: listen tcp 0.0.0.0:80: bind: address already in use”: A megadott port már foglalt a Raspberry Pi-n. Vagy változtasd meg a konténer portját (pl. -p 8080:80 helyett -p 9000:80), vagy állítsd le a portot használó szolgáltatást.
„No space left on device”: Elfogyott a hely az SD kártyán. Futtasd a docker system prune -a parancsot, vagy helyezz át volumeneket külső tárolóra.
Lassú teljesítmény: Lehet, hogy kevés a RAM, vagy a CPU túlterhelt. Figyeld a docker stats kimenetét, és fontold meg egy erősebb Raspberry Pi modell (pl. Pi 4 8GB) beszerzését, vagy kevesebb konténer futtatását.

Összefoglalás

Gratulálunk! Most már készen állsz arra, hogy a Raspberry Pi-det egy sokoldalú és hatékony mini szerverré alakítsd a Docker erejével. Ahogy láthatod, a konténerek futtatása a Pi-n nem csak egyszerű, de rengeteg lehetőséget is megnyit az otthoni automatizálás, a médiafogyasztás, a fejlesztés és az IoT projektek terén. Kísérletezz bátran, fedezd fel a Docker Hub széles kínálatát, és építsd meg a saját, egyedi otthoni infrastruktúrádat. A Raspberry Pi és a Docker kombinációja valóban egy apró, de annál erősebb csoda, ami a kreatív megoldások tárháza!