A Docker alapból parancssorból kezelhető: docker ps, docker compose up -d, docker logs. Ha egy szerveren több alkalmazás fut konténerben, sokan kényelmesebbnek találják, ha a konténereket, a naplókat és a Compose-fájlokat böngészőből látják és szerkesztik. Erre három népszerű, saját szerverre telepíthető eszköz van:

• Portainer CE: általános Docker-kezelő felület. Konténerek, képek, kötetek, hálózatok és Compose stackek egy helyen.
• Dockge: kis, egyszerű felület kifejezetten Docker Compose stackekhez. A Compose-fájlok a lemezen maradnak, a parancssorból ugyanúgy kezelhetők.
• Coolify: saját szerveren futó PaaS (a Heroku, a Vercel vagy a Netlify mintájára). Git-tárolóból épít és telepít alkalmazásokat, adatbázisokat indít, domaint és HTTPS-t állít be.

Mindhárom egy Linuxos KVM VPS-en is jól használható. A Portainerhez és a Dockge-hoz előbb a Dockert kell telepíteni (lásd: Docker telepítése Ubuntu, Debian és AlmaLinux rendszerre), a Coolify a sajátját telepíti. A Compose-fájlok felépítését a Docker Compose használata cikk mutatja be.

A lépéseket 2026 novemberében Ubuntu 24.04 rendszerű, x86_64-es virtuális gépeken próbáltuk ki, Docker Engine 29.9.3 és Docker Compose 5.7.0 alatt, a Portainer CE 2.45.3 LTS, a Dockge 1.5.0 és a Coolify 4.6.0 változatával. A parancsokat sudo-val vagy root felhasználóként futtasd.

Mikor segít egy webes felület, és mikor kockázat?

Hasznos, ha:

• több Compose-alkalmazás fut a szerveren, és gyorsan szeretnéd látni, melyik fut, melyik állt le, mennyi memóriát használ;
• a naplókat, a konténer konzolját vagy egy Compose-fájl szerkesztését böngészőből szeretnéd elérni;
• olyan kolléga is kezeli a szervert, aki nem mozog otthonosan a parancssorban;
• Git-tárolóból automatikusan szeretnél telepíteni (ez a Coolify terepe).

Kockázat, mert:

• a Docker socket root hozzáférés. Mindhárom eszköz a /var/run/docker.sock fájlon keresztül vezérli a Dockert. Aki a felületre bejut, olyan konténert indíthat, amely a szerver teljes fájlrendszerét csatolja, vagyis gyakorlatilag root jogot kap a szerveren. Egy gyenge jelszavú, interneten nyitott Portainer vagy Dockge ugyanolyan veszélyes, mint egy jelszó nélküli root SSH;
• a Docker megkerüli a tűzfalat. A közzétett portokat (-p 9443:9443) a Docker saját iptables-szabályokkal nyitja meg. A teszten bekapcsolt ufw mellett (csak az SSH engedélyezve) a Portainer 9443-as és a Dockge 5001-es portja kívülről is elérhető maradt, a 127.0.0.1-re kötött portok viszont nem. Részletek: Hogyan állítsak be tűzfalat a VPS-emen?;
• az első belépő lesz a rendszergazda. Mindhárom eszköz az első megnyitáskor hozza létre a rendszergazdát, és aki ezt megelőzi, átveszi a szervert. Ezért telepítés után azonnal hozd létre a fiókot.

Ha csak egy-két konténert futtatsz, és elboldogulsz a parancssorral, nincs szükséged webes felületre: kevesebb futó szolgáltatás, kevesebb támadási felület.

Összehasonlítás

	Portainer CE	Dockge	Coolify
