Găzduire Docker
Fiecare funcționalitate din cont, pas cu pas.
Primii pași: primul proiect
Serverul tău rulează Docker cu Compose. Descrii containerele în docker-compose.yml, apeși „Salvează și rulează”, iar serverul le construiește și le pornește. Poți porni din editorul din cont (mai jos) sau din git (vezi „Deploy din git”).
- Deschide proiectul
În caseta Proiect apasă Editează. Editorul are deja un exemplu mic (nginx cu un volum).
- Scrie sau lipește docker-compose.yml
Fiecare serviciu este un container. Folosește
image:pentru o imagine gata făcută saubuild:pentru un Dockerfile din proiect. - Apasă „Verifică”
Serverul verifică proiectul cu aceleași reguli pe care le aplică la rulare, fără să schimbe nimic. Problemele apar într-o listă, cu numele serviciului.
- Apasă „Salvează și rulează”
Versiunea se salvează (ultimele 10 rămân în istoric) și se aplică pe server: imaginile se descarcă sau se construiesc, apoi containerele pornesc. Rezultatul și ieșirea docker compose apar sub editor.
- Dă-i un domeniu
În caseta Domenii adaugă un domeniu spre serviciu și portul din container (aici
web, portul 80). Certificatul HTTPS se emite automat.
services:
web:
image: nginx:alpine
volumes:
- site:/usr/share/nginx/html
deploy:
resources:
limits: {cpus: "0.5", memory: 256M}
restart: unless-stopped
volumes:
site: {}
- Pune
restart: unless-stoppedla fiecare serviciu: containerele pornesc din nou după o repornire a serverului. Un serviciu fără politică de restart primește de la serveron-failure: este repornit când se oprește cu eroare sau rămâne fără memorie. - Setează limite de CPU și memorie (
deploy.resources.limits): așa un container nu poate ocupa tot serverul.
Containere
Caseta Containere arată câte containere rulează din câte include serviciul tău. Gestionează deschide lista.
- Citește starea
Fiecare container arată: pornit sau oprit (cu codul de ieșire sau „memorie insuficientă”), verificarea de sănătate (sănătos, nesănătos, pornește, fără verificare), repornirile, CPU și memoria folosite din limita lui și porturile.
- Înțelege etichetele porturilor
public: accesibil din Internet; blocat în firewall: publicat, dar nedeschis (apasă „deschide” ca să-l deschizi); doar privat: accesibil doar în rețeaua privată și prin VPN-ul ServerHost; doar pe server: publicat pe 127.0.0.1, accesibil doar de pe server; intern: doar între containere.
- Pornește, oprește, repornește
Butoanele de pe fiecare container acționează imediat, doar asupra acelui container.
- Șterge
Șterge containerul, niciodată volumele lui. Revine la următorul „Salvează și rulează” cât timp serviciul este încă în docker-compose.yml; ca să nu mai pornească, șterge sau comentează serviciul în docker-compose.yml.
services:
api:
build: .
healthcheck:
test: ["CMD", "wget", "-qO-", "http://127.0.0.1:3000/health"]
interval: 30s
timeout: 5s
retries: 3
restart: unless-stopped
- Fiecare container se numără la containerele incluse în serviciul tău (servicii × replici), cu excepția proxy-ului nostru HTTPS. Un compose care pornește mai multe este refuzat la „Verifică”; mărește numărul din Resurse → apasă Modifică.
- Cu o verificare de sănătate te putem anunța când aplicația nu mai răspunde, chiar dacă containerul încă rulează.
Volume și cote
Datele care trebuie să rămână după o repornire sau o versiune nouă stau în volume. Fiecare volum are cota lui pe discul de date, stabilită de tine.
- Declară volumul
Adaugă-l la
volumes:la finalul docker-compose.yml și montează-l în serviciu. La prima rulare primește o cotă de 5 GB (sau cât a rămas, dacă este mai puțin). Dacă au rămas sub 1 GB nealocați, rularea se oprește: micșorează cotele altor volume sau mărește stocarea. - Schimbă cota
În Volume → apasă Modifică, scrie cota în GB lângă fiecare volum. Suma apare cu roșu dacă trece de maximum; apasă „Salvează cotele”.
- Urmărește ocuparea
Fiecare volum arată cât ocupă din cota lui. La 90% vezi un avertisment și primești un email (o singură dată, până scade sub 85%).
- Șterge un volum nefolosit
Un volum pe care nu-l folosește niciun container are butonul „Șterge”. Datele se șterg definitiv; dacă volumul este încă în docker-compose.yml, la următoarea rulare se creează din nou, gol.
services:
db:
image: postgres:17-alpine
environment:
POSTGRES_PASSWORD: ${DB_PASS}
volumes:
- pgdata:/var/lib/postgresql/data
volumes:
pgdata: {}
services:
web:
image: nginx:alpine
volumes:
- ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
- site:/usr/share/nginx/html
volumes:
site: {}
- Cotele împreună pot ajunge la cel mult 90% din discul de date, iar 6 GB rămân mereu liberi pentru imagini și build (disc de 20 GB: 14 GB pentru volume). Fiecare cotă este de cel puțin 64 MB și cel puțin cât ocupă deja volumul.
- Fișierele proiectului (
./fișier) se pot monta doar citire, cu:ro. Tot ce scrie aplicația merge în volume. - Mai multă stocare: Resurse → apasă Modifică. Discul de date doar crește.
- Cu Stocarea Hibridă (SSD-NVMe, din Resurse → apasă Modifică), un volum poate sta pe discul SSD-NVMe: pune eticheta
svh.disk: ssdpe volum în docker-compose.yml (volumes: { pgdata: { labels: { svh.disk: ssd } } }) și se creează direct acolo, sau mută un volum existent cu Mută pe SSD-NVMe / Mută pe HDD Cluster. Mutarea copiază datele pe celălalt disc: containerele care folosesc volumul se opresc cât durează copierea, apoi pornesc din nou. Fiecare disc are plafonul lui de cote; imaginile și build-urile rămân pe HDD Cluster. Stocarea Hibridă se poate scoate doar după ce toate volumele sunt din nou pe HDD Cluster.
Proiect: editor, fișiere, .env, versiuni
Proiectul înseamnă docker-compose.yml, .env și fișierele tale (Dockerfile-uri, configurări, pagini mici). Totul se păstrează în cont, cu ultimele 10 versiuni.
- Adaugă fișiere
Încarcă fișiere (mai multe deodată, cel mult 512 KB fiecare) sau Fișier nou cu calea lui, de ex.
web/Dockerfile. Un fișier se poate redenumi sau elimina din editor. - Ține secretele în .env
Scrie parolele și cheile în
.envși folosește-le în docker-compose.yml ca${NUME}, sau dă tot fișierul unui serviciu cuenv_file: ./.env. - Verifică, apoi rulează
„Verifică” arată problemele fără să schimbe nimic; „Salvează și rulează” salvează o versiune nouă și o aplică.
- Revino la o versiune
Alege o versiune din listă și apasă Revino la această versiune: se aplică imediat, ca o versiune nouă. Ca s-o modifici întâi, apasă Încarcă în editor; se aplică doar când apeși „Salvează și rulează”.
DB_PASS=o-parola-lunga-si-unica APP_KEY=cheia-aplicatiei
FROM nginx:alpine COPY index.html /usr/share/nginx/html/index.html
- Nu sunt permise, pentru că ar da acces la tot serverul: privileged, cap_add, devices, network_mode / pid / ipc host, montarea folderelor serverului sau a socket-ului Docker, alte drivere de loguri, volume și rețele externe, build cu rețeaua host.
- Porturile 22, 80 și 443 ale serverului sunt rezervate (SSH și proxy-ul nostru). Pentru aplicațiile web folosește un domeniu în loc de un port publicat.
- După fiecare rulare (din cont sau din git), serverul verifică containerele: sănătoase (cu verificare de sănătate), pornite de un minut fără reporniri sau terminate cu codul 0. Dacă versiunea nouă nu trece în 5 minute, serverul repornește ultima versiune reușită. Datele din volume nu se întorc (o migrare a bazei de date rămâne făcută).
- Cel mult 60 de fișiere, de câte 512 KB, 4 MB în total. Pentru proiecte mai mari folosește deploy-ul din git.
- O versiune mai mare de aproximativ 600 KB nu intră în istoric: rămâne doar cea curentă.
Domenii (HTTPS)
Proxy-ul nostru trimite fiecare domeniu spre un serviciu și un port din container. Certificatul HTTPS (Let's Encrypt) se emite și se reînnoiește automat. Nu trebuie să publici porturile 80 sau 443.
- Îndreaptă DNS-ul
La registrarul domeniului, adaugă o înregistrare A pentru domeniu (de ex.
app.domeniul-tau.ro) cu valoareaIP_SERVER. - Adaugă domeniul
În Domenii → apasă Modifică: scrie domeniul, alege serviciul și portul din container (de ex. 80 pentru nginx, 3000 pentru Node.js), apasă Adaugă.
- Așteaptă certificatul
Cât timp DNS-ul nu indică spre server, domeniul are un certificat temporar. Când DNS-ul este corect, certificatul Let's Encrypt se emite în câteva minute (verificare la 5 minute).
- Securitate per domeniu
Apasă Securitate lângă domeniu: Doar adresele de acces (tot domeniul se deschide doar de la adresele tale de acces și din VPN-ul ServerHost), Content-Security-Policy (doar raportare sau impus, cu domeniile externe permise).
- Un domeniu poate aparține unui singur serviciu ServerHost. Cel mult 20 de domenii pe server.
- Antetele de securitate (X-Frame-Options, X-Content-Type-Options, Referrer-Policy, HSTS) se adaugă automat, doar dacă aplicația ta nu le trimite deja.
Porturi deschise din Internet
Pentru serviciile care nu sunt web (MQTT, servere de jocuri, o bază de date accesată din afară), publică portul în docker-compose.yml și deschide-l din cont.
- Publică portul
În docker-compose.yml:
ports: ["1883:1883"](portul serverului : portul containerului). - Deschide-l în firewall
În Securitate → apasă Modifică, la „Porturi deschise din Internet”, scrie portul, alege TCP sau UDP și apasă Deschide. Poți apăsa și „deschide” direct pe un port afișat „blocat în firewall” în lista containerelor.
- Închide-l
Apasă × lângă port: rămâne accesibil doar prin VPN-ul ServerHost.
services:
mqtt:
image: eclipse-mosquitto:2
ports:
- "1883:1883"
- Un port publicat pe care nu-l deschizi rămâne închis din Internet, dar accesibil prin VPN-ul ServerHost: util pentru baze de date și panouri de administrare.
- Blocarea pe țări se aplică și porturilor deschise.
Loguri
Fiecare container scrie în stdout și stderr. Le poți urmări live și le poți păstra pe disc pentru serviciile alese.
- Urmărește live
În Loguri → Vezi live alege containerul (sau apasă Loguri pe un container). Liniile noi apar la 2 secunde; cele din stderr sunt roșii. Din listă alegi doar stdout sau doar stderr; debifează „urmărește” ca să oprești citirea liniilor noi.
- Păstrează-le (loguri persistente)
La „Loguri persistente” bifează serviciile și numărul de zile (1-90), apoi salvează. Logurile se scriu în volumul
app__logs, cu rotire zilnică și comprimare. - Gestionează spațiul
Volumul
app__logspornește cu 1 GB și apare împreună cu celelalte volume: mărește-i cota acolo dacă păstrezi multe zile.
- Implicit (fără loguri persistente) fiecare container păstrează doar un buffer mic, circular: liniile vechi se pierd.
Securitate
Aceleași protecții ca la găzduirea web, la nivelul serverului.
- Adrese de acces
Adresele tale IP (sau nume DDNS) de la care se deschid domeniile protejate: cele cu „Doar adresele de acces”.
- Acces prin VPN
Cu VPN-ul ServerHost pornit, utilizatorii tăi VPN ajung la server de oriunde, inclusiv la porturile nedeschise din Internet.
- Țări blocate
Traficul dinspre și către țările bifate este blocat de firewall, pe toate porturile, inclusiv containerele. Salvează țările: firewall-ul se actualizează în câteva minute.
- Firewall-ul este mereu activ: din Internet sunt accesibile doar 80/443 (pentru proxy) și porturile pe care le deschizi tu. Portul 22 (SSH) se deschide doar pentru adresele tale de acces și, la deploy din git, pentru adresele CI-ului.
Deploy din git
La fiecare push, CI-ul repo-ului tău trimite proiectul pe server. Serverul nu se conectează la repo-ul tău și nu are nevoie de cheie de deploy.
- Alege git
În Deploy → apasă Modifică alege Git (deploy din CI) și serviciul git: ServerHost GitLab (permis automat) sau altul (GitHub, GitLab.com, runner propriu: scrie adresa CI-ului, portul 22 se deschide doar pentru ea). Apasă Salvează sursa proiectului.
- Salvează cheia CI
Apasă Copiază cheia și salveaz-o în repo ca variabilă CI protejată (secret) cu numele
SVH_DEPLOY_KEY. Cheia privată se afișează doar 24 de ore; după aceea poți genera una nouă. - Adaugă configurarea CI
Copiază în repo exemplul pentru serviciul tău git. docker-compose.yml (sau compose.yaml) trebuie să fie în rădăcina repo-ului.
- Ține .env în cont
Secretele rămân în cont, în Proiect → .env (în modul git editorul arată doar .env). Un .env din repo este ignorat.
- Fă push
Jobul CI trimite codul, serverul îl verifică (aceleași reguli ca la editor) și îl rulează. Jobul este verde dacă proiectul a pornit și a trecut verificarea de sănătate și roșu cu motivul exact dacă nu (serverul repornește atunci ultima versiune reușită). Deploy arată ultimul deploy (commit, rezultat, ieșire) și pe cele anterioare.
- Revino la o versiune anterioară
Repo-ul este sursa proiectului, deci revii din CI, rulând din nou deploy-ul commit-ului dorit: în GitLab, Build → Pipelines, pipeline-ul acelui commit, apoi Retry pe jobul de deploy; în GitHub, Actions, rularea acelui commit, apoi Re-run all jobs. Jobul trimite din nou acel commit (
git archive HEADeste commit-ul pipeline-ului). În cont, Revino la această versiune este disponibil doar cu editorul din cont.
deploy:
stage: deploy
image: alpine:3
rules:
- if: $CI_COMMIT_BRANCH == "main"
script:
- apk add --no-cache git openssh-client
- mkdir -p ~/.ssh && echo "$SVH_DEPLOY_KEY" > ~/.ssh/ci-svh && chmod 600 ~/.ssh/ci-svh
- git archive --format=tar HEAD > app.tar
- ssh -i ~/.ssh/ci-svh -o StrictHostKeyChecking=accept-new svhdeploy@IP_SERVER
deploy "$(sha256sum app.tar | cut -d' ' -f1)" < app.tar
name: deploy
on:
push:
branches: [main]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Deploy
env:
SVH_DEPLOY_KEY: ${{ secrets.SVH_DEPLOY_KEY }}
run: |
mkdir -p ~/.ssh && echo "$SVH_DEPLOY_KEY" > ~/.ssh/ci-svh && chmod 600 ~/.ssh/ci-svh
git archive --format=tar HEAD > app.tar
ssh -i ~/.ssh/ci-svh -o StrictHostKeyChecking=accept-new svhdeploy@IP_SERVER \
deploy "$(sha256sum app.tar | cut -d' ' -f1)" < app.tar
git archive --format=tar HEAD > app.tar ssh -i ~/.ssh/ci-svh svhdeploy@IP_SERVER deploy "$(sha256sum app.tar | cut -d' ' -f1)" < app.tar
- Refuzate, fără nicio schimbare: o arhivă care nu a ajuns completă (SHA-256), legăturile simbolice din repo, un proiect care nu trece verificările. Fișierele scoase din repo se șterg de pe server la următorul deploy; volumele nu se ating.
- Cel mult 512 MB per arhivă și 20.000 de fișiere. Nu pune în git node_modules, vendor sau rezultatul build-ului: se construiesc pe server, din Dockerfile.
- Înapoi la editor: alege Editorul din cont; cheia CI nu mai funcționează, iar „Salvează și rulează” pune la loc proiectul din editor.
Exemplu: o aplicație Node.js
O aplicație Node.js (Express, Fastify, NestJS) cu PostgreSQL, publicată din git. Dependențele se instalează pe server, la build.
- Adaugă Dockerfile și .dockerignore
În rădăcina repo-ului, lângă package.json.
- Adaugă docker-compose.yml
Serviciul
appse construiește din Dockerfile; baza de date își păstrează datele în volumulpgdata. - Scrie .env în cont
De ex.
DB_PASS=...șiDATABASE_URL=postgres://postgres:...@db:5432/postgres(baza de date se găsește după numele serviciului,db). - Fă push, apoi adaugă domeniul
După primul deploy reușit, adaugă domeniul spre
app, portul 3000.
FROM node:22-alpine WORKDIR /app COPY package*.json ./ RUN npm ci --omit=dev COPY . . ENV NODE_ENV=production EXPOSE 3000 USER node CMD ["node", "server.js"]
node_modules .git .env npm-debug.log
services:
app:
build: .
env_file: ./.env
healthcheck:
test: ["CMD", "wget", "-qO-", "http://127.0.0.1:3000/health"]
interval: 30s
deploy:
resources:
limits: {cpus: "1", memory: 512M}
restart: unless-stopped
db:
image: postgres:17-alpine
environment:
POSTGRES_PASSWORD: ${DB_PASS}
volumes:
- pgdata:/var/lib/postgresql/data
restart: unless-stopped
volumes:
pgdata: {}
FROM node:22-alpine AS build WORKDIR /app COPY package*.json ./ RUN npm ci COPY . . RUN npm run build FROM node:22-alpine WORKDIR /app ENV NODE_ENV=production COPY --from=build /app/package*.json ./ RUN npm ci --omit=dev COPY --from=build /app/.next ./.next COPY --from=build /app/public ./public EXPOSE 3000 USER node CMD ["npx", "next", "start", "-p", "3000"]
- Aplicația trebuie să asculte pe 0.0.0.0, nu pe localhost, ca proxy-ul să ajungă la ea.
- Build-ul folosește CPU-ul și memoria serverului tău; un build mare de Next.js poate avea nevoie de 2 GB RAM.
- Aici sunt două containere (app și db): amândouă se numără la containerele incluse în serviciu.
Exemplu: o aplicație Python (FastAPI) cu worker
Un API în Python (FastAPI) cu PostgreSQL, Redis și un worker pentru lucrările din fundal, publicat din git. API-ul și worker-ul se construiesc din același cod.
- Adaugă Dockerfile, .dockerignore și requirements.txt
În rădăcina repository-ului, lângă
main.py(API-ul) șiworker.py(lucrările). - Adaugă docker-compose.yml
Serviciile
apișiworkerse construiesc din același Dockerfile;workerrulează altă comandă (python -m worker). PostgreSQL își ține datele în volumulpgdata; Redis ține coada de lucrări doar în memorie. - Scrie .env în cont
De ex.
DB_PASS=...,DATABASE_URL=postgresql://postgres:...@db:5432/postgresșiREDIS_URL=redis://redis:6379/0(celelalte servicii se găsesc după nume). - Fă push, apoi adaugă domeniul
După primul deploy reușit, adaugă domeniul spre
api, portul 8000. Worker-ul, baza de date și Redis nu au nevoie de domeniu: se văd doar între containere.
FROM python:3.13-slim WORKDIR /app ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY . . RUN useradd -r -u 10001 app USER app EXPOSE 8000 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "2"]
__pycache__ .venv .git .env
fastapi uvicorn[standard] psycopg[binary] redis
services:
api:
build: .
env_file: ./.env
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health')"]
interval: 30s
depends_on: [db, redis]
deploy:
resources:
limits: {cpus: "1", memory: 512M}
restart: unless-stopped
worker:
build: .
command: ["python", "-m", "worker"]
env_file: ./.env
depends_on: [db, redis]
deploy:
resources:
limits: {cpus: "0.5", memory: 256M}
restart: unless-stopped
db:
image: postgres:17-alpine
environment:
POSTGRES_PASSWORD: ${DB_PASS}
volumes:
- pgdata:/var/lib/postgresql/data
restart: unless-stopped
redis:
image: redis:7-alpine
command: ["redis-server", "--save", "", "--appendonly", "no"]
restart: unless-stopped
volumes:
pgdata: {}
- Uvicorn ascultă pe 0.0.0.0, nu pe localhost, ca proxy-ul să ajungă la el. Adresa
/healthfolosită de verificarea de sănătate o scrii tu, în API. - Aici sunt patru containere (api, worker, db, redis): toate intră în containerele incluse în serviciul tău.
- Pentru WordPress sau alte site-uri PHP folosește Găzduirea web: are protecțiile WordPress, cache-ul de pagini și WebP incluse.
Alerte pe email
Îți scriem pe email (și în Mesajele din cont) când ceva are nevoie de atenția ta. Fiecare problemă se trimite o singură dată și se rearmează când dispare.
- Volume și discul de date
La 90% din cota unui volum sau din discul de date.
- Container nesănătos
Când verificarea de sănătate eșuează.
- Repornire în buclă
Când un container repornește iar și iar (de cel puțin 3 ori între două verificări).
- Oprire neașteptată
Când un container pornit se oprește cu eroare sau rămâne fără memorie, fără să-l fi oprit tu din cont.
- Verificările rulează la 5 minute.