Găzduire Docker

Narat cu vocea lui Edi AI AI dezvoltat de către ServerHost

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”).

  1. Deschide proiectul

    În caseta Proiect apasă Editează. Editorul are deja un exemplu mic (nginx cu un volum).

  2. Scrie sau lipește docker-compose.yml

    Fiecare serviciu este un container. Folosește image: pentru o imagine gata făcută sau build: pentru un Dockerfile din proiect.

  3. 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.

  4. 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.

  5. 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.

docker-compose.yml
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-stopped la fiecare serviciu: containerele pornesc din nou după o repornire a serverului. Un serviciu fără politică de restart primește de la server on-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.

  1. 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.

  2. Î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.

  3. Pornește, oprește, repornește

    Butoanele de pe fiecare container acționează imediat, doar asupra acelui container.

  4. Ș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.

Verificare de sănătate (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.

  1. 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.

  2. 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”.

  3. 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%).

  4. Ș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.

O bază de date cu volum
services:
  db:
    image: postgres:17-alpine
    environment:
      POSTGRES_PASSWORD: ${DB_PASS}
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata: {}
Un fișier din proiect montat doar citire
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: ssd pe 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.

  1. 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.

  2. Ț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 cu env_file: ./.env.

  3. Verifică, apoi rulează

    „Verifică” arată problemele fără să schimbe nimic; „Salvează și rulează” salvează o versiune nouă și o aplică.

  4. 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ă”.

.env
DB_PASS=o-parola-lunga-si-unica
APP_KEY=cheia-aplicatiei
web/Dockerfile
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.

  1. Îndreaptă DNS-ul

    La registrarul domeniului, adaugă o înregistrare A pentru domeniu (de ex. app.domeniul-tau.ro) cu valoarea IP_SERVER.

  2. 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ă.

  3. 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).

  4. 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.

  1. Publică portul

    În docker-compose.yml: ports: ["1883:1883"] (portul serverului : portul containerului).

  2. 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.

  3. Închide-l

    Apasă × lângă port: rămâne accesibil doar prin VPN-ul ServerHost.

Un port publicat (docker-compose.yml)
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.

  1. 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.

  2. 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.

  3. Gestionează spațiul

    Volumul app__logs porneș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.

  1. Adrese de acces

    Adresele tale IP (sau nume DDNS) de la care se deschid domeniile protejate: cele cu „Doar adresele de acces”.

  2. Acces prin VPN

    Cu VPN-ul ServerHost pornit, utilizatorii tăi VPN ajung la server de oriunde, inclusiv la porturile nedeschise din Internet.

  3. Ță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.

  1. 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.

  2. 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ă.

  3. 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.

  4. Ț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.

  5. 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.

  6. 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 HEAD este commit-ul pipeline-ului). În cont, Revino la această versiune este disponibil doar cu editorul din cont.

.gitlab-ci.yml (GitLab)
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
.github/workflows/deploy.yml (GitHub Actions)
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
Manual, de pe calculatorul tău (cu aceeași cheie)
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.

  1. Adaugă Dockerfile și .dockerignore

    În rădăcina repo-ului, lângă package.json.

  2. Adaugă docker-compose.yml

    Serviciul app se construiește din Dockerfile; baza de date își păstrează datele în volumul pgdata.

  3. Scrie .env în cont

    De ex. DB_PASS=... și DATABASE_URL=postgres://postgres:...@db:5432/postgres (baza de date se găsește după numele serviciului, db).

  4. Fă push, apoi adaugă domeniul

    După primul deploy reușit, adaugă domeniul spre app, portul 3000.

Dockerfile
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"]
.dockerignore
node_modules
.git
.env
npm-debug.log
docker-compose.yml
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: {}
Dockerfile pentru Next.js (build în doi pași)
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.

  1. Adaugă Dockerfile, .dockerignore și requirements.txt

    În rădăcina repository-ului, lângă main.py (API-ul) și worker.py (lucrările).

  2. Adaugă docker-compose.yml

    Serviciile api și worker se construiesc din același Dockerfile; worker rulează altă comandă (python -m worker). PostgreSQL își ține datele în volumul pgdata; Redis ține coada de lucrări doar în memorie.

  3. Scrie .env în cont

    De ex. DB_PASS=..., DATABASE_URL=postgresql://postgres:...@db:5432/postgres și REDIS_URL=redis://redis:6379/0 (celelalte servicii se găsesc după nume).

  4. 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.

Dockerfile
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"]
.dockerignore
__pycache__
.venv
.git
.env
requirements.txt
fastapi
uvicorn[standard]
psycopg[binary]
redis
docker-compose.yml
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 /health folosită 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.

  1. Volume și discul de date

    La 90% din cota unui volum sau din discul de date.

  2. Container nesănătos

    Când verificarea de sănătate eșuează.

  3. Repornire în buclă

    Când un container repornește iar și iar (de cel puțin 3 ori între două verificări).

  4. 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.