Mi ez?	Általános Docker-kezelő	Compose stack-kezelő	Saját szerveres PaaS
Licenc	zlib (nyílt forrású); a Business Edition fizetős	MIT	Apache 2.0
Memóriahasználat a teszten	kb. 25 MB	kb. 135 MB	kb. 500 MB (Coolify, PostgreSQL, Redis, Traefik, Sentinel)
Gépigény	Bármely VPS, amelyen fut a Docker	Bármely VPS, amelyen fut a Docker	A dokumentáció szerint legalább 2 CPU mag, 2 GB RAM; a telepítő 30 GB lemez alatt figyelmeztet
Portok	9443 (HTTPS), 8000 (Edge ügynökök, elhagyható)	5001 (HTTP)	8000 (felület), 6001, 6002, valamint a proxy: 80, 443 (TCP és UDP), 8080
Compose-fájlok helye	A Portainer kötetében (/data/compose/<szám>/)	A lemezen, /opt/stacks/<név>/compose.yaml	A /data/coolify/ alatt, a Coolify kezeli
Több szerver	Igen (ügynökökkel)	Igen (Dockge Felügyelők, béta)	Igen (SSH-n keresztül)
Kétlépcsős azonosítás	A CE beállításai között nem találtuk	Nincs	Van (TOTP és passkey)
Kinek való?	Aki mindent látni és kattintva kezelni szeretne a Dockerben	Aki Compose-fájlokkal dolgozik, és egy könnyű felületet szeretne hozzájuk	Aki Git-tárolóból szeretne telepíteni, domainnel és HTTPS-sel, kevés kézi munkával

Mindhárom konténerképe elérhető arm64 (ARM) változatban is, nem csak x86_64-re; a Portainer és a Dockge ezen felül 32 bites ARM-ra (armv7) is. ARM-on nem próbáltuk ki őket.

A Portainer és a Dockge megfér egy szerveren (a teszten együtt futottak), és egymás stackjeit is látják: a Portainer a nem általa indított stackeket „Limited” jelzéssel mutatja, ezeket csak korlátozottan kezeli. A Coolify ellenben a 80-as és 443-as portot is lefoglalja a saját proxyjának, ezért tiszta szerverre való, más webszerver vagy Nginx Proxy Manager nélkül.

Hozzáférés SSH-alagúton keresztül

A legbiztonságosabb, ha a kezelőfelület portja csak a szerver helyi címén (127.0.0.1) figyel, és a saját gépedről SSH-alagúton éred el. Így a felület az internet felől egyáltalán nem látszik, a tűzfalon sem kell portot nyitni, és a bejelentkezést az SSH-kulcs védi. A saját gépeden:

ssh -N -L 9443:127.0.0.1:9443 -L 5001:127.0.0.1:5001 felhasznalo@szerver-ip

Amíg ez a parancs fut, a Portainer a https://localhost:9443, a Dockge a http://localhost:5001 címen nyílik meg a böngészőben. A -N miatt nem nyílik parancssor; a Ctrl+C zárja az alagutat. Ha gyakran használod, tedd be a LocalForward sorokat az SSH config fájlba. Ha a felületet mégis domainnel, HTTPS-en szeretnéd elérni, tedd egy reverse proxy (például Nginx Proxy Manager) mögé, erős jelszóval, és lehetőleg IP-cím szerint korlátozva.

Az alábbi parancsok ezért a Portainer és a Dockge portját a 127.0.0.1 címre kötik. Ha a felületet közvetlenül a szerver IP-címén szeretnéd elérni, hagyd el a 127.0.0.1: előtagot, de akkor a fenti kockázatokkal számolj.

Portainer CE

Telepítés

A Portainer adatai (felhasználók, beállítások, a felületen létrehozott stackek) egy névvel ellátott kötetbe kerülnek:

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

A lts címke a hosszú támogatású ágat követi (a teszten 2.45.3 LTS), a sts a gyakrabban frissülő, rövid támogatásút. A hivatalos parancs a 8000-es portot is közzéteszi (-p 8000:8000): erre csak az Edge ügynököknek van szükségük, amelyekkel távoli, NAT mögötti gépeket lehet a Portainerhez kötni. Egyetlen szerver kezeléséhez elhagyható. A 9000-es HTTP portot a Portainer alapból nem teszi közzé.

Ugyanez Docker Compose-zal, például a /opt/portainer/compose.yaml fájlban:

services:
  portainer:
    container_name: portainer
    image: portainer/portainer-ce:lts
    restart: always
    ports:
      - "127.0.0.1:9443:9443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data

