Docker konténerek bevezetése és gyakorlati alkalmazása

Bevezetés

A konténerizáció napjainkban az egyik legfontosabb technológiai trend az alkalmazásfejlesztés és -üzemeltetés területén. A Docker megjelenésével a konténerek használata széles körben elterjedt, jelentősen megváltoztatva az alkalmazások fejlesztési, tesztelési és telepítési folyamatait. Ez a cikk bemutatja a Docker alapjait, előnyeit és gyakorlati alkalmazási lehetőségeit különböző szituációkban.

Mi az a konténerizáció és a Docker?

Konténerizáció alapelvei

A konténerizáció egy szoftverek izolált futtatására szolgáló módszer, amely a virtualizáció egy könnyebb alternatívája. Míg a hagyományos virtualizáció esetén minden virtuális gép (VM) tartalmazza a teljes operációs rendszert és az összes hozzá tartozó komponenst, addig a konténerek osztoznak a gazda operációs rendszer kernelén, és csak az alkalmazás futtatásához szükséges fájlokat és függőségeket tartalmazzák.

Docker vs. hagyományos virtualizáció

A Docker architektúrája

A Docker ökoszisztéma főbb komponensei:

1. Docker Engine: A konténerek létrehozásáért és futtatásáért felelős rendszer
2. Docker Client: Parancssori felület a Docker Engine vezérléséhez
3. Docker Registry: Tároló a Docker image-eknek (pl. Docker Hub)
4. Docker Compose: Eszköz több konténeres alkalmazások definiálására és futtatására
5. Docker Swarm/Kubernetes: Konténer-orchestráció (több gép kezelése)

A Docker előnyei és használati esetei

Főbb előnyök

1. Konzisztens környezet: "Ha nálam működik, akkor mindenhol működni fog"
2. Erőforrás-hatékonyság: Kisebb erőforrás-igény a hagyományos virtualizációhoz képest
3. Gyors telepítés és skálázás: Másodpercek alatt indítható új példányok
4. Izoláció: Alkalmazások és függőségeik elkülönítve futnak
5. Verziókezelés: Az image-ek verziókezelhetők, visszaállíthatók
6. Infrastruktúra mint kód: A környezet konfigurációja kód formájában definiálható

Gyakorlati használati esetek

• Fejlesztői környezetek standardizálása: Minden fejlesztő azonos környezetben dolgozik
• CI/CD pipeline-ok: Automatizált tesztelés és telepítés
• Mikroszolgáltatások architektúra: Szolgáltatások izolált futtatása és skálázása
• Legacy alkalmazások izolálása: Régi, specifikus környezetet igénylő alkalmazások biztonságos futtatása
• Több klienses (multi-tenant) alkalmazások: Ügyfelek adatainak és alkalmazásainak elkülönítése

Docker alapok - Telepítés és első lépések

Docker telepítése Linux rendszeren

Ubuntu/Debian:

# Függőségek telepítése
sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

# 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

# Repository hozzáadása
echo "deb [arch=amd64 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

# Docker Engine telepítése
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

CentOS/RHEL:

# Függőségek telepítése
sudo yum install -y yum-utils

# Repository hozzáadása
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# Docker Engine telepítése
sudo yum install docker-ce docker-ce-cli containerd.io

Docker szolgáltatás indítása és engedélyezése

sudo systemctl start docker
sudo systemctl enable docker

Non-root felhasználó hozzáadása a docker csoporthoz

sudo usermod -aG docker $USER
# Jelentkezzünk ki és be a változtatások érvényesítéséhez

Docker Compose telepítése

sudo curl -L "https://github.com/docker/compose/releases/download/v2.18.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Docker verzió ellenőrzése

docker --version
docker-compose --version

Első Docker konténer futtatása

# "Hello World" konténer futtatása
docker run hello-world

# Interaktív Ubuntu konténer indítása
docker run -it ubuntu bash

Docker képek és konténerek kezelése

Alapvető Docker parancsok

Képek kezelése

# Képek keresése a Docker Hub-on
docker search nginx

# Kép letöltése (pull)
docker pull nginx:latest

# Elérhető képek listázása
docker images

# Kép törlése
docker rmi nginx:latest

Konténerek kezelése

# Konténer futtatása
docker run --name my-nginx -d -p 8080:80 nginx

# Futó konténerek listázása
docker ps

# Összes konténer listázása (futó és leállított)
docker ps -a

# Konténer leállítása
docker stop my-nginx

# Konténer újraindítása
docker restart my-nginx

# Konténer naplóinak megtekintése
docker logs my-nginx

# Konténer törlése
docker rm my-nginx

Konténerrel való interakció

# Parancs futtatása futó konténerben
docker exec -it my-nginx bash

# Fájl másolása a konténerbe
docker cp index.html my-nginx:/usr/share/nginx/html/

