განათავსეთ Node.js აპლიკაცია Rivervo-ს ჰოსტინგზე (Next.js და Nuxt).
ბევრს ჰგონია, რომ 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 აპლიკაციების უმეტესობისთვის, რომლებსაც უზარმაზარი ტრაფიკი არ აქვთ, ეს გზამკვლევი სავსებით საკმარისია.
მოკლედ
npm run buildთქვენს კომპიუტერზე- ატვირთეთ
.next/(Next) ან.output/(Nuxt) +package.json+server.cjs - საიტი → Node.js და Python → Node.js აპლიკაცია → საქაღალდე, გაშვების ფაილი
server.cjs, რეჟიმი Production - დამოკიდებულებების დაყენება (npm install), შემდეგ გადატვირთვა
თუ რამე არასწორად მუშაობს, გახსენით მოთხოვნა — ჩასვით Passenger-ის შეცდომის გვერდი და ზუსტ ხაზს მიგითითებთ.
— Rivervo-ს გუნდი