volumes:
  portainer_data:
    name: portainer_data

cd /opt/portainer
sudo docker compose up -d

A Portainer saját aláírású tanúsítvánnyal indul, ezért a böngésző az első megnyitáskor figyelmeztet; ezt SSH-alagúton keresztül nyugodtan elfogadhatod.

Első belépés: telepítési token és 5 perces határidő

A dokumentáció szerint a Portainer 2.43 (illetve 2.39.4 LTS) óta az első rendszergazda létrehozásához egy telepítési token is kell, amelyet a Portainer a naplójába ír:

sudo docker logs portainer 2>&1 | grep setup_token

setup_token=78c3eb02...

Nyisd meg a https://localhost:9443 címet, add meg a rendszergazda nevét (alapból admin), egy legalább 12 karakteres jelszót és a tokent, majd kattints a Create user gombra.

Erre 5 perced van. Ha a konténer indulása után 5 percen belül nem hozod létre a felhasználót, a Portainer biztonsági okból letiltja a telepítést. A teszten a konténer tovább futott, de a felület ezt írta ki: „Your Portainer instance timed out for security purposes”. Ilyenkor indítsd újra, és kérd le a naplóból az új tokent:

sudo docker restart portainer
sudo docker logs portainer 2>&1 | grep setup_token | tail -1

A belépés után a Portainer felajánlja az Edge Compute bekapcsolását (Skip), majd az Environment Wizard képernyőn a Get Started a helyi Dockert választja ki. A Home oldalon a local környezetre kattintva jutsz a vezérlőpultra.

A Containers menü a konténerek listája. A sorok végén lévő ikonokkal a napló, a részletek, az erőforrás-használat és a konzol nyílik meg; a felső gombokkal a kijelölt konténerek indíthatók, leállíthatók, újraindíthatók vagy törölhetők.

Az első stack

Egy Compose-alkalmazás a Portainerben „stack”. A Stacks › Add stack oldalon adj nevet a stacknek (például nginx-demo), a Build method legyen Web editor, és illeszd be a Compose-fájlt:

services:
  web:
    image: nginx:alpine
    restart: unless-stopped
    ports:
      - "127.0.0.1:8081:80"

A lap alján a Deploy the stack gomb letölti a képet és elindítja a konténert. A Portainer a Compose-fájlt a saját kötetében tárolja (a teszten /data/compose/1/docker-compose.yml), nem egy általad választott mappában. Relatív kötetútvonalat (./data:/app/data) ezért itt ne használj: névvel ellátott kötetet vagy teljes útvonalat (/srv/app/data:/app/data) adj meg.

Egy stack frissítése: a stack oldalán az Editor fülön módosítsd a fájlt, vagy hagyd változatlanul, majd Update the stack. A megjelenő ablakban a Re-pull image and redeploy kapcsolóval a Portainer a képek legújabb változatát is letölti.

A Portainer frissítése és eltávolítása

A Portainer frissítése a konténer újralétrehozása; az adatok a portainer_data kötetben megmaradnak (a teszten a frissítés után a régi jelszóval lehetett belépni, telepítési token nélkül):

sudo docker stop portainer
sudo docker rm portainer
sudo docker pull portainer/portainer-ce:lts
sudo docker run -d -p 127.0.0.1:9443:9443 --name portainer --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer-ce:lts

Compose-zal: cd /opt/portainer && sudo docker compose pull && sudo docker compose up -d.

Eltávolítás:

sudo docker rm -f portainer
sudo docker volume rm portainer_data

A Portainerrel indított stackek ezután is tovább futnak, de a Compose-fájljuk a kötettel együtt törlődik. Előtte mentsd ki őket (a stack Editor fülén a Copy gombbal, vagy a kötet compose mappájából).

Dockge

A Dockge a Uptime Kuma fejlesztőjének eszköze. Minden stack egy mappa a /opt/stacks alatt, benne a compose.yaml és a .env fájllal. A felület ezeket a fájlokat szerkeszti, és a docker compose parancsot futtatja, így ugyanaz a stack a parancssorból is kezelhető, és a Dockge nélkül is működik.

Telepítés