# Fájl másolása a konténerből
docker cp my-nginx:/etc/nginx/nginx.conf ./nginx.conf

Dockerfile készítése - Saját image építése

A Dockerfile egy szöveges fájl, amely lépésről lépésre leírja, hogyan kell felépíteni egy Docker image-et. Alább egy egyszerű példa egy Node.js alkalmazáshoz:

Példa Dockerfile

# Alap image meghatározása
FROM node:18-alpine

# Munkakönyvtár beállítása
WORKDIR /app

# Függőségek másolása és telepítése
COPY package*.json ./
RUN npm install

# Alkalmazás forráskódjának másolása
COPY . .

# Port megnyitása
EXPOSE 3000

# Indítási parancs meghatározása
CMD ["node", "app.js"]

Image építése és publikálása

# Image építése
docker build -t myapp:1.0 .

# Image taggelése a registry számára
docker tag myapp:1.0 username/myapp:1.0

# Image feltöltése a Docker Hub-ra
docker login
docker push username/myapp:1.0

Dockerfile legjobb gyakorlatok

1. Többszakaszos build használata a kisebb végeredmény érdekében
2. .dockerignore fájl használata a nem szükséges fájlok kizárására
3. Minimális base image választása (Alpine vagy Slim variánsok)
4. Rétegek számának minimalizálása (RUN parancsok összevonása)
5. Non-root felhasználó használata a konténeren belül
6. Verziók explicit megadása a reprodukálhatóság érdekében

Többszakaszos build példa

# Build szakasz
FROM node:18-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Futtatási szakasz
FROM nginx:alpine
COPY --from=build /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Docker hálózatok és adatkezelés

Docker hálózatok típusai

A Docker öt hálózati meghajtót kínál alapértelmezetten:

1. bridge: Alapértelmezett hálózat, konténerek közötti kommunikációhoz
2. host: A konténer a host hálózati stackjét használja
3. none: Nincs hálózati kapcsolat
4. overlay: Konténerek közötti kommunikáció több Docker hoston át
5. macvlan: Közvetlen MAC cím hozzárendelés a konténerekhez

Hálózatok kezelése

# Hálózatok listázása
docker network ls

# Egyedi hálózat létrehozása
docker network create my-network

# Konténer csatlakoztatása hálózathoz
docker run --network=my-network --name db -d mongo

# Konténer információk lekérdezése
docker inspect db

Adatkezelés és perzisztencia

Docker három lehetőséget kínál az adatok tárolására:

1. Volumes: Docker által kezelt adattárolók
2. Bind mounts: A host rendszer könyvtárainak csatolása a konténerbe
3. tmpfs mounts: Csak memóriában létező tárolók

Volume-ok kezelése

# Volume létrehozása
docker volume create my-data

# Volume-ok listázása
docker volume ls

# Konténer indítása volume használatával
docker run -d --name mysql -v my-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=secret mysql:8

# Volume vizsgálata
docker volume inspect my-data

# Nem használt volume-ok törlése
docker volume prune

Bind mount használata

# Host könyvtár csatolása
docker run -d --name nginx -p 8080:80 -v $(pwd)/html:/usr/share/nginx/html nginx

Docker Compose - Több konténeres alkalmazások

A Docker Compose egy eszköz, amellyel több konténeres alkalmazások definiálhatók és indíthatók egyetlen YAML fájl segítségével.

Példa docker-compose.yml fájl

version: '3.8'

services:
  webapp:
    build: ./webapp
    ports:
      - "8080:80"
    depends_on:
      - db
    environment:
      - DB_HOST=db
      - DB_USER=postgres
      - DB_PASSWORD=secret
      - DB_NAME=myapp
    networks:
      - app-network

  db:
    image: postgres:14
    volumes:
      - db-data:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=secret
      - POSTGRES_USER=postgres
      - POSTGRES_DB=myapp
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

volumes:
  db-data:

Docker Compose parancsok

# Szolgáltatások indítása
docker-compose up -d

# Szolgáltatások állapotának ellenőrzése
docker-compose ps

# Naplók megtekintése
docker-compose logs

# Szolgáltatások leállítása
docker-compose down

# Szolgáltatások leállítása és kötetek törlése
docker-compose down -v

Docker biztonság és legjobb gyakorlatok

Biztonsági alapelvek

1. Minimális base image: Alpine vagy distroless image-ek használata
2. Rendszeres frissítés: Biztonsági patch-ek telepítése
3. Non-root felhasználó: Konténerek futtatása privilegizálatlan felhasználóként
4. Képek szkennelése: Ismert sebezhetőségek ellenőrzése (Trivy, Clair)
5. Secrets kezelése: Érzékeny adatok biztonságos kezelése
6. Erőforrás-korlátok: CPU és memória limitek beállítása

