A Docker konténerek használatának alapjai Linuxon

Üdvözöljük a jövő szoftverfejlesztésében és üzemeltetésében! A modern IT világban, ahol a gyorsaság, a megbízhatóság és a skálázhatóság kulcsfontosságú, egyre nagyobb szerepet kapnak a konténer-technológiák. Ezek közül kiemelkedik a Docker, amely forradalmasította az alkalmazások csomagolását, szállítását és futtatását. Ha valaha is szembesült azzal a problémával, hogy „nálam működött”, akkor pontosan tudja, milyen frusztráló lehet a környezeti eltérésekből adódó hibakeresés. A Docker erre kínál elegáns megoldást.

Ebben az átfogó útmutatóban lépésről lépésre végigvezetjük a Docker alapjain, különös tekintettel a Linux operációs rendszerre. Megtanulja, hogyan telepítse, hogyan kezelje a konténereket, hogyan tárolja az adatokat, és hogyan építsen saját alkalmazásokat a Docker erejével. Készüljön fel, hogy belevágjon egy izgalmas utazásba, amely megváltoztatja a szoftverekről alkotott képét!

Mi az a Docker és miért van rá szükségünk?

A Docker egy nyílt forráskódú platform, amely lehetővé teszi az alkalmazások és azok függőségeinek konténerekbe való csomagolását. De mit is jelent ez pontosan? Képzeljen el egy konténert, mint egy szabványosított, önálló szállítási egységet, amely tartalmazza az alkalmazáshoz szükséges mindent: a kódot, a futásidejű környezetet (runtime), a rendszereszközöket, a könyvtárakat és a konfigurációkat. Ennek eredményeként az alkalmazás bármilyen környezetben pontosan ugyanúgy fog futni, legyen szó fejlesztői gépről, tesztszerverről vagy éles rendszerről. Ez a portabilitás a Docker egyik legfőbb előnye.

A konténerek emellett elkülönítettek is. Ez azt jelenti, hogy minden konténer a saját környezetében fut, anélkül, hogy befolyásolná a gazdagép operációs rendszerét vagy más konténereket. Ez növeli a biztonságot és megakadályozza a függőségi konfliktusokat. Végül, a konténerek rendkívül könnyűek és hatékonyak. A virtuális gépekkel ellentétben nem tartalmaznak teljes operációs rendszert, csak azt, ami az alkalmazás futtatásához feltétlenül szükséges, így sokkal gyorsabban indulnak és kevesebb erőforrást igényelnek.

Konténer vs. Virtuális gép: A különbség megértése

A Docker konténerek és a virtuális gépek (VM-ek) gyakran összehasonlításra kerülnek, mivel mindkettő izolált környezetet biztosít az alkalmazások futtatásához. Azonban alapvető különbségek vannak közöttük:

Virtuális gép: Egy VM egy teljes operációs rendszert (pl. Windows, Linux disztribúció) futtat a gazdagép operációs rendszerének tetején egy hipervizor (pl. VMware, VirtualBox) segítségével. Minden VM-nek saját kernelje, bináris fájljai és könyvtárai vannak. Ez nagyobb erőforrás-igényt jelent (CPU, RAM, tárhely) és lassabb indítási időt.
Konténer: Egy konténer megosztja a gazdagép operációs rendszerének kerneljét, és csak az alkalmazáshoz szükséges bináris fájlokat és könyvtárakat tartalmazza. Ezért sokkal könnyebb, gyorsabb az indítása és kevesebb erőforrást fogyaszt. A konténerek a Docker motor (daemon) segítségével futnak a gazdagép operációs rendszerén.

Röviden: a VM a hardvert virtualizálja, míg a konténer az operációs rendszert. A konténerek sokkal hatékonyabbak a modern, mikroszolgáltatás alapú architektúrákhoz.

A Docker alapismeretei: Image és Container

Mielőtt belevágunk a gyakorlatba, tisztázzuk a két legfontosabb fogalmat:

Image (kép): A Docker image (kép) egy olvasható, futtatható csomag, amely tartalmazza az alkalmazás futtatásához szükséges összes kódot, könyvtárat, függőséget és konfigurációs fájlt. Gondoljunk rá úgy, mint egy alkalmazás tervrajzára vagy sablonjára. Az image-ek statikusak, és a Docker Hub-ról (egy online tároló) tölthetők le, vagy saját magunk építhetjük őket Dockerfile segítségével.
Container (konténer): A Docker konténer egy image futó példánya. Amikor futtatunk egy image-t, az egy konténerként életre kel. Képzeljük el úgy, mint egy tervrajz alapján épített házat. A konténer dinamikus, interaktív, és elindítható, leállítható, újraindítható, törölhető.

Docker telepítése Linuxra

A Docker telepítése Linuxon viszonylag egyszerű. Az alábbi lépések a Debian/Ubuntu alapú rendszerekre vonatkoznak, de a legtöbb disztribúción hasonló a folyamat.

1. Rendszerfrissítés és előfeltételek telepítése

sudo apt update
sudo apt upgrade -y
sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release -y

2. Docker GPG kulcs hozzáadása

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

3. Docker tároló hozzáadása a forrásokhoz

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

4. Docker telepítése

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io -y

5. Docker szolgáltatás ellenőrzése

A telepítés után a Docker szolgáltatásnak automatikusan el kell indulnia. Ellenőrizze a státuszát:

sudo systemctl status docker

Ha fut, akkor valami hasonló üzenetet lát: „Active: active (running)”.

6. Docker futtatása sudo nélkül (opcionális, de ajánlott fejlesztéshez)

Alapértelmezés szerint a Docker parancsokat sudo-val kell futtatni. Ahhoz, hogy ezt elkerülje, adja hozzá a felhasználóját a docker csoporthoz:

sudo usermod -aG docker $USER

A változtatások érvényesüléséhez jelentkezzen ki, majd be, vagy indítsa újra a terminált.

Ezután tesztelje a telepítést egy „hello-world” konténer futtatásával:

docker run hello-world

Ha sikeresen telepítette, egy üdvözlő üzenetet kell kapnia a terminálban.

Alapvető Docker parancsok

Most, hogy telepítve van a Docker, ismerkedjünk meg a legfontosabb parancsokkal.

Konténer életciklus-kezelés

docker pull <image_név>: Letölt egy image-t a Docker Hub-ról.
```
docker pull ubuntu
```
docker run <image_név>: Létrehoz és elindít egy konténert egy adott image-ből.
- -d (detached mode): A konténer a háttérben fut.
- -p <gazda_port>:<konténer_port>: Port átirányítás.
- --name <konténer_név>: Egyedi név adása a konténernek.
- -it (interactive, tty): Interaktív shell-t nyit a konténerben.
- --rm: A konténer automatikusan törlődik, amikor leáll.
```
docker run -d -p 80:80 --name mynginx nginx
docker run -it --rm ubuntu bash
```
docker ps: Listázza a futó konténereket. A -a opcióval az összes (futó és leállított) konténert láthatja.
```
docker ps
docker ps -a
```
docker stop <konténer_név_vagy_ID>: Leállít egy futó konténert.
```
docker stop mynginx
```
docker start <konténer_név_vagy_ID>: Elindít egy leállított konténert.
```
docker start mynginx
```
docker restart <konténer_név_vagy_ID>: Újraindít egy konténert.
```
docker restart mynginx
```
docker rm <konténer_név_vagy_ID>: Töröl egy leállított konténert. Futó konténert csak a -f (force) opcióval lehet törölni, de ez nem ajánlott.
```
docker rm mynginx
```

Image-kezelés

docker images: Listázza a helyben lévő Docker image-eket.
```
docker images
```
docker rmi <image_név_vagy_ID>: Töröl egy image-t. Ügyeljen arra, hogy a törölni kívánt image-ből ne fusson konténer.
```
docker rmi nginx
```

Konténer interakció és diagnosztika

docker exec -it <konténer_név_vagy_ID> <parancs>: Parancsot futtat egy már futó konténerben. Gyakran használják shell indítására.
```
docker exec -it mynginx bash
```
docker logs <konténer_név_vagy_ID>: Megjeleníti a konténer logjait. A -f (follow) opcióval valós időben követheti a logokat.
```
docker logs mynginx
docker logs -f mynginx
```

Adatkezelés: A Volume-ok szerepe