sudo mkdir -p /opt/stacks /opt/dockge
cd /opt/dockge
sudo curl -fsSL https://raw.githubusercontent.com/louislam/dockge/master/compose.yaml -o compose.yaml

A letöltött fájl a Dockge 5001-es portját minden címen közzéteszi. Ha SSH-alagúton fogod elérni, a ports alatti sort írd át 127.0.0.1:5001:5001-re, például így:

sudo sed -i 's/- 5001:5001/- 127.0.0.1:5001:5001/' compose.yaml
sudo docker compose up -d

A fájl a Docker socketet, a Dockge saját adatmappáját (./data) és a /opt/stacks mappát csatolja. Ha más mappában szeretnéd tartani a stackeket, a DOCKGE_STACKS_DIR változót és a kötetet is írd át, és a kötet két oldalán ugyanaz a teljes útvonal szerepeljen (például /srv/stacks:/srv/stacks), különben a stackek adatai rossz helyre kerülnek.

A Dockge titkosítás nélkül, HTTP-n szolgál ki, ezért interneten keresztül csak SSH-alagúton vagy HTTPS-es reverse proxy mögött használd.

Első belépés és az első stack

A http://localhost:5001 címen a Dockge a böngésző nyelvén, magyarul is megjelenik. Az első oldalon (Adminisztrátor felhasználó létrehozása) adj meg egy felhasználónevet és egy erős jelszót. Itt nincs időkorlát, ezért telepítés után azonnal hozd létre a fiókot.

Új stackhez kattints az Összeállít gombra, a Stack Neve mezőbe írj egy kisbetűs nevet (például uptime-kuma), és a jobb oldali szerkesztőbe írd be a Compose-fájlt:

services:
  uptime-kuma:
    image: louislam/uptime-kuma:2
    restart: unless-stopped
    ports:
      - 127.0.0.1:3001:3001
    volumes:
      - ./data:/app/data

A Telepítés gomb elmenti a fájlt a /opt/stacks/uptime-kuma/compose.yaml helyre, és elindítja a stacket; a Mentés csak elment. A letöltés és az indítás kimenete élőben látszik. A futó stack oldalán a Szerkesztés, Újraindítás, Frissítés és Leállítás gomb, valamint a konténer naplója és a Bash gombbal a konténer parancssora érhető el. A Frissítés a dokumentáció szerint letölti a képek új változatát, és újraindítja velük a stacket.

A relatív útvonal (./data) itt a stack mappájához képest értendő, így az Uptime Kuma adatai a /opt/stacks/uptime-kuma/data mappába kerülnek. A főképernyő Átalakítás Compose-ra mezője egy docker run parancsot alakít Compose-fájllá, a jobb felső menü Stack Mappa Beolvasása pontja pedig a kézzel a /opt/stacks alá másolt stackeket veszi fel a listába.

Ugyanez a parancssorból:

cd /opt/stacks/uptime-kuma
sudo docker compose ps
sudo docker compose logs -f

A Dockge frissítése és eltávolítása

cd /opt/dockge
sudo docker compose pull
sudo docker compose up -d

Eltávolítás: cd /opt/dockge && sudo docker compose down, majd ha már nem kell, sudo rm -rf /opt/dockge. A stackek tovább futnak (a teszten a Dockge leállítása után is futott az Uptime Kuma), és a Compose-fájljaik a /opt/stacks alatt maradnak.

A Dockge legutóbbi kiadása az 1.5.0 (2025. március); a forráskód azóta is kap javításokat, de új kiadás a teszt idején nem jelent meg. Kétlépcsős azonosítás nincs benne. A Beállítások › Biztonság oldalon a Hitelesítés Kikapcsolása a jelszavas védelmet teljesen kikapcsolja: ezt csak akkor használd, ha a Dockge elé egy másik, hitelesítést végző réteg (például reverse proxy jelszóval) kerül.

Coolify

A Coolify nem csak a Dockert kezeli: alkalmazásokat épít Git-tárolóból, Dockerfile-ból, Compose-fájlból vagy kész képből, adatbázisokat indít és ment, és a saját Traefik proxyján keresztül domaint és Let’s Encrypt tanúsítványt ad az alkalmazásoknak. Egy Coolify-példány több szervert is kezelhet SSH-n keresztül.