Biztonsági konfiguráció példák

Non-root felhasználó használata

FROM node:18-alpine

# Új felhasználó létrehozása
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

# Munkakönyvtár beállítása és jogosultságok
WORKDIR /app
COPY --chown=appuser:appgroup . .

# Non-root felhasználóra váltás
USER appuser

CMD ["node", "app.js"]

Konténer korlátozások

# Erőforrás-korlátok beállítása
docker run -d --name api \
  --memory="512m" \
  --cpus="0.5" \
  --pids-limit=100 \
  myapp:latest

Docker Bench Security

A Docker Bench Security egy szkript, amely ellenőrzi a Docker telepítés biztonsági beállításait:

docker run -it --net host --pid host --userns host --cap-add audit_control \
    -v /var/lib:/var/lib \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v /usr/lib/systemd:/usr/lib/systemd \
    -v /etc:/etc --label docker_bench_security \
    docker/docker-bench-security

Gyakorlati példák

1. LAMP Stack telepítése Docker Compose-zal

version: '3.8'

services:
  web:
    image: php:8.1-apache
    ports:
      - "80:80"
    volumes:
      - ./www:/var/www/html
    depends_on:
      - db
    networks:
      - lamp-network

  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: mydb
      MYSQL_USER: user
      MYSQL_PASSWORD: userpass
    volumes:
      - db-data:/var/lib/mysql
    networks:
      - lamp-network

  phpmyadmin:
    image: phpmyadmin/phpmyadmin
    ports:
      - "8080:80"
    environment:
      PMA_HOST: db
      PMA_USER: root
      PMA_PASSWORD: rootpass
    depends_on:
      - db
    networks:
      - lamp-network

networks:
  lamp-network:

volumes:
  db-data:

2. Node.js alkalmazás fejlesztési környezete

Dockerfile.dev:

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm install

EXPOSE 3000

CMD ["npm", "run", "dev"]

docker-compose.dev.yml:

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.dev
    ports:
      - "3000:3000"
    volumes:
      - ./:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development

3. CI/CD pipeline Docker image-dzsel

.gitlab-ci.yml példa:

stages:
  - build
  - test
  - deploy

build:
  stage: build
  image: docker:20.10
  services:
    - docker:20.10-dind
  script:
    - docker build -t myapp:$CI_COMMIT_SHORT_SHA .
    - docker save myapp:$CI_COMMIT_SHORT_SHA -o image.tar
  artifacts:
    paths:
      - image.tar

test:
  stage: test
  image: docker:20.10
  services:
    - docker:20.10-dind
  script:
    - docker load -i image.tar
    - docker run myapp:$CI_COMMIT_SHORT_SHA npm test

deploy:
  stage: deploy
  image: docker:20.10
  services:
    - docker:20.10-dind
  script:
    - docker load -i image.tar
    - docker tag myapp:$CI_COMMIT_SHORT_SHA registry.example.com/myapp:$CI_COMMIT_SHORT_SHA
    - docker push registry.example.com/myapp:$CI_COMMIT_SHORT_SHA

Összefoglalás és további lépések

A Docker konténerizáció alapjaiban változtatta meg az alkalmazásfejlesztés és -üzemeltetés módját. Előnyei közé tartozik a környezetek konzisztenciája, a gyors telepítés és skálázás, valamint az infrastruktúra kódként való kezelhetősége.

Ebben a cikkben megismertük:

• A Docker alapjait és architektúráját
• A Docker képek és konténerek kezelését
• Saját Docker image-ek építését Dockerfile segítségével
• A Docker hálózatokat és adatkezelési megoldásokat
• A Docker Compose használatát több konténeres alkalmazások kezeléséhez
• A Docker biztonsági legjobb gyakorlatait
• Gyakorlati példákat különböző használati esetekre

További lépések a Docker utazásban

1. Container orchestration megismerése (Kubernetes, Docker Swarm)
2. CI/CD pipeline-ok integrálása Docker-rel
3. Monitoring és naplózás megoldások konténerizált környezetben
4. Docker registry üzemeltetése privát használatra
5. Konténer biztonság mélyebb megismerése

Hasznos források

• Docker hivatalos dokumentáció
• Docker Hub - Hivatalos és közösségi Docker image-ek
• Awesome Docker - Hasznos Docker eszközök és források gyűjteménye
• Play with Docker - Ingyenes online Docker környezet gyakorláshoz

A konténerizáció technológiája folyamatosan fejlődik, ezért érdemes naprakésznek maradni a legújabb trendekkel és gyakorlatokkal kapcsolatban. A Docker elsajátítása nemcsak hasznos készség, hanem fontos lépcső a modern, felhő-natív alkalmazásfejlesztés és -üzemeltetés irányába.