დაწყება
ყველა სტატიაᲡᲐᲮᲔᲚᲛᲫᲦᲕᲐᲜᲔᲚᲝ · 6 წთ კითხვა

განათავსეთ Node.js აპლიკაცია Rivervo-ს ჰოსტინგზე (Next.js და Nuxt).

RT
Rivervo Team · Rivervo
·
29 აპრილი, 2026
·
განახლდა 13 ნოემბერი, 2026
Node
ON SHARED HOSTING

ბევრს ჰგონია, რომ Node.js აპლიკაციები მხოლოდ VPS-ზე უნდა იყოს. ეს ასე არ არის — Rivervo-ს ყველა გაზიარებულ ჰოსტინგის პაკეტში საიტის მენიუში არის Node.js და Python, რომელიც თქვენი აპლიკაციისთვის უშვებს Phusion Passenger-ის პროცესს იმავე Apache-ის უკან, რომელიც თქვენს სხვა საიტებს ემსახურება.

ეს გზამკვლევი მთელ პროცესს აღწერს ორი ყველაზე გავრცელებული ფრეიმვორკისთვის: Next.js და Nuxt 3. შედეგი: თქვენი აპლიკაცია მისამართზე https://tqvenidomeni.ge (ან ნებისმიერ ქვედომენზე), რეალურ Node.js პროცესზე, რომელიც გადატვირთვებს უძლებს და ერთი დაწკაპუნებით ხელახლა ეშვება.

თუ Node აპლიკაცია გაზიარებულ ჰოსტინგზე აქამდე არ განგითავსებიათ, ყველა გაშვების ფაილზე ჩერდება — Passenger-ს სჭირდება ერთი შესასვლელი სკრიპტი, რომელიც თქვენს ფრეიმვორკს უშვებს. ქვემოთ თითოეული ფრეიმვორკისთვის მზა ფაილს მოგაწვდით; დააკოპირეთ და ჩასვით, ცვლილებები საჭირო არ არის.

რა გჭირდებათ დაწყებამდე

  • Rivervo-ს ჰოსტინგის პაკეტი (ნებისმიერი — Node.js აპლიკაციები ყველა პაკეტზე მუშაობს)
  • Node.js v20 ან უფრო ახალი თქვენს კომპიუტერზე, აპლიკაციის ასაწყობად
  • აწყობილი აპლიკაცია, ატვირთვისთვის მზად (ამას ქვემოთ თითოეული ფრეიმვორკისთვის განვიხილავთ)
  • ფაილების მენეჯერზე ან SFTP-ზე წვდომა თქვენს ანგარიშზე (ორივე მუშაობს)

root, sudo, systemd ან reverse-proxy-ის კონფიგურაცია არ გჭირდებათ. ამ ყველაფერს Passenger აგვარებს.

ნაბიჯი 1 — ააწყვეთ აპლიკაცია თქვენს კომპიუტერზე

თქვენ ტვირთავთ აწყობილ აპლიკაციას და არა საწყის კოდს. პანელი დამოკიდებულებებს აყენებს, მაგრამ React-ს არ აკომპილირებს და Vite-ის აწყობას არ უშვებს. ეს ჯერ თქვენს კომპიუტერზე გააკეთეთ.

Next.js:

npm ci
npm run build

ეს ქმნის .next/-ს (აწყობილ შედეგს). აქ next start-ს ნუ გაუშვებთ — მას ცოტა ხანში გაშვების ფაილიდან გავუშვებთ.

Nuxt 3:

npm ci
npm run build

ეს ქმნის .output/-ს (Nuxt-ის უნივერსალური აწყობის საქაღალდეს). იგივე — ჯერ არაფერი გაუშვათ.

ნაბიჯი 2 — ატვირთეთ სწორი ფაილები

node_modules/-ის ატვირთვა საჭირო არ არის. დამოკიდებულებებს პანელი თავად დააყენებს. არც git და აწყობის ქეში გჭირდებათ.