Mielőtt telepíted

• Tiszta szerverre telepítsd. A Coolify a 80-as és 443-as portot a saját proxyjának foglalja le, ezért ne telepítsd olyan szerverre, ahol már fut webszerver, Nginx Proxy Manager vagy más alkalmazás.
• Gépigény. A dokumentáció szerint legalább 2 CPU mag, 2 GB RAM és 10 GB szabad lemezterület kell. A telepítő ennél szigorúbb: 30 GB-nál kisebb lemez vagy 20 GB-nál kevesebb szabad hely esetén figyelmeztet (a teszten a 29 GB-os lemeznél kiírta, majd 5 másodperc múlva folytatta). A Coolify saját konténerei a teszten kb. 500 MB memóriát és kb. 3 GB lemezt foglaltak, ehhez jönnek az alkalmazások és az építések.
• Támogatott rendszerek. A dokumentáció szerint Debian- és Ubuntu-alapú (Ubuntuból az LTS kiadások), Red Hat-alapú (AlmaLinux, Rocky Linux, Fedora), SUSE-, Arch és Alpine rendszereken telepíthető, x86_64 és arm64 processzoron.
• A snapből telepített Docker nem jó. Ha az Ubuntun snapből telepítetted a Dockert, előbb távolítsd el; a telepítő a Docker hivatalos tárolójából telepíti.
• Root SSH-hozzáférés kulccsal. A Coolify a saját szerverét is SSH-n keresztül kezeli, root felhasználóként.

Telepítés

A hivatalos telepítő:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

