DeployVeraDocs

TEKNİK REFERANS

Veritabanı ve worker ile uygulama

Web uygulaması, PostgreSQL ve arka plan worker'ını DeployVera'da birlikte çalıştırma: kopyalanabilir, adım adım örnek.

Son kontrol: Markdown

Neler çalışır

Evet: yönetilen PostgreSQL, arka plan worker'ı ve web uygulaması aynı hizmette birlikte çalışır. Panel Docker Compose çoklu servis dağıtımını varsayılan olarak çalıştırmaz; bunun yerine her servis ayrı bir uygulama olur.

Fiyat ve kota için canlı paketlere bakın: https://deployvera.com/docker. Ücretsiz pakette 1 uygulama hakkı vardır; web ve worker iki ayrı uygulama olduğundan en az 2 uygulama hakkı gerekir. Veritabanı ayrı kotadan sayılır.

  • Web uygulaması: internete açık uygulama (erişim modu "İnternete açık").
  • Worker: ikinci bir uygulama, erişim modu "Yalnız iç ağ". Aynı hizmetteki uygulama ve veritabanlarından http://dv-xxxx:PORT biçimindeki iç adresle ulaşılır. Worker işini veritabanındaki tablodan aldığı için dışarıdan adrese ihtiyaç duymaz.
  • Veritabanı: Veritabanları sayfasından oluşturulan yönetilen PostgreSQL; bağlantı adresi panelden kopyalanır.
  • Ortam değişkenleri her uygulamada ayrı girilir; bu yüzden DATABASE_URL iki uygulamaya da eklenir.
  • Loglar her uygulamanın kendi sayfasındaki Konteyner kaydı bölümünden okunur.

Depo: package.json

Web ve worker tek depoda durur. Bu rehberdeki tüm dosyalar depo kökünde olmalıdır (package.json, Dockerfile, src/).

{
  "name": "web-worker-example",
  "private": true,
  "type": "module",
  "dependencies": { "pg": "^8.13.0" }
}

Depo: src/db.js

Bağlantı havuzu ve tablo tabanlı iş kuyruğunun şeması. İki uygulama da açılışta çağırır; tablo yoksa oluşturur.

import pg from "pg";

export const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL, max: 5 });
export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// Web and worker both call this at startup; the advisory lock makes it safe to run concurrently.
export async function migrate() {
  for (let attempt = 1; ; attempt++) {
    let client;
    try {
      client = await pool.connect();
      await client.query("SELECT pg_advisory_lock(727001)");
      await client.query(`CREATE TABLE IF NOT EXISTS jobs (
        id BIGSERIAL PRIMARY KEY,
        payload JSONB NOT NULL,
        status TEXT NOT NULL DEFAULT 'pending',
        error TEXT,
        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
        finished_at TIMESTAMPTZ
      )`);
      await client.query("SELECT pg_advisory_unlock(727001)");
      return;
    } catch (error) {
      console.error(`migrate attempt ${attempt} failed: ${error.message}`);
      if (attempt >= 10) throw error;
      await sleep(3000);
    } finally {
      client?.release();
    }
  }
}

Depo: src/web.js

import http from "node:http";
import { pool, migrate } from "./db.js";

await migrate();

const json = (res, status, body) => {
  res.writeHead(status, { "content-type": "application/json" });
  res.end(JSON.stringify(body));
};

const server = http.createServer(async (req, res) => {
  try {
    if (req.method === "POST" && req.url === "/jobs") {
      const { rows } = await pool.query(
        "INSERT INTO jobs (payload) VALUES ($1) RETURNING id",
        [JSON.stringify({ queuedAt: new Date().toISOString() })],
      );
      return json(res, 202, rows[0]);
    }
    if (req.url === "/jobs") {
      const { rows } = await pool.query(
        "SELECT id, status, error, created_at, finished_at FROM jobs ORDER BY id DESC LIMIT 20",
      );
      return json(res, 200, rows);
    }
    json(res, 200, { ok: true });
  } catch (error) {
    console.error(error);
    json(res, 500, { error: "internal" });
  }
});

server.listen(Number(process.env.PORT || 3000), "0.0.0.0", () => console.log("web listening"));
process.on("SIGTERM", () => server.close(() => process.exit(0)));

Depo: src/worker.js

import http from "node:http";
import { pool, migrate, sleep } from "./db.js";

await migrate();

// The panel asks for a port on every application, so the worker answers on it too.
http.createServer((_req, res) => res.end("worker ok"))
  .listen(Number(process.env.PORT || 3000), "0.0.0.0");

let running = true;
process.on("SIGTERM", () => { running = false; });

// SKIP LOCKED lets several worker copies take different jobs without double processing.
async function claim() {
  const { rows } = await pool.query(`UPDATE jobs SET status = 'running'
    WHERE id = (SELECT id FROM jobs WHERE status = 'pending' ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1)
    RETURNING id, payload`);
  return rows[0];
}

while (running) {
  let job;
  try { job = await claim(); } catch (error) { console.error("claim failed:", error.message); }
  if (!job) { await sleep(2000); continue; }
  try {
    console.log(`job ${job.id} started`);
    await sleep(1000); // your real work goes here
    await pool.query("UPDATE jobs SET status = 'done', finished_at = now() WHERE id = $1", [job.id]);
    console.log(`job ${job.id} done`);
  } catch (error) {
    console.error(`job ${job.id} failed:`, error.message);
    await pool.query("UPDATE jobs SET status = 'failed', error = $2, finished_at = now() WHERE id = $1", [job.id, String(error.message)]);
  }
}
process.exit(0);