ატვირთეთ ანგარიშზე, სასურველია public_html-ის გარეთ (მაგ. /home/<account>/myapp/). რატომ გარეთ? იმიტომ, რომ Passenger public_html-ს ავტომატურად URL-ის ძირზე მიაბამს და აპლიკაციის კოდის იქ განთავსება მას ყველასთვის ხილულს ხდის.

ფრეიმვორკიატვირთეთგამოტოვეთ
Next.js.next/, public/, package.json, package-lock.json, next.config.js, თქვენი server.cjs (ქვემოთ)node_modules/, .git/, .env.local
Nuxt 3.output/, package.json, package-lock.json, თქვენი server.cjs (ქვემოთ)node_modules/, .nuxt/, .git/, საწყისი pages/, components/

ფაილების ატვირთვის ორი გზა არსებობს:

  • საიტი → ფაილები → ატვირთეთ zip → გახსენით არქივი — ყველაზე მარტივია, თუ კავშირი არასტაბილური გაქვთ.
  • SFTP (FileZilla, Cyberduck, rsync) — უფრო სწრაფია განმეორებითი განთავსებისთვის. სერვერი, პორტი, მომხმარებელი და პაროლი მითითებულია გვერდზე საიტი → SSH და SFTP.

ნაბიჯი 3 — დაამატეთ გაშვების ფაილი

ამ ფაილს Passenger ასრულებს, როცა მოთხოვნა შემოდის. მოათავსეთ ის package.json-ის გვერდით, აპლიკაციის საქაღალდეში.

Next.js-ისთვის — server.cjs

const next = require('next')
const http = require('http')
 
const port = process.env.PORT || 3000
const dev = process.env.NODE_ENV !== 'production'
const app = next({ dev, dir: __dirname })
const handle = app.getRequestHandler()
 
app.prepare().then(() => {
  http.createServer((req, res) => handle(req, res)).listen(port, () => {
    console.log(`Next.js server listening on port ${port}`)
  })
})

რას აკეთებს:

  • ტვირთავს Next-ს და მიუთითებს მიმდინარე საქაღალდეზე (სადაც თქვენი .next/ და package.json არის).
  • ქმნის მოთხოვნების დამმუშავებელს Next-ის შიდა მარშრუტიზატორიდან.
  • უშვებს HTTP სერვერს იმ პორტზე, რომელსაც Passenger გამოყოფს (process.env.PORT).
  • ლოკალური ტესტირებისთვის იყენებს 3000-ს.

dev ავტომატურად განისაზღვრება NODE_ENV-დან — პანელში დააყენეთ Production რეჟიმი (ამას ნაბიჯ 4-ში გავაკეთებთ) და Next საწარმოო რეჟიმში იმუშავებს.

Nuxt 3-ისთვის — server.cjs

import('./.output/server/index.mjs').then(({ createApp }) => {
  createApp().then(({ app }) => {
    const port = process.env.PORT || 3000
    app.listen(port, () => {
      console.log(`Nuxt server listening on port ${port}`)
    })
  })
})

რას აკეთებს:

  • დინამიკურად აიმპორტებს Nuxt-ის .output/server/index.mjs-ს (შესასვლელ წერტილს, რომელსაც npm run build ქმნის).
  • createApp()-ით ქმნის H3 სერვერის ეგზემპლარს.
  • უსმენს Passenger-ის მიერ გამოყოფილ პორტს.

დინამიკური import() განზრახ არის გამოყენებული — .mjs მოდულების require() შეუძლებელია, მაგრამ .cjs ფაილს მათი დინამიკური იმპორტი შეუძლია. ეს ყველაზე სუფთა ვარიანტია, რომელიც Passenger-ის გამშვებში მუშაობს.

ნაბიჯი 4 — შექმენით აპლიკაცია პანელში

გახსენით თქვენი პროექტი → საიტი → Node.js და Python → Node.js აპლიკაცია.

ველიმნიშვნელობა
ვერსია20 ან უფრო ახალი
რეჟიმიProduction
საქაღალდეmyapp თქვენს საწყის საქაღალდეში (სადაც ფაილები ატვირთეთ)
მისამართიtqvenidomeni.ge (ან ქვედომენი, მაგ. app.tqvenidomeni.ge)
გაშვების ფაილიserver.cjs