A Docker konténerek alapértelmezés szerint „állapot nélküliek” (stateless) és efemer (átmeneti) jellegűek. Ez azt jelenti, hogy ha egy konténer leáll vagy törlődik, minden adat, ami a konténer fájlrendszerében tárolódott, elveszik. Ez nem ideális adatbázisokhoz, logokhoz vagy bármilyen perzisztens adathoz. Itt jönnek képbe a Docker Volume-ok.

A Volume-ok lehetővé teszik, hogy a konténeren kívül tároljunk adatokat, a gazdagép fájlrendszerén, így az adatok megmaradnak, függetlenül a konténer életciklusától. Két fő típusuk van:

Bind Mounts: Ebben az esetben a gazdagép operációs rendszerének egy konkrét könyvtárát vagy fájlját csatoljuk a konténeren belülre. Ez rendkívül rugalmas, és gyakran használják fejlesztéskor forráskódok megosztására.
```
docker run -d -p 80:80 --name mynginx -v /home/user/myweb:/usr/share/nginx/html nginx
```
Ez a parancs a gazdagép /home/user/myweb könyvtárát a Nginx konténer /usr/share/nginx/html könyvtárához csatolja, így a weboldal fájljai a gazdagépen maradnak.
Named Volumes: Ezeket a Docker maga kezeli a gazdagépen. A Docker létrehozza és kezeli a volume-ot, és Ön csak a nevére hivatkozik. Ez jobb hordozhatóságot és biztonságot nyújt, és ajánlott a legtöbb perzisztens adat tárolására.
```
docker volume create mydata
docker run -d --name mydb -v mydata:/var/lib/mysql mysql
```
Itt létrehoztunk egy mydata nevű volume-ot, majd csatoltuk azt egy MySQL konténer adatkönyvtárához.

Hálózatkezelés: Konténerek kommunikációja

A Docker beépített hálózati képességekkel rendelkezik, amelyek lehetővé teszik a konténerek egymás közötti, valamint a külvilággal való kommunikációját. A leggyakrabban használt hálózati mód a „bridge” (híd) hálózat, amely alapértelmezett. Amikor egy konténer elindul, egy virtuális hálózati interfészt kap, és csatlakozik a Docker alapértelmezett bridge hálózatához.

Port Mapping (`-p`): Ahogy már láttuk, a -p opcióval publikálhatjuk a konténer portjait a gazdagép portjaira. Ez teszi lehetővé, hogy a külvilág elérje a konténerben futó alkalmazást.
```
docker run -d -p 8080:80 --name webapp my-web-app
```
Ez a konténer 80-as portját a gazdagép 8080-as portjára képezi le.
Konténerek közötti kommunikáció: Egyedi, felhasználó által definiált bridge hálózatok létrehozásával a konténerek nevük alapján kommunikálhatnak egymással, ahelyett, hogy IP-címeket kellene használniuk.
```
docker network create my-app-network
docker run -d --name db --network my-app-network mysql
docker run -d --name app --network my-app-network --env DB_HOST=db my-web-app
```
Ebben a példában az app konténer a db konténert a db névvel éri el.

Saját képek készítése: Dockerfile alapok

Bár sok előre elkészített image elérhető a Docker Hub-on, gyakran szükség van saját, testreszabott image-ek létrehozására. Ezt a Dockerfile segítségével tehetjük meg, amely egy szöveges fájl, és lépésről lépésre tartalmazza az image felépítésének utasításait.

Nézzünk meg egy egyszerű Dockerfile példát egy Node.js alkalmazáshoz:

# Egy alap image, ahonnan indulunk
FROM node:16-alpine

# A konténeren belüli munkakönyvtár beállítása
WORKDIR /app

# A helyi alkalmazásfájlok másolása a konténerbe
COPY package*.json ./
RUN npm install

COPY . .

# A konténeren belüli port, amelyet az alkalmazás használ
EXPOSE 3000

# Parancs, amely a konténer indulásakor fut le
CMD ["npm", "start"]

Néhány alapvető Dockerfile utasítás:

FROM <image>: Az image alapját adó alapképet határozza meg.
WORKDIR <path>: Beállítja az aktuális munkakönyvtárat a konténeren belül.
COPY <forrás> <cél>: Fájlokat vagy könyvtárakat másol a gazdagépről a konténer fájlrendszerébe.
RUN <parancs>: Parancsokat futtat az image építési fázisában (pl. függőségek telepítése).
CMD ["parancs", "paraméter"]: Meghatározza az alapértelmezett parancsot, amely a konténer elindulásakor fut le. Csak egy CMD lehet egy Dockerfile-ban.
EXPOSE <port>: Információt ad a Docker-nek, hogy a konténer mely portokat szándékozik használni. Nem publikálja a portot!

Az image építéséhez navigáljon abba a könyvtárba, ahol a Dockerfile található, majd futtassa:

docker build -t my-node-app .

A -t opcióval adhatunk nevet és tag-et (címkét) az image-nek. A . (pont) jelzi, hogy a Dockerfile az aktuális könyvtárban található.

Többkonténeres alkalmazások: Docker Compose bevezetés

A valós alkalmazások ritkán állnak egyetlen konténerből. Gyakran van szükség adatbázisra, gyorsítótárra, API szolgáltatásra és webes felületre, mindezek külön konténerekben. A Docker Compose egy eszköz, amely lehetővé teszi, hogy több Docker konténerből álló alkalmazásokat definiáljunk és futtassunk egyetlen YAML fájl segítségével.

Létrehozunk egy docker-compose.yml nevű fájlt az alkalmazás gyökérkönyvtárában:

version: '3.8'
services:
  web:
    build: .
    ports:
      - "80:3000"
    depends_on:
      - db
  db:
    image: postgres:13
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Ez a fájl két szolgáltatást definiál:

web: A webes alkalmazásunk, amely az aktuális könyvtárból épül fel. A 80-as portot átirányítja a 3000-esre, és függ a db szolgáltatástól.
db: Egy PostgreSQL adatbázis konténer, amelyhez volume-ot is csatolunk az adatok perzisztens tárolásához.

Az alkalmazás indításához navigáljon a docker-compose.yml fájlt tartalmazó könyvtárba, és futtassa:

docker compose up -d

A -d opcióval a háttérben futtatja a konténereket. Az alkalmazás leállításához:

docker compose down

A Docker Compose drasztikusan leegyszerűsíti a komplex, többkonténeres alkalmazások fejlesztését és üzembe helyezését.

Gyakori problémák és tippek

Engedélyek (`sudo`): Ha folyamatosan sudo-t kell használnia a Docker parancsokhoz, győződjön meg róla, hogy hozzáadta a felhasználóját a docker csoporthoz, és újraindította a terminált.
Lemezterület kezelése: A Docker image-ek és konténerek sok helyet foglalhatnak. Rendszeresen tisztítsa meg a nem használt objektumokat:
```
docker system prune -a
```
Ez törli az összes leállított konténert, nem használt hálózatot, image-et (amelyhez nincs konténer), és build cache-t.
Portkonfliktusok: Győződjön meg róla, hogy a publikált portok nem ütköznek más futó szolgáltatásokkal a gazdagépen.
Logok ellenőrzése: Ha egy konténer nem működik megfelelően, az első lépés mindig a logok ellenőrzése a docker logs <konténer_név> paranccsal.

Konklúzió: A Docker jövője a Linuxon

A Docker alapjainak elsajátítása kulcsfontosságú lépés a modern szoftverfejlesztés és az DevOps gyakorlatok felé vezető úton. A Linux platformmal való szinergiája páratlan teljesítményt és rugalmasságot biztosít. A konténerek nem csak a fejlesztők életét könnyítik meg az „úgy működik nálam” probléma kiküszöbölésével, hanem az üzemeltetők számára is felgyorsítják a telepítést, a skálázást és a hibakeresést.

Ez az útmutató csak a jéghegy csúcsa volt. A Docker ökoszisztémája hatalmas és folyamatosan fejlődik, olyan eszközökkel, mint a Docker Swarm vagy a Kubernetes, amelyek a konténerek nagy léptékű orchestrálására szolgálnak. Azonban az itt megszerzett alapok szilárd alapot biztosítanak ahhoz, hogy tovább mélyedjen a konténer-technológiák világába.

Reméljük, hogy ez a cikk segített megérteni a Docker konténerek működését és elindult a Linux alapú konténerizálás útján. Kezdjen el kísérletezni, építsen saját image-eket, és fedezze fel a Docker által nyújtott számtalan lehetőséget. A jövő már konténerben van!