Ha előbb el szeretnéd olvasni, töltsd le (curl -fsSL https://cdn.coollabs.io/coolify/install.sh -o install.sh), nézd át, majd futtasd sudo bash install.sh paranccsal. A teszten a szkript 2 perc 43 másodperc alatt kilenc lépést végzett el:

1. telepítette a hiányzó csomagokat (curl, wget, git, jq, openssl);
2. ellenőrizte, hogy fut-e az OpenSSH szerver, és engedélyezett-e a root bejelentkezés (az Ubuntu alapbeállítása, a prohibit-password, megfelel: csak kulccsal);
3. telepítette a Docker Engine-t (29.9.3) a Docker tárolójából;
4. megírta az /etc/docker/daemon.json fájlt: naplóforgatás (10 MB, 3 fájl) és a konténerhálózatok címtartománya (10.0.0.0/8, /24-es alhálózatokkal);
5. letöltötte a saját fájljait a /data/coolify/source/ mappába;
6. létrehozta a .env fájlt a titkos kulcsokkal;
7. SSH-kulcsot generált, és a nyilvános részét a /root/.ssh/authorized_keys fájlba írta (coolify megjegyzéssel);
8. letöltötte a képeket (Coolify, PostgreSQL, Redis, segédkép);
9. elindította a Coolify-t.

A címtartomány miatt érdemes tudni: ha a szerver egy 10.x.x.x című magánhálózatot vagy VPN-t is használ, az ütközhet a Docker-hálózatokkal. A telepítő a DOCKER_ADDRESS_POOL_BASE környezeti változóval más tartományt is elfogad.

A végén a szkript kiírja a felület címét (http://<szerver-ip>:8000) és két figyelmeztetést: a rendszergazdát 10 percen belül hozd létre, és mentsd el a /data/coolify/source/.env fájlt a szerveren kívülre (például jelszókezelőbe), mert a titkos kulcsok nélkül a mentések nem állíthatók vissza.

A felületet SSH-alagúton is elérheted (ssh -N -L 8000:127.0.0.1:8000 felhasznalo@szerver-ip, majd http://localhost:8000). A 6001-es port az élő frissítéseket, a 6002-es a webes terminált szolgálja ki; ha ezekre is szükséged van, ezeket is irányítsd át.

A rendszergazda és a kezdő beállítás

Az első oldalon (Create the root account for this instance) adj meg nevet, e-mail-címet és egy legalább 8 karakteres jelszót kis- és nagybetűvel, számmal és írásjellel. Ha 10 percen belül nem hozod létre, futtasd a sudo docker restart coolify parancsot, és próbáld újra. A létrehozás után a nyilvános regisztráció kikapcsol (Settings › Advanced: „Registration disabled”).

A kezdő varázsló (Welcome to Coolify, Continue) a szervert kéri. A This machine a Coolify saját szerverét választja ki; ekkor indul el a Traefik proxy is (a teszten a traefik:v3.7 képpel, a 80-as, 443-as és 8080-as porton). A 8080-as portot a Traefik vezérlőpultja használhatná, de az alapbeállításban (--api.insecure=false) nem érhető el, a teszten nem válaszolt rajta semmi; a tűzfalon ne nyisd meg. Ezután a varázsló létrehozza az első projektet (My First Project) a production környezettel. A varázsló a Skip setup gombbal át is ugorható; a szerver és a projekt ilyenkor is megmarad.

Az első alkalmazás telepítése

A projekt production környezetében a New Resource (vagy üres környezetben az Add Resource) gomb az erőforrás-választóhoz visz. Itt választható:

• Applications: nyilvános Git-tároló, privát tároló telepítési kulccsal, GitHub, GitLab vagy Gitea alkalmazáson keresztül (automatikus telepítéssel minden push után), Dockerfile, Docker Compose vagy kész Docker-kép;
• Databases: PostgreSQL, MySQL, MariaDB, Redis, KeyDB, Dragonfly, MongoDB, ClickHouse és (kísérleti) SQLite;
• Services: közel négyszáz egykattintásos sablon, például Uptime Kuma, n8n vagy WordPress.

A teszten a Coolify példatárából telepítettünk egy statikus oldalt. A Public Git Repository kártyán a Deploy gombra kattintva add meg a tároló címét (https://github.com/coollabsio/coolify-examples), majd Check Repository. A Coolify lekéri az alapértelmezett ágat, és felajánlja az építés módját (Build pack):

• Railpack: felismeri a nyelvet és a keretrendszert (Node.js, PHP, Python, Go stb.), és Dockerfile nélkül épít képet; ez az alapértelmezés;
• Nixpacks: a Railpack elődje, a felület már elavultként (deprecated) jelöli;
• Static: statikus fájlok nginx-szel kiszolgálva;
• Dockerfile és Docker Compose: a tárolóban lévő fájl alapján.

A Base directory a tárolón belüli mappa (a teszten /static), a Port az, amelyen az alkalmazás a konténerben figyel.

A Continue után az alkalmazás beállítási oldalára kerülsz, ahol a jobb felső Deploy gomb indítja az építést. A teszten 23 másodperc alatt lefutott: a Coolify letöltötte a tárolót, felépítette a képet, és „rolling update”-tel elindította az új konténert. A Deployment Logs oldalon minden lépés követhető.

Az alkalmazás automatikusan kap egy ideiglenes címet az sslip.io szolgáltatáson (http://<azonosító>.<szerver-ip>.sslip.io), amelyen domain nélkül is azonnal kipróbálható. A képen a szerver IP-címe helyett egy példacím látszik.

Saját domainhez a dokumentáció szerint a domain A rekordját irányítsd a szerver IP-címére, majd az alkalmazás Domains beállításánál add meg a címet https:// előtaggal (például https://app.pelda.hu); a Traefik ekkor Let’s Encrypt tanúsítványt kér hozzá. Ezt a lépést nem próbáltuk ki, mert a tesztgép nem volt nyilvános IP-címen elérhető. A dokumentáció szerint ha a Coolify felületének is domaint adsz, a 8000-es, 6001-es és 6002-es port a tűzfalon bezárható, a felület ezután a 443-as porton, HTTPS-en érhető el.

Biztonság és frissítés

• Kétlépcsős azonosítás: a bal alsó felhasználói menüben a Profile oldalon a Two-factor authentication › Configure 2FA kapcsolja be (hitelesítő alkalmazással). Passkey csak HTTPS-es domainen vagy localhost címen használható, IP-címen nem.
• Frissítés: a Settings › Updates oldalon az Automatic updates friss telepítés után be volt kapcsolva, így a Coolify magától frissül. Ha ezt kikapcsolod, a frissítés ugyanott, a felületről indítható. A dokumentáció szerint parancssorból az upgrade.sh szkripttel, a célverzió megadásával frissíthető; az install.sh újbóli futtatását frissítésre nem ajánlja.
• Telemetria: a Settings › Advanced oldalon az Anonymous telemetry alapból be van kapcsolva; ugyanitt kikapcsolható.
• Tűzfal: a szolgáltató tűzfalán vagy a szerveren csak a 22-es (SSH), 80-as és 443-as portot hagyd nyitva, a 8000-es, 6001-es és 6002-es portot pedig csak addig, amíg a felületnek nincs domainje. Ne feledd, hogy az ufw a Docker által közzétett portokat nem zárja le.

A Coolify eltávolítása

A dokumentáció lépéseit a teszten végigpróbáltuk. A Coolify eltávolítása nem törli a vele telepített alkalmazásokat és adatbázisokat, ezek tovább futnak (a proxy nélkül viszont a domainjeik nem működnek). Előbb ments, majd:

sudo docker rm -f coolify coolify-db coolify-redis coolify-sentinel coolify-proxy
sudo docker volume rm coolify-db coolify-redis
sudo docker network rm coolify
sudo rm -rf /data/coolify

A teszten megmaradt egy coolify-proxy-error-pages konténer is, ezt külön töröld (sudo docker rm -f coolify-proxy-error-pages). A docker network rm coolify addig hibát ad („network coolify has active endpoints”), amíg egy Coolify-jal telepített alkalmazás konténere csatlakozik a hálózathoz: ezeket előbb töröld vagy költöztesd át. A képeket a sudo docker images listája alapján törölheted, a Coolify SSH-kulcsát pedig a /root/.ssh/authorized_keys fájl coolify végű sorának törlésével vonhatod vissza.

Alternatívák

Ezeket nem próbáltuk ki; a leírás a dokumentációjuk szerint készült.

• Dokploy: a Coolify-hoz hasonló, saját szerveres PaaS (Traefik proxy, Git-tárolóból telepítés, adatbázisok, több szerver Docker Swarmmal).
• Komodo: több szerver Docker-konténereinek és Compose-stackjeinek kezelése egy felületről, Git-tárolóból is (GPL-3.0 licenc).
• Yacht: egyszerű, sablonokra épülő Docker-felület; telepítés előtt nézd meg, mennyire aktív a fejlesztése.
• Cockpit és cockpit-podman: a Red Hat-alapú rendszerek (AlmaLinux, Rocky Linux) webes szerverkezelője (alapból a 9090-es porton) a Podman-konténerek kezelésére szolgáló bővítménnyel (sudo dnf install cockpit cockpit-podman). A Podmant kezeli, nem a Docker Engine-t.

Melyiket válaszd?

• Portainer CE, ha a Docker minden részét (konténerek, képek, kötetek, hálózatok) egy felületen szeretnéd látni és kezelni, és nem zavar, hogy a felületen létrehozott stackek a Portainer kötetében élnek.
• Dockge, ha Compose-fájlokkal dolgozol, és csak egy könnyű, gyors felületet szeretnél hozzájuk, amely nélkül a stackek ugyanúgy működnek. Kis gépen is elfér.
• Coolify, ha Git-tárolóból szeretnél telepíteni, automatikus HTTPS-sel, adatbázisokkal és mentésekkel, és egy egész szervert erre szánsz.

A Portainer és a Dockge már a legkisebb VPS-en is elfut a Docker mellett; a memóriát az alkalmazások határozzák meg. A Coolify-hoz legalább 4 GB memória és 40 GB lemez ajánlott, például az AMD VPS 4 csomag (2 vCPU, 4 GB, 40 GB NVMe), mert a képek építése a saját konténerein felül is memóriát és lemezt használ. A Docker Compose-os alkalmazástelepítés egy gyakorlati példáját az n8n VPS-re telepítéséről szóló útmutatónk mutatja be.