დააჭირეთ შექმნა-ს. Node.js გარემო შეიქმნება საქაღალდეში ~/nodevenv/myapp/20/.

დამოკიდებულებების დაყენება

აპლიკაციის შექმნის შემდეგ დააჭირეთ მასზე დამოკიდებულებების დაყენება (npm install)-ს და თვალი ადევნეთ გამოსავალს. თუ შეცდომა მოხდა:

  • შეამოწმეთ, რომ package.json აპლიკაციის ძირეულ საქაღალდეშია (და არა ჩადგმულში).
  • Next.js-ისთვის: დარწმუნდით, რომ next არის dependencies-ში და არა devDependencies-ში (საწარმოო ინსტალაცია dev დამოკიდებულებებს გამოტოვებს).
  • Nuxt-ისთვის: nuxt თავადაც ჩვეულებრივი დამოკიდებულება უნდა იყოს.

გარემოს ცვლადების დამატება

აპლიკაციის პარამეტრები → გარემოს ცვლადები → ცვლადის დამატება. Production რეჟიმი უკვე აყენებს NODE_ENV=production-ს.

Next.js აპლიკაციებისთვის, რომლებიც მონაცემებს გაშვების დროს კითხულობენ (ბაზების URL-ები, API გასაღებები), დაამატეთ ისინი აქ. საიდუმლო მონაცემებით .env ფაილს ნუ ატვირთავთ — მათი სწორი ადგილი აპლიკაციის გარემოს ცვლადებია.

პარამეტრების შენახვა აპლიკაციას გადატვირთავს, ასე რომ ახალი ცვლადები მაშინვე ამოქმედდება.

ნაბიჯი 5 — შემოწმება

გახსენით აპლიკაციის URL. უნდა დაინახოთ თქვენი აპლიკაცია.

თუ Passenger-ის შეცდომის გვერდს ხედავთ, გაშალეთ ის და ჩახედეთ ბოლოში — თითქმის ყოველთვის იქ არის მკაფიო stack trace. ორი ყველაზე ხშირი შეცდომა:

Error: Cannot find module 'next' — npm install არ გაშვებულა ან არასწორ საქაღალდეში გაეშვა. ხელახლა დააჭირეთ დამოკიდებულებების დაყენება (npm install)-ს.

Error: ENOENT: no such file or directory, open '.next/...' — ატვირთეთ საწყისი კოდი, მაგრამ არა აწყობილი .next/ საქაღალდე. ააწყვეთ თქვენს კომპიუტერზე და ხელახლა ატვირთეთ.

როგორ განაახლოთ

გაიმეორეთ ნაბიჯები 1 და 2 და დააჭირეთ აპლიკაციაზე გადატვირთვა-ს. კონკრეტულად:

1. Build locally    npm run build
2. Upload          .next/ or .output/, plus any changed source/config
3. Panel          Restart the app

თუ package.json-ს ცვლით, გადატვირთვამდე დააჭირეთ დამოკიდებულებების დაყენება (npm install)-ს. ბრძანების ხაზი გირჩევნიათ? საიტი → ტერმინალი: აპლიკაციის ბარათზე ნაჩვენებია ბრძანება მის გარემოში შესასვლელად.

ხშირი პრობლემები

WebSocket-ები: Passenger მუშაობს HTTP/1.1-სა და HTTP/2-ზე. WebSocket-ზე გადასვლა მუშაობს Next.js-ისა და Nuxt-ის ჩაშენებული მარშრუტებისთვის. თუ ცალკე WebSocket სერვერს იყენებთ (ws, socket.io), ის იმავე პორტს იყენებს და იმავე server.cjs-ით ეშვება — დამატებითი კონფიგურაციის გარეშე.

ფაილების ატვირთვა / next.config.js-ის body-parser ლიმიტები: Passenger-ის მოთხოვნის ზომის ნაგულისხმევი ლიმიტი 10 MB-ია. თუ დიდ ფაილებს ტვირთავთ, გაზარდეთ passenger_max_request_size .htaccess-ით public_html-ში:

PassengerMaxRequestSize 52428800

(50 MB ბაიტებში.)

Cron ამოცანები: თუ აპლიკაციას ფონური ამოცანები სჭირდება (საინფორმაციო წერილების დაგზავნა, დაგეგმილი ექსპორტი), ნუ გაუშვებთ მათ ვებ-პროცესში. გამოიყენეთ საიტი → Cron ამოცანები Node სკრიპტის პირდაპირ გასაშვებად:

/home/<account>/nodevenv/myapp/20/bin/node /home/<account>/myapp/scripts/send-newsletter.js

პროცესის მეხსიერება: Passenger აპლიკაციას გადატვირთავს, თუ ის ანგარიშის RAM-ის ლიმიტს გადააჭარბებს (დამოკიდებულია პაკეტზე). ტიპური Next.js / Nuxt აპლიკაცია უმოქმედო მდგომარეობაში 100 MB-ზე ნაკლებს მოიხმარს. თუ ლიმიტს აღწევთ, process.memoryUsage()-ით გააანალიზეთ და მეხსიერების გაჟონვა მოძებნეთ, სანამ დაასკვნით, რომ უფრო დიდი პაკეტი გჭირდებათ.

საკუთარი დომენები და HTTPS: აპლიკაციისთვის მითითებულ მისამართს Passenger უკავშირდება. SSL ავტომატურია — დამატებითი კონფიგურაციის გარეშე. სხვა დომენისთვის ან ქვედომენისთვის ჯერ დაამატეთ ის გვერდზე საიტი → დომენები, შემდეგ კი აირჩიეთ აპლიკაციის მისამართად.

Node-ის ვერსია: სიაში ვერსია ჩანს ყველა დაყენებული ვერსია; შეცვალეთ ის აპლიკაციის პარამეტრებში.

როდის არ გამოვიყენოთ გაზიარებული ჰოსტინგი Node-ისთვის

პირდაპირ გეტყვით — Node.js გაზიარებულ ჰოსტინგზე შესანიშნავად მუშაობს პორტფოლიოებისთვის, ბლოგებისთვის, მარკეტინგული გვერდებისთვის, მცირე SaaS ფრონტენდებისთვის, შიდა ინსტრუმენტებისთვის. უჭირს:

  • მაღალი გამტარუნარიანობის API-ებს (მუდმივად >50 მოთხოვნა/წმ) — ანგარიშის CPU-ს ლიმიტს იგრძნობთ
  • WebSocket-ზე დაფუძნებულ აპლიკაციებს ათასობით ერთდროული კავშირით
  • აპლიკაციებს, რომლებიც სამუშაო პროცესებს ქმნიან (რიგების დამმუშავებლები, სკრეიპერები) — Passenger-ის პროცესების ლიმიტი ანგარიშზე ამას მოუხერხებელს ხდის
  • ყველაფერს, რასაც systemd, Docker ან root წვდომა სჭირდება

ასეთი შემთხვევებისთვის სწორი არჩევანია ჩვენი VPS — სრული root წვდომა, საკუთარი ბირთვი, გაუშვით რაც გსურთ. მაგრამ Next.js და Nuxt აპლიკაციების უმეტესობისთვის, რომლებსაც უზარმაზარი ტრაფიკი არ აქვთ, ეს გზამკვლევი სავსებით საკმარისია.

მოკლედ

  1. npm run build თქვენს კომპიუტერზე
  2. ატვირთეთ .next/ (Next) ან .output/ (Nuxt) + package.json + server.cjs
  3. საიტი → Node.js და Python → Node.js აპლიკაცია → საქაღალდე, გაშვების ფაილი server.cjs, რეჟიმი Production
  4. დამოკიდებულებების დაყენება (npm install), შემდეგ გადატვირთვა

თუ რამე არასწორად მუშაობს, გახსენით მოთხოვნა — ჩასვით Passenger-ის შეცდომის გვერდი და ზუსტ ხაზს მიგითითებთ.

— Rivervo-ს გუნდი