Dockerfile

FROM node:22-slim
WORKDIR /app
COPY package.json ./
RUN npm install --omit=dev
COPY src ./src
# The web app uses this default; the worker application sets APP_ROLE=worker in its environment variables.
ENV APP_ROLE=web
CMD ["sh", "-c", "exec node src/${APP_ROLE}.js"]

1. Veritabanı oluşturun

Panelde Veritabanları sayfasını açın, motor olarak PostgreSQL seçip hizmetinize bağlı bir veritabanı oluşturun. Çalışır duruma gelince bağlantı adresini kopyalayın. Adres postgres://kullanici:parola@dv-... biçimindedir ve yalnızca aynı hizmetteki uygulamalardan erişilebilir.

Bağlantı adresini depoya yazmayın; sonraki adımlarda uygulamaların ortam değişkeni olarak girin.

2. Web uygulamasını yayınlayın

Yeni uygulama sihirbazında depoyu ve dalı seçin, derleme yöntemi olarak Dockerfile'ı seçin ve portu 3000 yapın. Erişim modu "İnternete açık" kalır.

Gelişmiş ayarlardan DATABASE_URL ortam değişkenini ekleyin (1. adımda kopyaladığınız adres). Dockerfile içindeki varsayılan APP_ROLE=web olduğundan başka bir değişken gerekmez. Dağıtımı başlatın; yayına çıkınca web adresinde /jobs yolu boş bir liste döndürür.

Dockerfile yerine Otomatik algıla (Nixpacks) yöntemini kullanacaksanız başlatma komutu olarak web uygulamasında node src/web.js, worker uygulamasında node src/worker.js girin; bu durumda Dockerfile ve APP_ROLE gerekmez.

3. Worker'ı ikinci uygulama olarak yayınlayın

Aynı depodan ikinci bir uygulama oluşturun (aynı hizmet, aynı dal). Derleme yöntemi Dockerfile, port 3000, erişim modu "Yalnız iç ağ" olsun. Ortam değişkenleri: aynı DATABASE_URL ve APP_ROLE=worker.

Uygulama zaten oluşturulduysa erişim modunu uygulama detayındaki "Dış erişimi kapat" düğmesiyle değiştirebilirsiniz; bu işlem çalışan uygulamayı kısa süreliğine yeniden başlatır.

Worker, işleri jobs tablosundan FOR UPDATE SKIP LOCKED ile alır. Aynı anda birden fazla worker kopyası çalışsa bile bir iş iki kez alınmaz. Kuyruk için ayrı bir ürün gerekmez.

4. Deneyin ve logları okuyun

Web adresinize bir iş ekleyip işleri listeleyin. Birkaç saniye içinde durum pending yerine done olmalıdır.

Logları her uygulamanın detay sayfasında okuyun: web uygulamasında web listening, worker uygulamasında job 1 started ve job 1 done satırları görünmelidir. Derleme hatasında ilgili uygulamanın derleme kaydına bakın; yaygın hatalar /docs/tr/build-errors makalesindedir.

curl -X POST https://YOUR-WEB-ADDRESS/jobs
curl https://YOUR-WEB-ADDRESS/jobs

Claude Code'dan "yayına al"

DeployVera MCP sunucusu bağlıysa (kurulum: /docs/tr/mcp) depoda aşağıdaki gibi bir istek verebilirsiniz.

Ajan create_project ile her uygulamayı oluşturur (bu işlem her zaman tarayıcıda onayınızı ister), set_env_vars ile değişkenleri yazar, deploy ve get_build ile derlemeyi izler, get_build_logs ile logları okur. Veritabanını oluşturmak ve worker'ın erişim modunu "Yalnız iç ağ" yapmak panelde yapılır; ajan bu iki adımı üstlenmez.

Bu depoyu DeployVera'ya yayına al: iki uygulama olarak. Web uygulaması internete açık olsun, worker uygulaması APP_ROLE=worker ile çalışsın. İkisine de aynı DATABASE_URL değerini ver. Derlemeler bitince her uygulamanın logunu oku.

Sınırlar

Panelde Docker Compose dosyası olduğu gibi çalıştırılmaz; her servis ayrı uygulamadır. Kısıtlı Compose desteği yalnızca sunucuda açıksa görünür (/docs/tr/compose-migration).

Derleme dizini ve Dockerfile yolu ayarı sunucuda kapalı olabilir; bu yüzden örnekte tek bir kök Dockerfile ve APP_ROLE kullanılır. Alt dizin derlemesine güvenmeyin.

Aynı depoyu iki uygulama olarak yayınlamak depoyu iki kez derler; kaynaklar hizmetteki tüm uygulamalar arasında paylaşılır.

Örnekteki kuyruk bilerek basittir: çöken bir worker'ın running bıraktığı işleri bir zaman aşımıyla pending'e almak size aittir. Veritabanı yedekleri için /docs/tr/backups makalesine bakın.

Sonraki adımlar

Paketler ve güncel fiyatlar: https://deployvera.com/docker. Kalıcılık ve veritabanı davranışı için /docs/tr/persistence ve /docs/tr/plans-and-databases makalelerine bakın.